Project import
diff --git a/.mailmap b/.mailmap
new file mode 100644
index 0000000..aebe06f
--- /dev/null
+++ b/.mailmap
@@ -0,0 +1,5 @@
+Luiz Augusto von Dentz <luiz.dentz-von@nokia.com> <luiz.dentz-von@nokia.com>
+Leena Gunda <leena.gunda@wipro.com> <leena.gunda@wipro.com>
+Flávio Ceolin <flavio.ceolin@profusion.mobi> <flavio.ceolin@profusion.mobi>
+Daniel Wagner <daniel.wagner@bmw-carit.de> <daniel.wagner@bmw-carit.de>
+Zhang Zhengguang <zhengguang.zhang@intel.com> <zhengguang.zhang@intel.com>
diff --git a/AUTHORS b/AUTHORS
new file mode 100644
index 0000000..7f95df0
--- /dev/null
+++ b/AUTHORS
@@ -0,0 +1,93 @@
+Marcel Holtmann <marcel@holtmann.org>
+Inaky Perez-Gonzalez <inaky@linux.intel.com>
+Samuel Ortiz <sameo@linux.intel.com>
+Joshua Lock <josh@linux.intel.com>
+Richard Purdie <rpurdie@linux.intel.com>
+Gustavo Sverzut Barbieri <barbieri@profusion.mobi>
+Martin Xu <martin.xu@intel.com>
+Sam Leffler <sleffler@google.com>
+Daniel Wagner <daniel.wagner@bmw-carit.de>
+Forest Bond <forest@alittletooquiet.net>
+Kalle Valo <kalle.valo@canonical.com>
+Fabien Marotte <fabienx.marotte@linux.intel.com>
+Pekka Pessi <pekka.pessi@nokia.com>
+Tomasz Bursztyka <tomasz.bursztyka@linux.intel.com>
+Cristiano Fernandes <cristiano.fernandes@hp.com>
+Joey Lee <jlee@novell.com>
+Leena Gunda <leena.gunda@wipro.com>
+Patrik Flykt <patrik.flykt@linux.intel.com>
+David Woodhouse <dwmw2@infradead.org>
+Gustavo Padovan <gustavo@padovan.org>
+Julien Massot <jmassot@aldebaran-robotics.com>
+Jukka Rissanen <jukka.rissanen@linux.intel.com>
+Grant Erickson <marathon96@gmail.com>
+Guillaume Lucas <guillaumex.lucas@intel.com>
+Henri Bragge <henri.bragge@ixonos.com>
+Alok Barsode <alok.barsode@intel.com>
+Sébastien Bianti <sebastien.bianti@linux.intel.com>
+Yu A Wang <yu.a.wang@intel.com>
+Thierry Boureille <thierry.boureille@gmail.com>
+Paolo Pellegrino <paolo.pellegrino@zirak.it>
+Bertrand Aygon <bertrand.aygon@intel.com>
+Jeff Zheng <jeff.zheng@intel.com>
+Philippe Nunes <philippe.nunes@linux.intel.com>
+Danny Jeongseok Seo <s.seo@samsung.com>
+Flávio Ceolin <flavio.ceolin@profusion.mobi>
+Arjan van de Ven <arjan@linux.intel.com>
+Daniel Mack <zonque@gmail.com>
+Guillaume Zajac <guillaume.zajac@linux.intel.com>
+Manfred Kober <manfred.kober@gmx.de>
+Mario Domenech Goulart <mario.goulart@gmail.com>
+Otavio Salvador <otavio@ossystems.com.br>
+Tim Sander <tim01@iss.tu-darmstadt.de>
+Adrien Bustany <adrien.bustany@nokia.com>
+Henrique Dante de Almeida <hdante@profusion.mobi>
+Lucas De Marchi <lucas.demarchi@profusion.mobi>
+Elena Tebesoi <elena.tebesoi@gmail.com>
+Mikel Astiz <mikel.astiz@bmw-carit.de>
+Paulo Pizarro <paulo.pizarro@gmail.com>
+Ross Burton <ross.burton@intel.com>
+Tudor Marcu <tudor.a.marcu@intel.com>
+Ceara Chewning <ceara.k.chewning@intel.com>
+Johannes Berg <johannes.berg@intel.com>
+Justin Maggard <jmaggard10@gmail.com>
+Yann E. Morin <yann.morin.1998@free.fr>
+Constantin Musca <constantinx.musca@intel.com>
+Terry Simons <terry.simons@gmail.com>
+Luciano Coelho <luciano.coelho@intel.com>
+Peter Meerwald <pmeerw@pmeerw.net>
+Chengyi Zhao <chengyix.zhao@gmail.com>
+Tysen Moore <tysen.moore@xs-embedded.com>
+Bastien Nocera <hadess@hadess.net>
+Michael Ikey Doherty <michael.i.doherty@intel.com>
+Mateusz Potrola <mateuszx.potrola@intel.com>
+Jaehyun Kim <jeik01.kim@samsung.com>
+Zhang Zhengguang <zhengguang.zhang@intel.com>
+Sjoerd Simons <sjoerd.simons@collabora.co.uk>
+Alban Crequy <alban.crequy@collabora.co.uk>
+Philippe Coval <philippe.coval@open.eurogiciel.org>
+Hannu Mallat <hannu.mallat@jollamobile.com>
+Glenn Schmottlach <Glenn.Schmottlach@xs-embedded.com>
+Jonathan Liu <net147@gmail.com>
+Andrew LeCain <electricalpanel@gmail.com>
+Maneesh Jain <maneesh.jain@samsung.com>
+Eduardo Abinader <eduardo.abinader@openbossa.org>
+Guoqiang Liu <guoqiang.liu@archermind.com>
+Eric Bouxirot <eric.bouxirot@azimut-monitoring.com>
+Alexandru Costache <alexandrux.costache@intel.com>
+Pasi Sjöholm <pasi.sjoholm@jolla.com>
+Mario Schuknecht <mario.schuknecht@dresearch-fe.de>
+Slava Monich <slava.monich@jolla.com>
+Aaron McCarthy <aaron.mccarthy@jolla.com>
+Saurav Babu <saurav.babu@samsung.com>
+David Lechner <david@lechnology.com>
+Jason Abele <jason@aether.com>
+Erik Larsson <erik@ortogonal.com>
+Chris Hiszpanski <chris@kunasystems.com>
+Tomáš Čech <sleep_walker@suse.cz>
+Philip Withnall <philip@tecnocode.co.uk>
+Andreas Oberritter <obi@opendreambox.org>
+Arman Uguray <armansito@chromium.org>
+Vinicius Costa Gomes <vcgomes@gmail.com>
+Marcus Folkesson <marcus.folkesson@gmail.com>
+Michael Olbrich <m.olbrich@pengutronix.de>
diff --git a/COPYING b/COPYING
new file mode 100644
index 0000000..6d45519
--- /dev/null
+++ b/COPYING
@@ -0,0 +1,340 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+ 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The licenses for most software are designed to take away your
+freedom to share and change it. By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users. This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it. (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.) You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+ To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have. You must make sure that they, too, receive or can get the
+source code. And you must show them these terms so they know their
+rights.
+
+ We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+ Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software. If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+ Finally, any free program is threatened constantly by software
+patents. We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary. To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ GNU GENERAL PUBLIC LICENSE
+ TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License. The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language. (Hereinafter, translation is included without limitation in
+the term "modification".) Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope. The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+ 1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+ 2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+ a) You must cause the modified files to carry prominent notices
+ stating that you changed the files and the date of any change.
+
+ b) You must cause any work that you distribute or publish, that in
+ whole or in part contains or is derived from the Program or any
+ part thereof, to be licensed as a whole at no charge to all third
+ parties under the terms of this License.
+
+ c) If the modified program normally reads commands interactively
+ when run, you must cause it, when started running for such
+ interactive use in the most ordinary way, to print or display an
+ announcement including an appropriate copyright notice and a
+ notice that there is no warranty (or else, saying that you provide
+ a warranty) and that users may redistribute the program under
+ these conditions, and telling the user how to view a copy of this
+ License. (Exception: if the Program itself is interactive but
+ does not normally print such an announcement, your work based on
+ the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole. If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works. But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+ 3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+ a) Accompany it with the complete corresponding machine-readable
+ source code, which must be distributed under the terms of Sections
+ 1 and 2 above on a medium customarily used for software interchange; or,
+
+ b) Accompany it with a written offer, valid for at least three
+ years, to give any third party, for a charge no more than your
+ cost of physically performing source distribution, a complete
+ machine-readable copy of the corresponding source code, to be
+ distributed under the terms of Sections 1 and 2 above on a medium
+ customarily used for software interchange; or,
+
+ c) Accompany it with the information you received as to the offer
+ to distribute corresponding source code. (This alternative is
+ allowed only for noncommercial distribution and only if you
+ received the program in object code or executable form with such
+ an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it. For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable. However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+ 4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License. Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+ 5. You are not required to accept this License, since you have not
+signed it. However, nothing else grants you permission to modify or
+distribute the Program or its derivative works. These actions are
+prohibited by law if you do not accept this License. Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+ 6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions. You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+ 7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all. For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices. Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+ 8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded. In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+ 9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number. If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation. If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+ 10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission. For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this. Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+ NO WARRANTY
+
+ 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+ 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+ Gnomovision version 69, Copyright (C) year name of author
+ Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary. Here is a sample; alter the names:
+
+ Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+ `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+ <signature of Ty Coon>, 1 April 1989
+ Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs. If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library. If this is what you want to do, use the GNU Library General
+Public License instead of this License.
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..11e08cd
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,1015 @@
+ver 1.29:
+ Fix issue with IPv6 autoconfiguration when disabled.
+ Fix issue with IPv6 temporary route handling.
+ Fix issue with IPv6 timers for nameservers.
+ Fix issue with DHPCv6 and route configuration.
+ Fix issue with DHCPv6 source port and buggy servers.
+ Fix issue with DHCPv6 rapid commit option length.
+ Fix issue with DHCPv6 rapid commit error handling.
+ Fix issue with handling invalid WiFi passphrases.
+ Fix issue with connecting Ethernet devices.
+ Add support for Ethernet and VLAN usage.
+
+ver 1.28:
+ Fix issue with DHCPv6 re-transmission timer.
+ Fix issue with DHCP service ID option byte order.
+ Fix issue with IPv6 connections and SLAAC/DHCPv6.
+ Fix issue with telephony and IPv6 autoconfiguration.
+ Fix issue with Bluetooth technology setting changes.
+ Fix issue with WiFi autoscan interval calculation.
+ Fix issue with WiFi and missing BSS signal strength.
+ Add support for IPv4 information for WiFi Display.
+
+ver 1.27:
+ Fix issue with memory leak in IP configuration.
+ Fix issue with providing random numbers for DHCP.
+ Fix issue with handling IN_MOVED_TO inotify events.
+ Fix issue with channel selection for WiFi scanning.
+ Add support for handling Bluetooth GN and PANU roles.
+
+ver 1.26:
+ Fix issue with missing WiFi security provisioning support.
+ Fix issue with immutable setting and provisioned services.
+ Fix issue with scheduling DNS cache cleanup procedure.
+ Fix issue with IPv6 Privacy setting on service removal.
+ Fix issue with DHCPv6 CONFIRM message sending procedure.
+ Fix issue with DHCPv6 lease expiration handling support.
+ Fix issue with DHCPv4 networks and broadcast flag handling.
+ Fix issue with DHCPv4 networks without gateway configuration.
+ Fix issue with P2P Peer authorization handling.
+ Fix issue with P2P Peer service registration.
+ Add support for WiFi Display information elements.
+ Add support for systemd-hostnamed integration.
+
+ver 1.25:
+ Fix issue with handling rebind timer for DHCPv6.
+ Fix issue with handling DHCP renew transaction.
+ Fix issue with user supplied proxy settings and DHCP.
+ Fix issue with extra status codes from captive portals.
+ Fix issue with service idle state reset on failure.
+ Fix issue with DNS label compression handling.
+ Add support for experimental P2P Peer service.
+
+ver 1.24:
+ Fix issue with handling slave interfaces.
+ Fix issue with handling DHCPv4 broadcast flag.
+ Fix issue with handling DHCPv4 lease expiration.
+ Fix issue with handling WiFi auto-scanning timeout.
+ Fix issue with handling domain and DNS server changes.
+ Fix issue with double free and agent messages.
+
+ver 1.23:
+ Fix issue with memory leak in technology handling.
+ Fix issue with not removing host route of OpenVPN.
+ Fix issue with double free in DHCP cleanup handling.
+ Fix issue with handling DHCP method from oFono.
+ Fix issue with IPv6-PD when disabling tethering.
+ Fix issue with DNS proxy when disabling tethering.
+ Fix issue with Bluetooth start and stop interaction.
+ Fix issue with Bluetooth PAN networks on adapter change.
+
+ver 1.22:
+ Fix issue with WPS state synchronization.
+ Fix issue with DNS servers and default service.
+ Fix issue with DHCP client and rebooting state.
+ Add support for NTP exponential backoff handling.
+ Add support for NTP kiss-of-death packet handling.
+ Add support for Ethernet gadget networking.
+
+ver 1.21:
+ Fix issue with WiFi networks and zero SSID length.
+ Fix issue with security details for hidden WiFi networks.
+ Fix issue with handling IPv6 proxy address resolving.
+ Fix issue with enabling Bluetooth controllers.
+
+ver 1.20:
+ Fix issue with invalid cache of DNS proxy support.
+ Fix issue with stopping DHCP for failed connections.
+ Fix issue with not stopping IPv4 Link-Local state machine.
+ Fix issue with service type handling for unknown interfaces.
+ Fix issue with using interface names instead of indexes.
+ Fix issue with resetting network retry counter on failure.
+ Fix issue with using nameservers when its type is not enabled.
+ Fix issue with fallback nameservers not being used.
+ Add support for NTP version 3 protocol.
+
+ver 1.19:
+ Fix issue with not correctly storing IPv4 method.
+ Fix issue with changing the default service too early.
+ Fix issue with service reference count and WISPr checks.
+ Fix issue with service auto-connect handling and ordering.
+ Fix issue with host and domain names when service changes.
+ Fix issue with proxy result and WISPr handling.
+ Fix issue with proxy reset when disconnecting.
+ Fix issue with handling fallback nameservers.
+ Add support for multiple agents.
+
+ver 1.18:
+ Fix issue with alignment calculation for iptables.
+ Fix issue with WEP key index parameter handling.
+ Fix issue with handling of 802.1x credentials.
+ Fix issue with command line parameter parsing.
+ Add support for completion handling in client tool.
+
+ver 1.17:
+ Fix issue with handling consecutive WiFi scanning.
+ Fix issue with WiFi handling and RFKILL soft block.
+ Fix issue with handling external RFKILL events.
+ Fix issue with handling USB gadget devices.
+ Fix issue with network reference handling.
+ Fix issue with byte order and DHCP discover options.
+ Fix issue with DHCP retry handling during IPv4-LL.
+ Fix issue with DHCPv6 rebind handling.
+ Add support for DHCPv6 decline message handling.
+ Add support for DHCPv6 duplicate address detection.
+
+ver 1.16:
+ Fix issue with missing signals during connection changes.
+ Fix issue with missing notification of proxy properties.
+ Fix issue with missing DHCPv6 domain list option.
+ Fix issue with missing DHCPv6 release message.
+ Fix issue with missing DHCPv6 error handling.
+ Fix issue with wrong IPCMv6 checksum calculation.
+ Fix issue with wrong service disconnect state.
+ Fix issue with failure to enable offline mode.
+ Add support for Netfilter Accounting (NFACCT).
+ Add support for IPv6 prefix delegation handling.
+
+ver 1.15:
+ Fix issue with missing cleanup for IPv4-LL handling.
+ Fix issue with missing property update for domain names.
+ Fix issue with scanning for all stored hidden WiFi networks.
+ Fix issue with time server polling for non-default service.
+ Fix issue with persistent storage of time configuration.
+
+ver 1.14:
+ Fix issue with WiFi scanning race condition and power cycle.
+ Add support for configuring allowed tethering technologies.
+ Add support for persistent tethering configurations.
+ Add support for DHCPv6 max retransmission duration option.
+ Add support for DHCPv6 elapsed time option.
+ Add support for DHCPv6 confirm messages.
+
+ver 1.13:
+ Fix issue with auto-scanning of known hidden SSIDs.
+ Fix issue with not correctly terminated auto-scanning.
+ Fix issue with missing enforcing of immutable services.
+ Fix issue with missing handling of multiple connection attempts.
+ Fix issue with missing WISPr restart after nameserver change.
+ Fix issue with missing provisioning for IP address method.
+ Fix issue with missing IP configuration signal on disconnect.
+ Fix issue with DNS proxy and memory leaks on request timeouts.
+ Fix issue with DNS proxy and handling partial TCP messages.
+ Fix issue with DNS proxy and handling of EDNS0 buffers.
+ Fix issue with DNS proxy and handling of IPv6 loopback.
+ Fix issue with DNS proxy listening on all interfaces.
+ Fix issue with CDMA network creation.
+
+ver 1.12:
+ Fix issue with overwriting gateway address.
+ Fix issue with missing IP address validation.
+ Fix issue with parsing of IPv6 configuration settings.
+ Fix issue with DHCP server address stored in host order.
+ Fix issue with resolver query failures and pending results.
+ Fix issue with wrongly reported max scan SSID parameter.
+ Fix issue with handling errors from WiFi fast scanning.
+ Add support for WiFi provisioning via NFC.
+ Add support for VPN daemon provisioning.
+ Add support for Ethernet provisioning.
+
+ver 1.11:
+ Fix issue with agent reference counting imbalance.
+ Fix issue with handling max number of SSID for scanning.
+ Fix issue with missing notification of online state changes.
+ Fix issue with not properly triggering auto-connect behavior.
+ Fix issue with disabling IPv6 in lower up interface states.
+ Fix issue with spurious error messages for interface handling.
+ Fix issue with wrong answer count in DNS responses.
+ Fix issue with crash in DNS lookup function.
+ Add support for BlueZ 5.x network interfaces.
+ Remove deprecated WiMAX support.
+
+ver 1.10:
+ Fix issue with not skipping service if settings loading fails.
+ Fix issue with not clearing address before starting DHCP.
+ Fix issue with not handling removal of GPRS context.
+ Fix issue with not closing UDP socket on error condition.
+ Fix issue with race condition when removing WiFi device.
+ Add support for separate VPN daemon.
+
+ver 1.9:
+ Fix issue with WISPr portal context handling.
+ Fix issue with DNS lookup from wrong queue.
+ Fix issue with DNS data reception after disconnect.
+ Fix issue with missing DNS host part length checking.
+ Fix issue with RFKILL and technology interaction.
+ Fix issue with tethering and disabled technologies.
+ Add support for single connected technology setting.
+
+ver 1.8:
+ Fix issue with NTP transmit time calculation.
+ Fix issue with WiFi Tethering and newer kernels.
+ Fix issue with Netlink messages from Wireless Extensions.
+ Fix issue with IPv6 nameserver refresh beeing applied to IPv4.
+ Fix issue with overwriting DNS proxy address information.
+ Fix issue with missing handling of RFKILL hard blocking.
+ Add support for disabling internal backtrace functionality.
+
+ver 1.7:
+ Fix issue with IPv4 address removal when setting interface down.
+ Fix issue with wrong error when setting tethering support option.
+ Fix issue with errors reported twice via agent to the client.
+ Fix issue with missing serialization of agent callbacks.
+ Add initial version of command line client tool.
+
+ver 1.6:
+ Fix issue with Bluetooth networking support.
+ Fix issue with technology enabling method returns.
+ Fix issue with wrong IP address for fixed configurations.
+ Fix issue with IP address setting when interface is down.
+ Fix issue with handling duplicate hidden WiFi networks.
+ Fix issue with missing scanning for hidden WiFi networks.
+ Fix issue with missing update of service properties.
+ Fix issue with missing clearing of service errors.
+ Add manual pages for daemon and configuration file.
+
+ver 1.5:
+ Fix issue with detecting Bluetooth networks when powered off.
+ Fix issue with connection attempts of non-favorite services.
+ Fix issue with connection attempts of disabled IP configurations.
+ Fix issue with missing auto-connection after changing IP method.
+ Fix issue with setting service state when changing IPv4 method.
+ Fix issue with IPv6 usage and static/manual configuration.
+ Add support for configuration option to disable hostname updates.
+ Add support for storing WiFi Tethering identifier and passphrase.
+ Add support for signaling changes of error property.
+
+ver 1.4:
+ Fix issue with WiFi scanning in Tethering mode.
+ Fix issue with WISPr operation and disconnects.
+ Fix issue with DHCP client and restart behavior.
+ Fix issue with DNS resolving and failing IPv6 records.
+ Fix issue with incorrect NTP leap-not-in-sync flag.
+ Fix issue with incorrect NTP transmit time value.
+ Fix issue with failing NTP server due to routing.
+ Fix issue with missing gateway change notification.
+ Fix issue with stale network interfaces at startup.
+ Fix issue with pending method reply and agent errors.
+ Add support for providing previous WPS PIN to agent.
+ Add support for WPA supplicant based auto-scanning.
+ Add support for per device regulatory domain setting.
+ Add support for provisioning hidden WiFi networks.
+
+ver 1.3:
+ Fix issue with default configuration values.
+ Fix issue with timeserver canonical name entries.
+ Fix issue with crash from cellular dummy context.
+ Fix issue with incorrect index for private networks.
+
+ver 1.2:
+ Fix issue with not handling WiFi security changes.
+ Fix issue with not stopping WiFi scanning on shutdown.
+ Fix issue with auto-scanning and network discovery.
+ Fix issue with D-Bus reply for hidden WiFi networks.
+ Fix issue with overlapping memory areas and DNS requests.
+ Add support for randomized DNS transaction identifiers.
+ Add support for DNS caching over TCP connections.
+ Add support for using default IPv6 privacy setting.
+ Add support for providing previous passphrase to agent.
+ Add support for configuration unprovisioning handling.
+ Add support for NetworkInterfaceBlacklist configuration.
+ Add support for Bluetooth DUN daemon (dundee).
+
+ver 1.1:
+ Fix issue with missing message type and DHCPv4 support.
+ Fix issue with potential NULL pointer in DHCPv6 handling.
+ Fix issue with potential NULL pointer in VPN handling.
+ Fix issue with potential NULL pointer for WiFi SSID.
+ Fix issue with missing conversion of raw WiFi PSK input.
+ Fix issue with missing stop for WiFi auto-scanning handling.
+ Fix issue with uninitialized IPv6 prefix length in oFono plugin.
+ Fix issue with domain search list handling according to RFC 6106.
+ Fix issue with domain name list notifications.
+ Fix issue with nameserver list notifications.
+ Fix issue with incorrect fixed IP configuration.
+ Fix issue with incorrect cleanup of resolver timers.
+ Fix issue with handling of RDNSS lifetime expiration.
+ Fix issue with crash on wrong domain length information.
+ Add support for favorite service database migration.
+ Add support for disabling WISPr functionality.
+ Add support for configurable agent timeouts.
+
+ver 1.0:
+ Fix issue with missing WiFi disconnecting flag.
+ Fix issue with missing GPRS context attached check.
+ Fix issue with potential crash and supplicant handling.
+ Fix issue with potential crash and VPN provider.
+ Fix issue with potential crash and host routes.
+
+ver 0.85:
+ Fix issue with duplicate service timeservers.
+ Fix issue with failure state when aborting agent request.
+ Fix issue with automatic scanning for hidden WiFi networks.
+ Fix issue with missing hostname/domainname validity checks.
+ Fix issue with missing DHCP packet length checks.
+ Add support for browser launching from WISPr login.
+
+ver 0.84:
+ Fix issue with handling changed WiFi security of access points.
+ Fix issue with state notification of NetworkManager compatibility.
+
+ver 0.83:
+ Fix issue with Ethernet not being enabled by default.
+ Fix issue with missing host routes for WISPr request.
+ Fix issue with missing HTTPS handling for WISPr support.
+ Fix issue with agent asking for passphrase for open service.
+ Fix issue with endless online check for preferred technology.
+ Fix issue with IPv6 RDNSS and DNS server creation.
+ Fix issue with WiFi roaming state change handling.
+ Fix issue with broken handling of WPS PBC method.
+
+ver 0.82:
+ Fix issue with global online state handling.
+ Fix issue with timeserver handling in case of VPN.
+ Fix issue with automatic WiFi scanning handling.
+ Fix issue with WPS PIN length of zero and PBC.
+
+ver 0.81:
+ Update default configuration options.
+ Add support for WPS PBC advertising handling.
+ Add support for wpa_supplicant background scanning.
+ Fix issue with showing cellular services without APN.
+ Fix issue with missing timeservers changed signal.
+
+ver 0.80:
+ Update to support additional D-Bus API changes.
+ Add support for preferred technologies switching.
+ Add support for default auto connect technologies option.
+ Add support for service specific timeserver configuration.
+ Add support for extended timeserver fallback functionality.
+ Add support for extended nameserver fallback functionality.
+ Add support for user supplied routes for providers.
+ Add support for checking WiFi passphrase validity.
+ Fix issue with WISPr support and proxy handling.
+ Fix issue with Ethernet and auto connect handling.
+ Fix issue with too early IPv6 auto connection.
+ Fix issue with too early 6to4 connection checks.
+ Fix issue with oFono interaction on disconnect.
+ Fix issue with DNS servers behind point-to-point links.
+ Fix issue with pending DNS proxy requests.
+ Fix multiple issues with VPN handling.
+ Fix multiple issues with default gateway handling.
+
+ver 0.79:
+ Update to support changed D-Bus API.
+ Add support for WiFi background scanning.
+ Add support for showing hidden WiFi networks as services.
+ Add support for generic stateless DHCPv6 handling.
+ Add support for DHCPv4 client identifier handling.
+ Add support for generic IP address pool handling.
+ Add support for global DNS cache handling.
+ Add support for internal NTP time handling.
+ Add support for updated oFono handling.
+
+ver 0.78:
+ Fix multiple issues with service connection states.
+ Fix multiple issues with technology handling.
+ Fix issue with DHCP file descriptor leakage.
+ Fix issue with open access points and WPS.
+ Fix issue with handling of cellular devices.
+ Fix issue with DNS proxy hostname resolving.
+ Add support for PPTP and L2TP VPN tunneling.
+ Add support for organized settings storage.
+ Add support for WiFi fast connect handling.
+ Add support for better WiFi error handling.
+ Add support for integrated WISPr handling.
+
+ver 0.77:
+ Fix issue with iptables API breakage.
+ Fix issue with agent input handling.
+ Fix issue with empty cellular operator name.
+ Fix issue with reference counting for network objects.
+ Fix issue with missing D-Bus signals for proxy changes.
+ Fix issue with group identifier and hidden WiFi networks.
+ Fix issue with setting wrong gateway for PPP connections.
+ Fix issue with mismatch of stored IP configuration settings.
+ Fix issue with not stopping DHCP for IPv4 configuration.
+ Add support for remembering last IP address from DHCP.
+ Add support for EAP-GTC authentication method.
+
+ver 0.76:
+ Fix issue with loopback interface setup.
+ Fix issue with /etc/localtime being a symlink.
+ Fix issue with not handling dummy network devices.
+ Fix issue with not provisioning existing services.
+ Fix issue with running WPAD on IPv6 connections.
+ Fix issue with client certificate for TTLS/PEAP.
+ Remove internal element infrastructure.
+
+ver 0.75:
+ Fix issue with 3G connect timeout handling.
+ Fix issue with WiFi raw key PSK handling.
+ Fix issue with DHCP renewal timeout handling.
+ Fix issue with DHCP and empty nameserver list.
+ Add support for unit testing.
+
+ver 0.74:
+ Fix issue with race condition in ready/online handling.
+ Fix issue with DHCP release callback handling.
+ Fix multiple issues with session API handling.
+ Add support for using DNS proxy for Tethering.
+ Add support for Private Network API.
+ Add support for Clock API.
+
+ver 0.73:
+ Update support for session API handling.
+ Add support for more advanced roaming policies.
+ Add support for EAP identity and passphrase queries.
+ Add support for IPv6 handling with cellular bearer.
+ Add support for main configuration file.
+ Remove deprecated profile interface.
+
+ver 0.72:
+ Fix issue with overwriting DNS servers from DHCP.
+ Fix issue with DHCP renewal with same configuration.
+ Fix issue with multiple memory leaks.
+ Add support for 6to4 tunneling.
+
+ver 0.71:
+ Fix issue with not storing IPv6 privacy settings.
+ Fix issue with storing fixed and manual IP settings.
+ Fix issue with service state when PAN connection fails.
+ Fix issue with tethering and WiFi bridge handling.
+ Fix issue with autonomously activated contexts.
+ Fix issue with nameserver array for PACrunner.
+ Fix issue with network information memory leak.
+ Fix issue with double-free in statistics handling.
+ Fix issue with handling malformed profiles.
+ Fix issue with pending DHCP client requests.
+ Add initial support for TI shared transport handling.
+
+ver 0.70:
+ Add support for reporting invalid WiFi passphrases.
+ Add support for IPv6 privacy extension.
+ Add support for IPv6 advanced features.
+ Add support for IPv6 nameserver settings.
+ Remove deprecated APN service settings.
+
+ver 0.69:
+ Fix issue with not handling DNS proxy failures gracefully.
+ Fix issue with double free in statistics handling.
+ Fix issue with early tethering bridge creation.
+ Add support for tethering property per technology.
+ Add support for initial WiFi tethering feature.
+ Add support for using PACrunner as proxy driver.
+ Add support for WPS as part of the security property.
+
+ver 0.68:
+ Fix issue with wrong name of PolicyKit configuration file.
+ Fix issue with inconsistency of WiFi scan states.
+ Fix issue with missing auto-reconnect and oFono.
+ Add support for vpnc based private networks.
+ Add support for WiFi Protected Setup handling.
+ Remove legacy WiFi plugin.
+
+ver 0.67:
+ Fix issue with oFono plugin and multiple online calls.
+ Fix issue with checking for AutoConnect service property.
+ Remove deprecated MCC and MNC service properties.
+
+ver 0.66:
+ Fix multiple set of memory leaks.
+ Fix issue with WPA supplicant phase2 values.
+ Fix issue with WiFi access points after kill/restart.
+ Fix issue with correct PACrunner configuration loading.
+ Add support for loading provision files at runtime.
+ Add support for setting proxy auto-configuration.
+ Add support for IPv6 auto-configured addresses.
+
+ver 0.65:
+ Use new WiFi plugin by default.
+ Fix issue with handling already powered devices.
+ Fix issue with handling proxy PAC option from DHCP.
+ Add support for handling regulatory domain settings.
+ Add support for handling IPv6 router advertisements.
+ Add support for handling IPv6 nameservers.
+ Add support for handling multiple search domains.
+ Add support for handling oFono modem lockdown.
+ Add support for handling IPv6 DNS connections.
+ Add support for IPv4 Link-Local negotiation.
+ Add support for USB CDC Tethering functionality.
+
+ver 0.64:
+ Update service name to net.connman domain.
+ Fix issue with disabling a technology twice.
+ Fix issue with using wrong string for Proxy.Method.
+ Fix issue with TCP connection lookup and DNS proxy.
+ Fix issue with TCP receive busy waits and DNS proxy.
+ Fix various issues with WPA Supplicant interaction.
+ Add support for chunk encoding to HTTP client.
+ Add support for internal HTTP client for portal detection.
+ Add support for internal DHCP server setup.
+ Add support for internal NAT and IP forwarding setup.
+ Add support for Bluetooth Tethering functionality.
+ Remove deprecated device and network D-Bus interfaces.
+ Remove support for dhclient plugin.
+
+ver 0.63:
+ Change to use nl80211/cfg80211 WiFi management by default.
+ Fix various issues with new WPA Supplicant interface.
+ Fix issue with not connecting failed networks at boot.
+ Fix issue with properly tracking RFKILL blocked state.
+ Fix issue with missing signals for IPv4/IPv6 gateway details.
+ Add support for using RTNL for setting IPv4/IPv6 details.
+ Add support for using PHONET_PIPE GPRS interfaces.
+ Add support for setting manual proxy configurations.
+ Add support for exporting proxy configurations to PACrunner.
+ Add support for combined home and roaming statistics.
+ Add support for OpenVPN connections.
+ Remove dependency on udev.
+
+ver 0.62:
+ Fix crash with non-existent or extra DHCP result options.
+ Fix crash when doing PEAP/TTLS authentication.
+ Fix issue with handling multiple data counters.
+ Fix issue with Bluetooth adapters without address.
+ Fix issue with multiple scanning attempts after disconnects.
+ Fix issue with VPN services when switching into offline mode.
+ Add support for storing statistics information in separate files.
+ Add support for verification of configuration file parameters.
+ Add support for handling time server values from DHCP.
+ Add support for allowing DNS over TCP within the DNS proxy.
+ Add support for loading proxy configurations into PACrunner.
+ Add support for WiFi plugin using new WPA Supplicant D-Bus API.
+ Add support for requesting passphrases via agents.
+ Remove default support for EDNS0 option.
+
+ver 0.61:
+ Add support for using the internal DHCP client by default.
+ Add support for latest PolicyKit framework.
+ Add support for new oFono D-Bus interfaces.
+
+ver 0.60:
+ Fix issue with missing reset of proxy settings.
+ Fix issue with missing Ethernet property changed signal.
+ Fix issue with offline operation on already blocked devices.
+ Fix issue with offline mode and device powered changes.
+ Fix issue with portal detection and DHCP renewals.
+ Fix issue with connection attempts for removed networks.
+ Fix issue with stale pointers of networks.
+
+ver 0.59:
+ Fix issue with D-Bus object paths of VPN providers.
+
+ver 0.58:
+ Fix various issues around offline mode.
+ Fix various issues with VPN nameserver handling.
+ Add support for home/roaming network statistics.
+ Add support for EAP-TTLS WiFi configuration.
+ Add support for creating backtraces.
+
+ver 0.57:
+ Fix missing default profile creation.
+ Fix missing service integration of VPN providers.
+ Fix missing export of PAC information retrieved from DHCP.
+ Fix issue with detection of new Bluetooth devices.
+ Fix issue with offline mode handling.
+ Fix issue with device power handling.
+
+ver 0.56:
+ Fix issues with offline mode handling.
+ Fix service integration with VPN providers.
+ Add internal asynchronous resolver library.
+ Add internal DHCP client library.
+ Add support for using internal DHCP client.
+ Add support for WPAD proxy auto-configuration.
+ Add support for static IPv6 configuration.
+ Add support for DHCP provided domain names.
+ Add initial support for on-demand connections.
+ Remove uDHCP and resolvconf plugins.
+
+ver 0.55:
+ Fix issue with 3G roaming status indication.
+ Fix issue with using -H option with dhclient.
+ Fix issue with loading WiFi SSID details for scanning.
+ Add support for setting host routes for DNS servers.
+ Add support for more detailed statistics counters.
+ Add support for internal DHCP client library.
+
+ver 0.54:
+ Fix issue with root requests and EDNS0 OPT records.
+ Fix issue with default gateway when route deletion fails.
+ Fix issue with group identifiers for cellular networks.
+ Fix issue with fixed IP settings from cellular networks.
+ Fix issue with nameserver settings and manual configuration.
+ Add support for cellular network name changes.
+ Add support for cellular signal strength changes.
+ Add support for actively scanning for hidden networks.
+ Add support for ASCII based WEP keys.
+ Add support for NTP timeserver updates.
+ Add support for PPP default route settings.
+
+ver 0.53:
+ Fix issue with supplicant and device scanning state cleaning.
+ Fix issue with Bluetooth PAN networks stay in connected state.
+ Fix issue with reference counting and connected state.
+ Fix issue with technology disabling on device removal.
+ Fix issue with two default gateways when using VPN.
+ Fix issue with static IPv4 configuration and signals.
+ Add support for splitting DHCP provided nameserver results.
+ Add support multiple nameservers in /etc/resolv.conf.
+ Add support for setting manual DNS server configuration.
+ Add support for exporting IPv4 gateway information.
+ Add support for newer versions of oFono API.
+
+ver 0.52:
+ Fix issue with new "connected" states.
+ Fix issue with hidden networks and PSK.
+ Fix issue with DHCP and Bluetooth PAN.
+ Fix issue when disconnecting PAN networks.
+ Add support for application sessions.
+ Add plugin for hh2serial GPS support.
+
+ver 0.51:
+ Fix issue with missing device power toggling.
+ Fix issue with D-Bus object path on device removal.
+ Add support for WiFi portal detection.
+ Add support for configuring static gateways.
+ Remove unneeded plugin for Option HSO support.
+ Remove unneeded plugin for Ericsson MBM support.
+
+ver 0.50:
+ Fix configuration loading for unknown services.
+ Fix IP method setting of Ethernet plugin.
+
+ver 0.49:
+ Fix issue with WiFi power changes.
+ Fix issue with Bluetooth device startup.
+ Fix issue with host route settings for VPN.
+ Fix issue with processing of RFKILL events.
+ Fix some WPA Enterprise privacy issues.
+ Add support for basic Ethernet information.
+ Add support for static IP settings.
+
+ver 0.48:
+ Fix signal strength calculation when quality is not provided.
+ Fix issues with wpa_supplicant state tracking.
+ Fix faulty removal of IP address from interface.
+ Fix permissions of newly created /etc/resolv.conf file.
+ Fix DNS proxy handling when in offline mode.
+ Add support for EDNS0 resolver option.
+ Add workaround for large EDNS0 queries.
+ Add workaround for DHCP startup failures with WiFi networks.
+ Add support for handling hostnames and domainnames.
+ Add support for IPv4 configuration via service interface.
+ Add support for fixed and manual IPv4 configuration.
+ Add support for default service changed notifier.
+ Add support for clearing failure state via service removal.
+ Add support for OpenConnect VPN connections.
+ Add support for IEEE 802.1x WiFi networks.
+ Add support for roaming between WPA and WPA2 networks.
+ Add various generic D-Bus helpers and use them.
+ Remove special handling of Ethernet devices.
+
+ver 0.47:
+ Fix segmentation fault on resolver shutdown.
+ Fix issue with adding nameserver that doesn't exist.
+ Fix issue when no broadcast address is given.
+ Fix issue with missing property changed signal.
+ Add checks for invalid supplicant state transitions.
+ Add initial version of oFono GPRS support.
+ Add support for dynamic debug framework.
+
+ver 0.46:
+ Fix reconnect issue when power off or disabling the device.
+ Remove problematic retry on failure code path.
+
+ver 0.45:
+ Fix crash with connect timeout and second connect attempt.
+ Fix reconnect issues after suspend or roaming attempt.
+
+ver 0.44:
+ Fix command line options for device filtering.
+ Fix issue with network reference in MBM support.
+ Fix handling when losing network access in MBM plugin.
+ Fix broken libiWmxSDK callback parameter handling.
+ Add work around Intel WiMAX SDK API breakage.
+
+ver 0.43:
+ Fix issue with missing scanning after power up.
+ Fix issue with udev versus /dev/rfkill event processing.
+ Fix issue with powered down device on connection attempt.
+ Add support for multiple connection attempts.
+ Add support for tracking the operation state.
+ Add full support for Ericsson MBM cellular devices.
+
+ver 0.42:
+ Fix issue with switching between hidden WiFi networks.
+ Fix issue with missing scanning after disconnect.
+ Fix issue with not triggering auto-connect in some cases.
+
+ver 0.41:
+ Fix race condition with WiFi devices and RFKILL.
+ Fix issue with WiFi connect/disconnect and some drivers.
+ Fix issue with WEP encryption and staging drivers.
+ Fix issue with wrong setup of loopback interfaces.
+
+ver 0.40:
+ Fix issue with wrong setting of initial AutoConnect value.
+ Fix issue with IP configuration and loopback devices.
+ Fix issue with build system and include directory.
+ Fix wrong variable for dhclient-script location.
+ Fix disconnect race condition with Bluetooth service.
+ Add support for ignoring bonding Ethernet interfaces.
+
+ver 0.39:
+ Fix file permissions for profile storage.
+ Fix service resorting when they are in different states.
+ Fix support for handling Bluetooth PAN devices.
+ Add support for AutoConnect property of services.
+ Add support for creating, modifying and removing profiles.
+ Add support for fully flexible task handling framework.
+ Add support for more generic RTNL handling and notifications.
+ Add support for full non-recursive build.
+
+ver 0.38:
+ Fix broken check for security modes.
+ Fix requirement of inotify when loopback support is disabled.
+
+ver 0.37:
+ Fix missing update of signal strength from scan results.
+ Fix error handling in case when passphrase is required.
+ Add support for PassphraseRequired property.
+ Add missing check for WiFi security modes.
+
+ver 0.36:
+ Fix missing reset of network reference when disconnecting.
+ Fix wrong variable reference when sending technology replies.
+ Fix wrong identifiers of D-Bus error names.
+
+ver 0.35:
+ Fix missing auto-connect trigger on Ethernet device removal.
+ Fix availability listing for devices without attached drivers.
+ Fix signals for connected and default technologies.
+ Fix notification to use service types instead of device types.
+ Fix potential pending scan result reply messages after removal.
+ Add support for blocking enable and disable technology changes.
+
+ver 0.34:
+ Fix setup of udev context before loading any plugins.
+ Fix rearming the scan trigger if a device got disabled.
+ Fix device power state changes tracking with RFKILL notifications.
+ Fix wrong usage of device types instead of service types.
+ Fix connect method to handle non-WiFi services.
+
+ver 0.33:
+ Add support for RFKILL changes of the WiFi subsystem.
+ Fix state value of Network Manager compatibility support.
+
+ver 0.32:
+ Fix broken device unregistration on removal.
+ Fix WiMAX device detection handling.
+
+ver 0.31:
+ Fix missing enforcement of offline mode for new devices.
+ Add support for persistent storage of offline mode.
+ Add support for persistent storage of device power state.
+ Remove deprecated and unused network storage callbacks.
+
+ver 0.30:
+ Fix issue where hidden network could show up in service list.
+ Fix issue with asynchronous notification of scan requests.
+ Fix message reference leak when adding interface fails.
+ Fix problem when removing network during inactive state.
+ Remove broken and unused callback for joining networks.
+ Remove deprecated device and network interface methods.
+ Remove test scripts for deprecated interface methods.
+
+ver 0.29:
+ Fix missing signal emission for offline mode changes.
+ Fix signal emission for changes in technology properties.
+ Rename Technologies property to AvailableTechnologies.
+
+ver 0.28:
+ Fix another reference counting imbalance when adding networks.
+ Revert supplicant change to always reset scanning after results.
+
+ver 0.27:
+ Fix missing disarming of the connection timeout.
+ Fix handling of multiple supplicant disconnect attempts.
+ Fix simultaneous connects from different technologies limitation.
+
+ver 0.26:
+ Fix broken handling of auto-connect logic.
+ Fix handling of out-of-range access points.
+ Fix support for connecting to hidden networks.
+ Fix reference counting for networks with same SSID.
+ Fix issue with WiFi interfaces not getting switched off.
+ Fix problems with delayed service list updates.
+ Fix disconnect/abort of connection attempts.
+
+ver 0.25:
+ Fix showing of WiFi networks with less than 25% signal strength.
+ Fix potential segmentation fault with network passphrases.
+
+ver 0.24:
+ Fix handling of initial device powered state.
+ Fix missing Powered property changed signals.
+ Fix canceling of a network connection attempt.
+ Fix stalled configuration issue with supplicant.
+ Fix detection of association errors from supplicant.
+ Fix issue with wrong scanning state information.
+ Fix hidden SSID detection routines.
+ Fix visible Ethernet services even without carrier.
+ Add global method call to request scanning.
+ Add support for global technologies list.
+ Add support for delaying service list updates.
+ Update the overall D-Bus API documentation.
+
+ver 0.23:
+ Fix dhclient probe/remove race condition.
+ Fix handling of disconnected services during auto-connect.
+ Add support for proper group name of hidden networks.
+ Add support for storing SSID details of hidden networks.
+
+ver 0.22:
+ Fix wrong auto-connect procedure after user connection.
+ Fix invalid update of already connected network.
+ Fix idle state handling after disconnecting device.
+ Fix disconnect race condition in WiFi supplicant.
+ Fix WiFi signal strength reporting.
+
+ver 0.21:
+ Add udev based network device detection.
+ Add support for global auto-connect feature.
+ Add support for basic service drag and drop.
+ Fix missing passphrase cleanup on service removal.
+ Fix potential duplicate network creation.
+ Fix handling of WEP shared keys.
+
+ver 0.20:
+ Add plugin for Intel WiMAX SDK support.
+ Add special handling for default vendor SSIDs.
+ Add support for default gateway in different network.
+ Add support for automatic switching of default gateway.
+ Add support for asynchronous handling of Powered property.
+ Add support for connecting/disconnecting Ethernet services.
+ Add support for more detailed error states of services.
+ Add support for clearing error state via ClearProperty.
+ Fix error code for invalid or unknown properties.
+ Fix various timeout handling issues.
+ Remove Policy and Priority device and network properties.
+
+ver 0.19:
+ Add hidden networks to the service list.
+ Add support for storing the service name.
+ Fix service list sorting for connected services.
+ Fix missing cancel command when operation times out.
+ Fix various issues with service favorite handling.
+ Remove Available and Remember network properties.
+
+ver 0.18:
+ Add support for asynchronous service connect method.
+ Fix broken storage of service favorite details.
+
+ver 0.17:
+ Add AT chat library implementation.
+ Fix service lookup for WiFi and WiMAX devices.
+ Fix service state signal emission and error handling.
+ Fix storing and loading of configured passphrases for services.
+
+ver 0.16:
+ Update Intel OSPM support to latest specification.
+ Add initial support for new service interface.
+ Add support for builtin plugins.
+ Add extra warning if no nameserver is defined.
+ Add error reporting for state and storage directory creation.
+ Add error message for network and device storing failures
+ Fix stale entry in gateway list after connection changes.
+ Fix handling of DHCP results with no nameserver.
+ Fix infinite loop for service lookup.
+ Fix various format string warnings.
+
+ver 0.15:
+ Detect VMware network interface and ignore them.
+ Fix setting of scan_ssid for hidden networks.
+ Fix empty network name property.
+
+ver 0.14:
+ Add support for detecting DHCP failures.
+ Add support for joining hidden WiFi networks.
+ Add support for device and network address property.
+ Add support for default /etc/resolv.conf generation.
+ Fix issue with wrong address setting for loopback.
+ Fix detection of WiFi access point changes.
+ Fix crash with blob properties.
+
+ver 0.13:
+ Add support for notification infrastructure.
+ Add fully dynamic property storage capabilities.
+ Fix broken loading of last network on bootup.
+ Fix crash when unplugging WiFi devices.
+ Rename OSPM plugin to Intel OSPM plugin.
+ Rename WiMAX plugin to Intel WiMAX SDK plugin.
+
+ver 0.12:
+ Fix connection state change handling.
+ Fix network list enumeration.
+ Fix broken driver matching for devices.
+ Fix issue with network identifier lookup.
+
+ver 0.11:
+ Add plugin priority handling.
+ Add network type for WiMAX.
+ Fix network protocol selection for Bluetooth PAN.
+ Fix parameters for Bluetooth PAN disconnect method.
+
+ver 0.10:
+ Fix races with connection signals.
+ Fix automatic switching of default connection.
+
+ver 0.9:
+ Rename FlightMode to OfflineMode.
+ Add static IPv4 setting support for Ethernet devices.
+ Add extra options to exclude devices and plugins.
+ Add support for toggling debug output.
+ Add support for ScanInterval property.
+ Fix handling of disconnect commands from applications.
+ Fix detection of networks that are out of range.
+ Fix setting network remember status.
+ Fix argument type checking of properties.
+
+ver 0.8:
+ Add Device and Network property to connection interface.
+ Add option to disable installation of data files.
+ Add command line option to show version number.
+ Fix signal emission for network changes.
+
+ver 0.7:
+ Add basic support for flight mode.
+ Add support for multiple storage drivers.
+ Add support for RTNL newlink watch API.
+ Add support for different security privileges.
+ Add support for device and network priorities.
+ Add functions for setting network properties.
+ Fix issue with listing devices without a driver.
+ Fix issue with WiFi scanning indication.
+ Fix detection of WiFi security changes.
+ Update WiFi driver to use new network helpers.
+ Install different D-Bus configuration for PolicyKit.
+
+ver 0.6:
+ Add CONNMAN_API_SUBJECT_TO_CHANGE definition.
+ Add detailed configuration options.
+ Add various D-Bus helper functions.
+ Add generic device driver infrastructure.
+ Add generic network driver infrastructure.
+ Add property for WiFi network mode.
+ Add property for network interface name.
+ Add property for global connection policy.
+ Add support for verbose compiler warnings.
+ Add support for device detection via udev.
+ Add support for systems with udhcpc.
+ Add support for Bluetooth PAN networks.
+ Fix WiFi issue with DHCP restart after handshake.
+ Fix exported symbols list creation.
+ Remove deprecated and unused plugins.
+
+ver 0.5:
+ Add support for handling Bluetooth adapters.
+ Add support for activating wpa_supplicant on demand.
+ Add Device property to network objects.
+ Add Scanning property to device objects.
+ Fix Name property of device objects.
+ Fix WiFi SSID to object path conversion.
+ Fix duplicate wireless scan results.
+ Fix built issue with libudev and uClibc.
+ Fix issues with element registration failures.
+
+ver 0.4:
+ Add DNS proxy resolver plugin.
+ Add support for default connections.
+ Add support for gateway change notifications.
+ Add signal strength property for connections.
+ Add property for connection type.
+ Fix issue with carrier detection.
+ Fix broken resolvconf plugin.
+
+ver 0.3:
+ Add support for automatically connecting known networks.
+ Add improved framework for handling resolver details.
+ Add generic signal strength property.
+ Fix bridge and WiMAX device detection.
+ Fix network listing for Ethernet devices.
+
+ver 0.2:
+ Add support for indicating network changes.
+ Add support for signal strength property.
+ Add support for unique device names.
+ Fix broken device enumeration.
+ Fix issue with device removal callback.
+ Fix issue with wpa_supplicant disconnecting.
+ Fix D-Bus access policy configuration.
+
+ver 0.1:
+ Initial public release.
diff --git a/HACKING b/HACKING
new file mode 100644
index 0000000..80382ed
--- /dev/null
+++ b/HACKING
@@ -0,0 +1,109 @@
+Hacking on Connection Manager
+*****************************
+
+
+Build tools requirements
+========================
+
+When building and testing directly from the repository it is important to
+have at least automake version 1.10 or later installed. All modern
+distributions should default to the latest version, but it seems that
+Debian's default is still an earlier version:
+
+ Check version
+ # dpkg -l '*automake*'
+
+ Install new version
+ # apt-get install automake1.10
+ # update-alternatives --config automake
+
+
+Working with the source code repository
+=======================================
+
+The repository contains two extra scripts that accomplish the bootstrap
+process. One is called "bootstrap" which is the basic scripts that uses the
+autotools scripts to create the needed files for building and installing.
+It makes sure to call the right programs depending on the usage of shared or
+static libraries or translations etc.
+
+The second program is called "bootstrap-configure". This program will make
+sure to properly clean the repository, call the "bootstrap" script and then
+call configure with proper settings for development. It will use the best
+options and pass them over to configure. These options normally include
+the enabling the maintainer mode and the debugging features.
+
+So while in a normal source project the call "./configure ..." is used to
+configure the project with its settings like prefix and extra options. In
+case of bare repositories call "./bootstrap-configure" and it will bootstrap
+the repository and calls configure with all the correct options to make
+development easier.
+
+In case of preparing for a release with "make distcheck", don't use
+bootstrap-configure since it could export development specific settings.
+
+So the normal steps to checkout, build and install such a repository is
+like this:
+
+ Checkout repository
+ # git clone git://git.kernel.org/pub/scm/network/connman/connman.git
+ # cd connman
+
+ Configure and build
+ # ./bootstrap-configure
+ # make
+
+ Check installation
+ # make install DESTDIR=$PWD/x
+ # find x
+ # rm -rf x
+
+ Check distribution
+ # make distcheck
+
+ Final installation
+ # sudo make install
+
+ Remove autogenerated files
+ # make maintainer-clean
+
+
+Running from within the source code repository
+==============================================
+
+When using "./configure --enable-maintainer-mode" the automake scripts will
+use the plugins directly from within the repository. This removes the need
+to use "make install" when testing "connmand". The "bootstrap-configure"
+automatically includes this option.
+
+ Run daemon in foreground with debugging
+ # sudo ./src/connmand -n -d 'plugins/*'
+
+The debugging option -d takes an argument. This argument can be a comma
+separated list of file names like 'plugins/wifi.c,plugins/ethernet.c' to
+enable debugs in these files. Simple glob style pattern matching is
+supported in this list.
+
+For production installations or distribution packaging it is important that
+the "--enable-maintainer-mode" option is NOT used.
+
+Some times it is important to restrict the available interfaces. For example
+in cases where testing happens over a network connection. The "-i" command
+line switch allows to specify a glob pattern for the interface names.
+
+ Run daemon for wireless interfaces
+ # sudo ./src/connmand -n -i wlan*
+
+
+Debugging the D-Bus interface during runtime
+============================================
+
+Running the daemon with debugging information in the foreground is quite
+verbose and sometimes not really helpful. The "monitor-connman" script
+allows to monitor "PropertyChanged" D-Bus signals from various interfaces.
+
+Every "PropertyChanged" signal will generate a line of output. Some of them
+can get very complex. The first detail inside "{ ... }" is the interface
+name (without its service name prefix). The second detail inside "[ ... ]"
+is the object path. And after that it is followed by a key and value of
+the property that changed.
diff --git a/INSTALL b/INSTALL
new file mode 100644
index 0000000..56b077d
--- /dev/null
+++ b/INSTALL
@@ -0,0 +1,236 @@
+Installation Instructions
+*************************
+
+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002, 2004, 2005 Free
+Software Foundation, Inc.
+
+This file is free documentation; the Free Software Foundation gives
+unlimited permission to copy, distribute and modify it.
+
+Basic Installation
+==================
+
+These are generic installation instructions.
+
+ The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation. It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions. Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+ It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring. (Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.)
+
+ If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release. If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+ The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'. You only need
+`configure.ac' if you want to change it or regenerate `configure' using
+a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+ 1. `cd' to the directory containing the package's source code and type
+ `./configure' to configure the package for your system. If you're
+ using `csh' on an old version of System V, you might need to type
+ `sh ./configure' instead to prevent `csh' from trying to execute
+ `configure' itself.
+
+ Running `configure' takes awhile. While running, it prints some
+ messages telling which features it is checking for.
+
+ 2. Type `make' to compile the package.
+
+ 3. Optionally, type `make check' to run any self-tests that come with
+ the package.
+
+ 4. Type `make install' to install the programs and any data files and
+ documentation.
+
+ 5. You can remove the program binaries and object files from the
+ source code directory by typing `make clean'. To also remove the
+ files that `configure' created (so you can compile the package for
+ a different kind of computer), type `make distclean'. There is
+ also a `make maintainer-clean' target, but that is intended mainly
+ for the package's developers. If you use it, you may have to get
+ all sorts of other programs in order to regenerate files that came
+ with the distribution.
+
+Compilers and Options
+=====================
+
+Some systems require unusual options for compilation or linking that the
+`configure' script does not know about. Run `./configure --help' for
+details on some of the pertinent environment variables.
+
+ You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment. Here
+is an example:
+
+ ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
+
+ *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory. To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'. `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script. `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+ If you have to use a `make' that does not support the `VPATH'
+variable, you have to compile the package for one architecture at a
+time in the source code directory. After you have installed the
+package for one architecture, use `make distclean' before reconfiguring
+for another architecture.
+
+Installation Names
+==================
+
+By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc. You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PREFIX'.
+
+ You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files. If you
+give `configure' the option `--exec-prefix=PREFIX', the package will
+use PREFIX as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+ In addition, if you use an unusual directory layout you can give
+options like `--bindir=DIR' to specify different values for particular
+kinds of files. Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+ If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System). The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+ For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+There may be some features `configure' cannot figure out automatically,
+but needs to determine by the type of machine the package will run on.
+Usually, assuming the package is built to be run on the _same_
+architectures, `configure' can figure that out, but if it prints a
+message saying it cannot guess the machine type, give it the
+`--build=TYPE' option. TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+ CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+ OS KERNEL-OS
+
+ See the file `config.sub' for the possible values of each field. If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+ If you are _building_ compiler tools for cross-compiling, you should
+use the `--target=TYPE' option to select the type of system they will
+produce code for.
+
+ If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+If you want to set default values for `configure' scripts to share, you
+can create a site shell script called `config.site' that gives default
+values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists. Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+Variables not defined in a site shell script can be set in the
+environment passed to `configure'. However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost. In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'. For example:
+
+ ./configure CC=/usr/local2/bin/gcc
+
+causes the specified `gcc' to be used as the C compiler (unless it is
+overridden in the site shell script). Here is a another example:
+
+ /bin/bash ./configure CONFIG_SHELL=/bin/bash
+
+Here the `CONFIG_SHELL=/bin/bash' operand causes subsequent
+configuration-related scripts to be executed by `/bin/bash'.
+
+`configure' Invocation
+======================
+
+`configure' recognizes the following options to control how it operates.
+
+`--help'
+`-h'
+ Print a summary of the options to `configure', and exit.
+
+`--version'
+`-V'
+ Print the version of Autoconf used to generate the `configure'
+ script, and exit.
+
+`--cache-file=FILE'
+ Enable the cache: use and save the results of the tests in FILE,
+ traditionally `config.cache'. FILE defaults to `/dev/null' to
+ disable caching.
+
+`--config-cache'
+`-C'
+ Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+ Do not print messages saying which checks are being made. To
+ suppress all normal output, redirect it to `/dev/null' (any error
+ messages will still be shown).
+
+`--srcdir=DIR'
+ Look for the package's source code in directory DIR. Usually
+ `configure' can determine that directory automatically.
+
+`configure' also accepts some other, not widely useful, options. Run
+`configure --help' for more details.
+
diff --git a/Makefile.am b/Makefile.am
new file mode 100644
index 0000000..aa5ea74
--- /dev/null
+++ b/Makefile.am
@@ -0,0 +1,475 @@
+
+AM_MAKEFLAGS = --no-print-directory
+
+noinst_LTLIBRARIES =
+
+includedir = @includedir@/connman
+
+include_HEADERS = include/log.h include/plugin.h \
+ include/notifier.h include/service.h \
+ include/resolver.h include/ipconfig.h \
+ include/device.h include/network.h include/inet.h \
+ include/storage.h include/provision.h \
+ include/session.h include/ipaddress.h include/agent.h \
+ include/inotify.h include/peer.h include/machine.h \
+ include/technology.h \
+ include/dbus.h \
+ include/gdbus.h
+
+nodist_include_HEADERS = include/version.h
+
+noinst_HEADERS = include/rtnl.h include/task.h \
+ include/option.h \
+ include/provider.h include/vpn-dbus.h \
+ include/utsname.h include/timeserver.h include/proxy.h \
+ include/setting.h
+
+local_headers = $(foreach file,$(include_HEADERS) $(nodist_include_HEADERS) \
+ $(noinst_HEADERS), include/connman/$(notdir $(file)))
+
+
+noinst_LTLIBRARIES += gdbus/libgdbus-internal.la
+
+gdbus_libgdbus_internal_la_SOURCES = gdbus/gdbus.h \
+ gdbus/mainloop.c gdbus/watch.c \
+ gdbus/object.c gdbus/client.c gdbus/polkit.c
+
+gdhcp_sources = gdhcp/gdhcp.h gdhcp/common.h gdhcp/common.c gdhcp/client.c \
+ gdhcp/server.c gdhcp/ipv4ll.h gdhcp/ipv4ll.c gdhcp/unaligned.h \
+ gdhcp/timer.c gdhcp/timer.h
+
+gweb_sources = gweb/gweb.h gweb/gweb.c gweb/gresolv.h gweb/gresolv.c
+
+if WISPR
+gweb_sources += gweb/giognutls.h gweb/giognutls.c
+else
+gweb_sources += gweb/giognutls.h gweb/gionotls.c
+endif
+
+shared_sources = src/shared/util.h src/shared/util.c \
+ src/shared/netlink.h src/shared/netlink.c
+
+if DATAFILES
+
+if NMCOMPAT
+nmcompat_conf = plugins/connman-nmcompat.conf
+endif
+
+dbusconfdir = @DBUS_CONFDIR@
+
+dbusconf_DATA = src/connman.conf $(nmcompat_conf)
+
+if VPN
+dbusconf_DATA += vpn/connman-vpn-dbus.conf
+dbusservicedir = @DBUS_DATADIR@
+dbusservice_DATA = vpn/net.connman.vpn.service
+endif
+
+if SYSTEMD
+systemdunitdir = @SYSTEMD_UNITDIR@
+
+systemdunit_DATA = src/connman.service
+
+if VPN
+systemdunit_DATA += vpn/connman-vpn.service
+endif
+endif
+endif
+
+service_files_sources = src/connman.service.in src/net.connman.service.in \
+ vpn/connman-vpn.service.in \
+ vpn/net.connman.vpn.service.in
+service_files = src/connman.service src/net.connman.service \
+ vpn/connman-vpn.service \
+ vpn/net.connman.vpn.service
+
+plugin_LTLIBRARIES =
+
+plugin_objects =
+
+builtin_modules =
+builtin_sources =
+builtin_libadd =
+builtin_cflags =
+
+noinst_PROGRAMS =
+bin_PROGRAMS =
+
+unit_objects =
+
+MANUAL_PAGES =
+
+sbin_PROGRAMS = src/connmand
+
+src_connmand_SOURCES = $(gdhcp_sources) $(gweb_sources) \
+ $(builtin_sources) $(shared_sources) src/connman.ver \
+ src/main.c src/connman.h src/log.c \
+ src/error.c src/plugin.c src/task.c \
+ src/device.c src/network.c src/connection.c \
+ src/manager.c src/service.c \
+ src/clock.c src/timezone.c src/agent-connman.c \
+ src/agent.c src/notifier.c src/provider.c \
+ src/resolver.c src/ipconfig.c src/detect.c src/inet.c \
+ src/dhcp.c src/dhcpv6.c src/rtnl.c src/proxy.c \
+ src/utsname.c src/timeserver.c src/rfkill.c \
+ src/storage.c src/dbus.c src/config.c \
+ src/technology.c src/counter.c src/ntp.c \
+ src/session.c src/tethering.c src/wpad.c src/wispr.c \
+ src/stats.c src/iptables.c src/dnsproxy.c src/6to4.c \
+ src/ippool.c src/bridge.c src/nat.c src/ipaddress.c \
+ src/inotify.c src/firewall.c src/ipv6pd.c src/peer.c \
+ src/peer_service.c src/machine.c src/util.c \
+ src/rlimits.c
+
+src_connmand_LDADD = gdbus/libgdbus-internal.la $(builtin_libadd) \
+ @GLIB_LIBS@ @DBUS_LIBS@ @XTABLES_LIBS@ @GNUTLS_LIBS@ \
+ -lresolv -ldl -lrt
+
+src_connmand_LDFLAGS = -Wl,--export-dynamic \
+ -Wl,--version-script=$(srcdir)/src/connman.ver
+
+if VPN
+vpn_plugin_LTLIBRARIES =
+
+vpn_plugin_objects =
+
+builtin_vpn_modules =
+builtin_vpn_sources =
+builtin_vpn_libadd =
+builtin_vpn_cflags =
+
+sbin_PROGRAMS += vpn/connman-vpnd
+
+vpn_connman_vpnd_SOURCES = $(builtin_vpn_sources) \
+ $(gweb_sources) vpn/vpn.ver vpn/main.c vpn/vpn.h \
+ src/log.c src/error.c src/plugin.c src/task.c \
+ vpn/vpn-manager.c vpn/vpn-provider.c \
+ vpn/vpn-provider.h vpn/vpn-rtnl.h \
+ vpn/vpn-ipconfig.c src/inet.c vpn/vpn-rtnl.c \
+ src/dbus.c src/storage.c src/ipaddress.c src/agent.c \
+ vpn/vpn-agent.c vpn/vpn-agent.h src/inotify.c \
+ vpn/vpn-config.c
+
+vpn_connman_vpnd_LDADD = gdbus/libgdbus-internal.la $(builtin_vpn_libadd) \
+ @GLIB_LIBS@ @DBUS_LIBS@ @GNUTLS_LIBS@ \
+ -lresolv -ldl
+
+vpn_connman_vpnd_LDFLAGS = -Wl,--export-dynamic \
+ -Wl,--version-script=$(srcdir)/vpn/vpn.ver
+endif
+
+BUILT_SOURCES = $(local_headers) src/builtin.h $(service_files) scripts/connman
+
+if VPN
+BUILT_SOURCES += vpn/builtin.h
+endif
+
+CLEANFILES = src/connman.conf $(BUILT_SOURCES) $(service_files)
+
+statedir = $(localstatedir)/run/connman
+vpn_statedir = $(localstatedir)/run/connman-vpn
+
+if VPN
+vpn_plugindir = $(libdir)/connman/plugins-vpn
+endif
+
+plugindir = $(libdir)/connman/plugins
+
+scriptdir = $(libdir)/connman/scripts
+
+storagedir = $(localstatedir)/lib/connman
+vpn_storagedir = $(localstatedir)/lib/connman-vpn
+
+configdir = ${sysconfdir}/connman
+
+if MAINTAINER_MODE
+if VPN
+build_vpn_plugindir = $(abs_top_srcdir)/vpn/plugins/.libs
+endif
+build_plugindir = $(abs_top_srcdir)/plugins/.libs
+build_scriptdir = $(abs_top_srcdir)/scripts
+else
+build_plugindir = $(plugindir)
+build_scriptdir = $(scriptdir)
+if VPN
+build_vpn_plugindir = $(vpn_plugindir)
+endif
+endif
+
+AM_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ @XTABLES_CFLAGS@ \
+ @GNUTLS_CFLAGS@ $(builtin_cflags) \
+ -DCONNMAN_PLUGIN_BUILTIN \
+ -DSTATEDIR=\""$(statedir)"\" \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DPLUGINDIR=\""$(build_plugindir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\" \
+ -DSTORAGEDIR=\""$(storagedir)\"" \
+ -DVPN_STORAGEDIR=\""$(vpn_storagedir)\"" \
+ -DCONFIGDIR=\""$(configdir)\""
+
+if VPN
+AM_CPPFLAGS = -I$(builddir)/include -I$(srcdir)/gdbus
+else
+AM_CPPFLAGS = -I$(builddir)/include -I$(builddir)/src -I$(srcdir)/gdbus
+endif
+
+src_connmand_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ @XTABLES_CFLAGS@ \
+ @GNUTLS_CFLAGS@ $(builtin_cflags) \
+ -DCONNMAN_PLUGIN_BUILTIN \
+ -DSTATEDIR=\""$(statedir)"\" \
+ -DPLUGINDIR=\""$(build_plugindir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\" \
+ -DSTORAGEDIR=\""$(storagedir)\"" \
+ -DVPN_STORAGEDIR=\""$(vpn_storagedir)\"" \
+ -DCONFIGDIR=\""$(configdir)\"" \
+ -I$(builddir)/src
+
+EXTRA_DIST = src/genbuiltin src/connman-dbus.conf src/connman-polkit.conf \
+ plugins/connman-nmcompat.conf \
+ $(service_files_sources) scripts/connman.in
+
+if VPN
+vpn_connman_vpnd_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ \
+ $(builtin_vpn_cflags) \
+ -DCONNMAN_PLUGIN_BUILTIN \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DPLUGINDIR=\""$(build_vpn_plugindir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\" \
+ -DSTORAGEDIR=\""$(storagedir)\"" \
+ -DVPN_STORAGEDIR=\""$(vpn_storagedir)\"" \
+ -DCONFIGDIR=\""$(configdir)\"" \
+ -I$(builddir)/vpn
+
+endif
+
+EXTRA_DIST += vpn/vpn-dbus.conf vpn/vpn-polkit.conf
+
+script_DATA =
+script_PROGRAMS =
+script_LTLIBRARIES =
+
+include Makefile.plugins
+
+if CLIENT
+bin_PROGRAMS += client/connmanctl
+
+MANUAL_PAGES += doc/connmanctl.1
+
+client_connmanctl_SOURCES = client/dbus_helpers.h client/dbus_helpers.c \
+ client/services.h client/services.c \
+ client/commands.h client/commands.c \
+ client/input.h client/input.c \
+ client/agent.h client/agent.c \
+ client/peers.h client/peers.c \
+ client/vpnconnections.h client/vpnconnections.c \
+ client/main.c
+
+client_connmanctl_LDADD = gdbus/libgdbus-internal.la @DBUS_LIBS@ @GLIB_LIBS@ \
+ -lreadline -ldl
+endif
+
+noinst_PROGRAMS += unit/test-ippool
+
+unit_test_ippool_SOURCES = src/log.c src/dbus.c src/error.c \
+ src/ippool.c unit/test-ippool.c
+unit_test_ippool_LDADD = gdbus/libgdbus-internal.la \
+ @GLIB_LIBS@ @DBUS_LIBS@ -ldl
+
+TESTS = unit/test-ippool
+
+if WISPR
+noinst_PROGRAMS += tools/wispr
+
+tools_wispr_SOURCES = $(gweb_sources) tools/wispr.c
+tools_wispr_LDADD = @GLIB_LIBS@ @GNUTLS_LIBS@ -lresolv
+endif
+
+if TOOLS
+noinst_PROGRAMS += tools/supplicant-test \
+ tools/dhcp-test tools/dhcp-server-test \
+ tools/addr-test tools/web-test tools/resolv-test \
+ tools/dbus-test tools/polkit-test \
+ tools/iptables-test tools/tap-test tools/wpad-test \
+ tools/stats-tool tools/private-network-test \
+ tools/session-test tools/iptables-unit \
+ tools/dnsproxy-test tools/netlink-test
+
+tools_supplicant_test_SOURCES = tools/supplicant-test.c \
+ tools/supplicant-dbus.h tools/supplicant-dbus.c \
+ tools/supplicant.h tools/supplicant.c
+tools_supplicant_test_LDADD = gdbus/libgdbus-internal.la \
+ @GLIB_LIBS@ @DBUS_LIBS@
+
+tools_web_test_SOURCES = $(gweb_sources) tools/web-test.c
+tools_web_test_LDADD = @GLIB_LIBS@ @GNUTLS_LIBS@ -lresolv
+
+tools_resolv_test_SOURCES = gweb/gresolv.h gweb/gresolv.c tools/resolv-test.c
+tools_resolv_test_LDADD = @GLIB_LIBS@ -lresolv
+
+tools_wpad_test_SOURCES = gweb/gresolv.h gweb/gresolv.c tools/wpad-test.c
+tools_wpad_test_LDADD = @GLIB_LIBS@ -lresolv
+
+tools_stats_tool_LDADD = @GLIB_LIBS@
+
+tools_dhcp_test_SOURCES = $(gdhcp_sources) tools/dhcp-test.c
+tools_dhcp_test_LDADD = @GLIB_LIBS@
+
+tools_dhcp_server_test_SOURCES = $(gdhcp_sources) tools/dhcp-server-test.c
+tools_dhcp_server_test_LDADD = @GLIB_LIBS@
+
+tools_dbus_test_SOURCES = tools/dbus-test.c
+tools_dbus_test_LDADD = gdbus/libgdbus-internal.la @GLIB_LIBS@ @DBUS_LIBS@
+
+tools_polkit_test_LDADD = @DBUS_LIBS@
+
+tools_iptables_test_SOURCES = src/log.c src/iptables.c tools/iptables-test.c
+tools_iptables_test_LDADD = @GLIB_LIBS@ @XTABLES_LIBS@ -ldl
+
+tools_private_network_test_LDADD = @GLIB_LIBS@ @DBUS_LIBS@
+
+tools_session_test_SOURCES = src/log.c src/dbus.c src/error.c \
+ tools/session-test.c tools/session-utils.c tools/manager-api.c \
+ tools/session-api.c tools/session-test.h
+tools_session_test_LDADD = gdbus/libgdbus-internal.la \
+ @GLIB_LIBS@ @DBUS_LIBS@ -ldl
+
+tools_iptables_unit_CFLAGS = @DBUS_CFLAGS@ @GLIB_CFLAGS@ @XTABLES_CFLAGS@ \
+ -DIPTABLES_SAVE=\""${IPTABLES_SAVE}"\"
+tools_iptables_unit_SOURCES = src/log.c \
+ src/iptables.c src/firewall.c src/nat.c tools/iptables-unit.c
+tools_iptables_unit_LDADD = gdbus/libgdbus-internal.la \
+ @GLIB_LIBS@ @DBUS_LIBS@ @XTABLES_LIBS@ -ldl
+
+tools_dnsproxy_test_SOURCES = tools/dnsproxy-test.c
+tools_dnsproxy_test_LDADD = @GLIB_LIBS@
+
+tools_netlink_test_SOURCES =$(shared_sources) tools/netlink-test.c
+tools_netlink_test_LDADD = @GLIB_LIBS@
+
+endif
+
+test_scripts = test/get-state test/list-services \
+ test/monitor-services test/test-clock \
+ test/simple-agent test/show-introspection test/test-compat \
+ test/test-manager test/test-connman test/monitor-connman \
+ test/connect-provider test/remove-provider \
+ test/test-counter test/set-ipv4-method test/set-ipv6-method \
+ test/get-services test/get-proxy-autoconfig test/set-proxy \
+ test/enable-tethering test/disable-tethering test/backtrace \
+ test/test-session test/p2p-on-supplicant \
+ test/test-new-supplicant test/service-move-before \
+ test/set-global-timeservers test/get-global-timeservers \
+ test/set-nameservers test/set-domains test/set-timeservers \
+ test/set-clock
+
+test_scripts += test/vpn-connect test/vpn-disconnect test/vpn-get \
+ test/monitor-vpn test/vpn-property
+
+if TEST
+testdir = $(pkglibdir)/test
+test_SCRIPTS = $(test_scripts)
+endif
+
+EXTRA_DIST += $(test_scripts)
+
+EXTRA_DIST += doc/overview-api.txt doc/behavior-api.txt \
+ doc/coding-style.txt doc/wifi-p2p-overview.txt \
+ doc/vpn-agent-api.txt doc/peer-api.txt \
+ doc/ipconfig-api.txt doc/plugin-api.txt \
+ doc/manager-api.txt doc/agent-api.txt \
+ doc/service-api.txt doc/technology-api.txt \
+ doc/counter-api.txt doc/config-format.txt \
+ doc/clock-api.txt doc/session-api.txt \
+ doc/session-overview.txt doc/backtrace.txt \
+ doc/advanced-configuration.txt \
+ doc/vpn-config-format.txt \
+ doc/vpn-connection-api.txt \
+ doc/vpn-manager-api.txt doc/vpn-overview.txt \
+ doc/session-policy-format.txt
+
+EXTRA_DIST += src/main.conf \
+ src/eduroam.config
+
+MANUAL_PAGES += doc/connman.8 doc/connman.conf.5
+
+dist_man_MANS = $(MANUAL_PAGES)
+
+pkgconfigdir = $(libdir)/pkgconfig
+
+pkgconfig_DATA = connman.pc
+
+DISTCHECK_CONFIGURE_FLAGS = --disable-datafiles \
+ --enable-hh2serial-gps \
+ --enable-openconnect \
+ --enable-openvpn \
+ --enable-vpnc \
+ --enable-session-policy-local \
+ --enable-nmcompat \
+ --enable-polkit
+
+DISTCLEANFILES = $(pkgconfig_DATA)
+
+MAINTAINERCLEANFILES = Makefile.in \
+ aclocal.m4 configure config.h.in config.sub config.guess \
+ ltmain.sh depcomp compile missing install-sh mkinstalldirs test-driver
+
+
+src/builtin.h: src/genbuiltin $(builtin_sources)
+ $(AM_V_at)$(MKDIR_P) $(dir $@)
+ $(AM_V_GEN)$(srcdir)/src/genbuiltin $(builtin_modules) > $@
+
+vpn/builtin.h: src/genbuiltin $(builtin_vpn_sources)
+ $(AM_V_at)$(MKDIR_P) $(dir $@)
+ $(AM_V_GEN)$(srcdir)/src/genbuiltin $(builtin_vpn_modules) > $@
+
+src/connman.conf: src/connman-dbus.conf src/connman-polkit.conf
+if POLKIT
+ $(AM_V_GEN)cp $(srcdir)/src/connman-polkit.conf $@
+else
+ $(AM_V_GEN)cp $(srcdir)/src/connman-dbus.conf $@
+endif
+
+if VPN
+vpn/connman-vpn-dbus.conf: vpn/vpn-dbus.conf vpn/vpn-polkit.conf
+if POLKIT
+ $(AM_V_GEN)cp $(srcdir)/vpn/vpn-polkit.conf $@
+else
+ $(AM_V_GEN)cp $(srcdir)/vpn/vpn-dbus.conf $@
+endif
+endif
+
+if SELINUX
+if VPN
+EXTRA_DIST += connman-task.pp
+CLEANFILES += connman-task.pp
+endif
+
+connman-task.pp: vpn/connman-task.te
+ make -f /usr/share/selinux/devel/Makefile
+endif
+
+EXTRA_DIST += vpn/connman-task.te
+
+do_subst = $(AM_V_GEN)$(SED) \
+ -e 's,[@]prefix[@],$(prefix),g' \
+ -e 's,[@]sbindir[@],$(sbindir),g' \
+ -e 's,[@]sysconfdir[@],$(sysconfdir),g'
+
+%.service: %.service.in Makefile
+ $(AM_V_at)$(MKDIR_P) $(dir $@)
+ $(do_subst) < $< > $@
+
+scripts/connman: scripts/connman.in Makefile
+ $(AM_V_at)$(MKDIR_P) $(dir $@)
+ $(do_subst) < $< > $@
+
+include/connman/version.h: include/version.h
+ $(AM_V_at)$(MKDIR_P) include/connman
+ $(AM_V_GEN)$(LN_S) $(abs_top_builddir)/$< $@
+
+include/connman/%.h: $(abs_top_srcdir)/include/%.h
+ $(AM_V_at)$(MKDIR_P) include/connman
+ $(AM_V_GEN)$(LN_S) $< $@
+
+clean-local:
+ @$(RM) -rf include/connman
diff --git a/Makefile.plugins b/Makefile.plugins
new file mode 100644
index 0000000..2a5d2de
--- /dev/null
+++ b/Makefile.plugins
@@ -0,0 +1,273 @@
+
+plugin_cflags = -fvisibility=hidden -I$(srcdir)/gdbus \
+ @DBUS_CFLAGS@ @GLIB_CFLAGS@
+plugin_ldflags = -no-undefined -module -avoid-version
+
+if LOOPBACK
+builtin_modules += loopback
+builtin_sources += plugins/loopback.c
+endif
+
+if ETHERNET
+builtin_modules += ethernet
+builtin_sources += plugins/ethernet.c
+endif
+
+if GADGET
+builtin_modules += gadget
+builtin_sources += plugins/gadget.c
+endif
+
+gsupplicant_sources = gsupplicant/gsupplicant.h gsupplicant/dbus.h \
+ gsupplicant/supplicant.c gsupplicant/dbus.c
+
+if WIFI
+builtin_modules += wifi
+builtin_sources += plugins/wifi.c $(gsupplicant_sources)
+endif
+
+if SLEEP
+plugin_LTLIBRARIES += plugins/sleepplugin.la
+plugin_objects += $(plugins_sleepplugin_la_OBJECTS)
+plugins_sleepplugin_la_SOURCES = plugins/sleepplugin.c
+plugins_sleepplugin_la_CFLAGS = $(plugin_cflags)
+plugins_sleepplugin_la_LDFLAGS = $(plugin_ldflags)
+endif
+
+if BLUETOOTH
+builtin_modules += bluetooth_legacy
+builtin_sources += plugins/bluetooth_legacy.c
+builtin_modules += bluetooth
+builtin_sources += plugins/bluetooth.c
+endif
+
+if HH2SERIAL_GPS
+if HH2SERIAL_GPS_BUILTIN
+builtin_modules += hh2serial_gps
+builtin_sources += plugins/hh2serial-gps.c
+else
+plugin_LTLIBRARIES += plugins/hh2serial-gps.la
+plugin_objects += $(plugins_hh2serial_gps_la_OBJECTS)
+plugins_hh2serial_gps_la_CFLAGS = $(plugin_cflags)
+plugins_hh2serial_gps_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if OFONO
+builtin_modules += ofono
+builtin_sources += plugins/mcc.h plugins/ofono.c
+endif
+
+if DUNDEE
+builtin_modules += dundee
+builtin_sources += plugins/dundee.c
+endif
+
+if VPN
+builtin_modules += vpn
+builtin_sources += plugins/vpn.c
+
+if OPENCONNECT
+if OPENCONNECT_BUILTIN
+builtin_vpn_modules += openconnect
+builtin_vpn_sources += vpn/plugins/openconnect.c
+builtin_vpn_source = vpn/plugins/vpn.c vpn/plugins/vpn.h
+builtin_vpn_cflags += -DOPENCONNECT=\"@OPENCONNECT@\"
+else
+vpn_plugin_LTLIBRARIES += vpn/plugins/openconnect.la
+vpn_plugin_objects += $(plugins_openconnect_la_OBJECTS)
+vpn_plugins_openconnect_la_SOURCES = vpn/plugins/vpn.h vpn/plugins/vpn.c \
+ vpn/plugins/openconnect.c
+vpn_plugins_openconnect_la_CFLAGS = $(plugin_cflags) \
+ -DOPENCONNECT=\"@OPENCONNECT@\" \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\"
+vpn_plugins_openconnect_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if OPENVPN
+if OPENVPN_BUILTIN
+builtin_vpn_modules += openvpn
+builtin_vpn_sources += vpn/plugins/openvpn.c
+builtin_vpn_source = vpn/plugins/vpn.c vpn/plugins/vpn.h
+builtin_vpn_cflags += -DOPENVPN=\"@OPENVPN@\"
+else
+vpn_plugin_LTLIBRARIES += vpn/plugins/openvpn.la
+vpn_plugin_objects += $(plugins_openvpn_la_OBJECTS)
+vpn_plugins_openvpn_la_SOURCES = vpn/plugins/vpn.h vpn/plugins/vpn.c \
+ vpn/plugins/openvpn.c
+vpn_plugins_openvpn_la_CFLAGS = $(plugin_cflags) -DOPENVPN=\"@OPENVPN@\" \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\"
+vpn_plugins_openvpn_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if VPNC
+if VPNC_BUILTIN
+builtin_vpn_modules += vpnc
+builtin_vpn_sources += vpn/plugins/vpnc.c
+builtin_vpn_source = vpn/plugins/vpn.c vpn/plugins/vpn.h
+builtin_vpn_cflags += -DVPNC=\"@VPNC@\"
+else
+vpn_plugin_LTLIBRARIES += vpn/plugins/vpnc.la
+vpn_plugin_objects += $(plugins_vpnc_la_OBJECTS)
+vpn_plugins_vpnc_la_SOURCES = vpn/plugins/vpn.h vpn/plugins/vpn.c \
+ vpn/plugins/vpnc.c
+vpn_plugins_vpnc_la_CFLAGS = $(plugin_cflags) -DVPNC=\"@VPNC@\" \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\"
+vpn_plugins_vpnc_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if L2TP
+if L2TP_BUILTIN
+builtin_vpn_modules += l2tp
+builtin_vpn_sources += vpn/plugins/l2tp.c
+builtin_vpn_source = vpn/plugins/vpn.c vpn/plugins/vpn.h
+builtin_vpn_cflags += -DL2TP=\"@L2TP@\"
+else
+vpn_plugin_LTLIBRARIES += vpn/plugins/l2tp.la
+vpn_plugin_objects += $(plugins_l2tp_la_OBJECTS)
+vpn_plugins_l2tp_la_SOURCES = vpn/plugins/vpn.h vpn/plugins/vpn.c \
+ vpn/plugins/l2tp.c
+vpn_plugins_l2tp_la_CFLAGS = $(plugin_cflags) -DL2TP=\"@L2TP@\" \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\"
+vpn_plugins_l2tp_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if PPTP
+if PPTP_BUILTIN
+builtin_vpn_modules += pptp
+builtin_vpn_sources += vpn/plugins/pptp.c
+builtin_vpn_source = vpn/plugins/vpn.c vpn/plugins/vpn.h
+builtin_vpn_cflags += -DPPPD=\"@PPPD@\" -DPPTP=\"@PPTP@\"
+else
+vpn_plugin_LTLIBRARIES += vpn/plugins/pptp.la
+vpn_plugin_objects += $(plugins_pptp_la_OBJECTS)
+vpn_plugins_pptp_la_SOURCES = vpn/plugins/vpn.h vpn/plugins/vpn.c \
+ vpn/plugins/pptp.c
+vpn_plugins_pptp_la_CFLAGS = $(plugin_cflags) -DPPPD=\"@PPPD@\" \
+ -DPPTP=\"@PPTP@\" \
+ -DVPN_STATEDIR=\""$(vpn_statedir)"\" \
+ -DSCRIPTDIR=\""$(build_scriptdir)"\"
+vpn_plugins_pptp_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if PPTP
+script_LTLIBRARIES += scripts/libppp-plugin.la
+scripts_libppp_plugin_la_LDFLAGS = $(plugin_ldflags)
+scripts_libppp_plugin_la_LIBADD = @DBUS_LIBS@
+else
+if L2TP
+script_LTLIBRARIES += scripts/libppp-plugin.la
+scripts_libppp_plugin_la_LDFLAGS = $(plugin_ldflags)
+scripts_libppp_plugin_la_LIBADD = @DBUS_LIBS@
+endif
+endif
+
+if VPN
+builtin_vpn_sources += $(builtin_vpn_source)
+endif
+endif
+
+if PACRUNNER
+builtin_modules += pacrunner
+builtin_sources += plugins/pacrunner.c
+endif
+
+if POLKIT
+builtin_modules += polkit
+builtin_sources += plugins/polkit.c
+
+if DATAFILES
+policydir = @POLKIT_DATADIR@
+
+policy_DATA = plugins/net.connman.policy
+
+if VPN
+policy_DATA += vpn/net.connman.vpn.policy
+endif
+endif
+endif
+
+if IOSPM
+plugin_LTLIBRARIES += plugins/iospm.la
+plugin_objects += $(plugins_iospm_la_OBJECTS)
+plugins_iospm_la_CFLAGS = $(plugin_cflags)
+plugins_iospm_la_LDFLAGS = $(plugin_ldflags)
+endif
+
+if OPENCONNECT
+script_PROGRAMS += scripts/openconnect-script
+
+scripts_openconnect_script_LDADD = @DBUS_LIBS@
+else
+if VPNC
+script_PROGRAMS += scripts/openconnect-script
+
+scripts_openconnect_script_LDADD = @DBUS_LIBS@
+endif
+endif
+
+if OPENVPN
+script_PROGRAMS += scripts/openvpn-script
+
+scripts_openvpn_script_LDADD = @DBUS_LIBS@
+endif
+
+if NMCOMPAT
+builtin_modules += nmcompat
+builtin_sources += plugins/nmcompat.c
+endif
+
+if TIST
+if TIST_BUILTIN
+builtin_modules += tist
+builtin_sources += plugins/tist.c
+else
+plugin_LTLIBRARIES += plugins/tist.la
+plugin_objects += $(plugins_tist_la_OBJECTS)
+plugins_tist_la_CFLAGS = $(plugin_cflags)
+plugins_tist_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if SESSION_POLICY_LOCAL
+if SESSION_POLICY_LOCAL_BUILTIN
+builtin_modules += session_policy_local
+builtin_sources += plugins/session_policy_local.c
+else
+plugin_LTLIBRARIES += plugins/session_policy_local.la
+plugin_objects += $(plugins_session_policy_local_la_OBJECTS)
+plugins_session_policy_local_la_CFLAGS = $(plugin_cflags) \
+ -DSTORAGEDIR=\""$(storagedir)\""
+plugins_session_policy_local_la_LDFLAGS = $(plugin_ldflags)
+endif
+endif
+
+if NEARD
+builtin_modules += neard
+builtin_sources += plugins/neard.c
+endif
+
+EXTRA_DIST += plugins/polkit.policy
+
+plugins/net.connman.policy: plugins/polkit.policy
+if POLKIT
+ $(AM_V_GEN)cp $< $@
+endif
+
+EXTRA_DIST += vpn/vpn-polkit.policy
+
+if VPN
+vpn/net.connman.vpn.policy: vpn/vpn-polkit.policy
+if POLKIT
+ $(AM_V_GEN)cp $< $@
+endif
+endif
diff --git a/NEWS b/NEWS
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/NEWS
diff --git a/README b/README
new file mode 100644
index 0000000..531f396
--- /dev/null
+++ b/README
@@ -0,0 +1,399 @@
+Connection Manager
+******************
+
+Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+
+
+Functionality and features
+==========================
+
+The following features are built-in into Connection Manager:
+ - Generic plugin infrastructure
+ - Device and network abstraction (with basic storage support)
+ - IPv4, IPv4-LL (link-local) and DHCP
+ - IPv6, DHCPv6 and 6to4 tunnels
+ - Advanced routing and DNS configuration
+ - Built-in DNS proxy and intelligent caching
+ - Built-in WISPr hotspot logins and portal detection
+ - Time and timezone configuration (manual and automatic with NTP)
+ - Proxy handling (manual and automatic with WPAD)
+ - Tethering support (USB, Bluetooth and WiFi AP mode)
+ - Detailed statistics handling (home and roaming)
+
+Various plugins can be enabled for networking support:
+ - Ethernet plugin
+ - WiFi plugin with WEP40/WEP128 and WPA/WPA2 (personal and enterprise)
+ - Bluetooth plugin (using BlueZ)
+ - 2G/3G/4G plugin (using oFono)
+
+Also plugins with additional features are available:
+ - Loopback interface setup
+ - PACrunner proxy handling
+ - PolicyKit authorization support
+
+Note that when ConnMan starts, it clears all network interfaces that are
+going to be used. If this is not desired, network interfaces can be ignored
+either by setting NetworkInterfaceBlacklist in the main.conf config file or
+by using the -I command line option.
+
+
+Compilation and installation
+============================
+
+In order to compile Connection Manager you need following software packages:
+ - GCC compiler
+ - GLib library
+ - D-Bus library
+ - IP-Tables library (for tethering support)
+ - GnuTLS library (optional)
+ - PolicyKit (optional)
+ - readline (command line client)
+
+To configure run:
+ ./configure --prefix=/usr --sysconfdir=/etc --localstatedir=/var
+
+Configure automatically searches for all required components and packages.
+
+To compile and install run:
+ make && make install
+
+
+Configuration and options
+=========================
+
+For a working system, certain configuration options need to be enabled:
+
+ --disable-ethernet
+
+ Disable support for Ethernet network cards
+
+ By default Ethernet technology support is built-in and
+ enabled. This option can be used to build a small daemon
+ for a specific system if Ethernet support is not required.
+
+ --disable-gadget
+
+ Disable support for USB Ethernet Gadget devices
+
+ By default USB Ethernet Gadget technology support is built-in and
+ enabled. This option can be used to build a small daemon
+ for a specific system if USB Ethernet Gadget support is not required.
+
+ --disable-wifi
+
+ Disable support for WiFi devices
+
+ By default WiFi technology support is built-in and
+ enabled. This option can be used to build a small daemon
+ for a specific system if WiFi support is not required.
+
+ It is safe to build a daemon with WiFi support and no
+ running wpa_supplicant. The start of wpa_supplicant is
+ automatically detected and only a runtime dependency. It
+ is not needed to build ConnMan.
+
+ --disable-bluetooth
+
+ Disable support for Bluetooth devices
+
+ By default Bluetooth technology support is built-in and
+ enabled. This option can be used to build a small daemon
+ for a specific system if Bluetooth support is not required.
+
+ It is safe to build a daemon with Bluetooth support and no
+ running bluetoothd. The start of bluetoothd is automatically
+ detected and only a runtime dependency. It is not needed to
+ build ConnMan.
+
+ --disable-ofono
+
+ Disable support for cellular 2G/3G/4G devices
+
+ By default oFono technology support is built-in and
+ enabled. This option can be used to build a small daemon
+ for a specific system where oFono is not used.
+
+ It is safe to build a daemon with oFono support and no
+ running ofonod. That start of ofonod is automatically
+ detected and only a runtime dependency. It is not needed to
+ build ConnMan.
+
+ --disable-dundee
+
+ Disable support for Bluetooth DUN devices
+
+ By default Bluetooth DUN technology (dundee) support is
+ built-in and enabled. This option can be used to build a
+ small daemon for a specific system where dundee is not used.
+
+ It is safe to build a daemon with dundee support and no
+ running dundee. That start of dundee is automatically
+ detected and only a runtime dependency. It is not needed to
+ build ConnMan.
+
+ --disable-pacrunner
+
+ Disable support for PACrunner proxy handling
+
+ By default PACrunner support is built-in and enabled. This
+ option can be used to build a small daemon for a specific
+ system where PACrunner is not used.
+
+ It is safe to build a daemon with PACrunner support and no
+ pacrunner daemon. It will detect and start a PACrunner
+ process if needed at runtime. The presence is not needed
+ to build ConnMan.
+
+ --disable-loopback
+
+ Disable setup of loopback device
+
+ For distributions with a really minimal init system and no
+ networking scripts this can take care of setting up the
+ loopback device and enabling it.
+
+ It is safe to leave this selected even if networking
+ scripts are in place. It detects an already configured
+ loopback device and leaves it as it is.
+
+ --disable-wispr
+
+ Disable support for WISPr hotspot logins
+
+ For systems with really minimal memory requirements, this
+ will disable the support for WISPr hotspot logins. The code
+ for WISPr will be still compiled into the daemon, but its
+ requirement on GnuTLS for secure connections will be lifted.
+
+ The missing GnuTLS support shrinks the memory requirements
+ by about 30% and for systems that are more stationary and do
+ not log into hotspots this might be a better trade off.
+
+ Disabling WISPr support is not disabling the portal detection
+ support. A portal will still be detected, but instead of being
+ asked for login credentials, the request for a browser session
+ will be made through the agent.
+
+ --enable-polkit
+
+ Enable support for PolicyKit authorization
+
+ This allows to check every D-Bus access against a security
+ policy and so restrict access to certain functionality.
+
+ --enable-nmcompat
+
+ Enable support for NetworkManager compatibility interfaces
+
+ This allows to expose a minimal set of NetworkManager
+ interfaces. It is useful for systems with applications
+ written to use NetworkManager to detect online/offline
+ status and have not yet been converted to use ConnMan.
+
+ --disable-client
+
+ Disable support for the command line client
+
+ By default the command line client is enabled and uses the
+ readline library. For specific systems where ConnMan is
+ configured by other means, the command line client can be
+ disabled and the dependency on readline is removed.
+
+ --enable-selinux
+
+ Enable support for compiling SElinux type enforcement rules
+
+ The TE rules are needed if host environment is in enforcing
+ mode. Without this option, the VPN client process cannot
+ send notification to connman-vpnd via net.connman.Task
+ interface. The compiled connman-task.pp module needs to
+ also installed using this command
+ # semodule -i connman-task.pp
+ in order to enable the dbus access.
+
+
+Activating debugging
+====================
+
+One can activate debugging prints in ConnMan using -d command line option.
+If the -d option has no parameters, then debugging is activated for all
+source code files. If the -d option has parameters, they tell which source
+code files have debugging activated. One can use wild cards in file names.
+Example:
+ -d Activate all normal debug prints
+ -d src/service.c This prints debugging info from src/service.c
+ file only
+ -d src/network.c:src/ipconfig.c
+ This activates debug prints in src/network.c
+ and src/ipconfig.c files.
+ -d 'src/n*.c' This would activate debug print from all the C source
+ files starting with letter 'n' in src directory.
+ Note the quotation marks around option, that is to
+ prevent shell expansion.
+ -d '*/n*.c:*/i*.c' Activate debug prints for all C source files starting
+ with letters 'n' or 'i' in any sub-directory.
+
+Some components of ConnMan have environment variable activated debug prints.
+If the environment variable is set, then corresponding component will print
+some extra debugging information.
+Following environment variables can be used:
+ CONNMAN_DHCP_DEBUG DHCPv4 related debug information
+ CONNMAN_DHCPV6_DEBUG DHCPv6 related debug information
+ CONNMAN_IPTABLES_DEBUG Extra information when iptables is used
+ CONNMAN_RESOLV_DEBUG Name resolver debug prints. These debug prints
+ are used when ConnMan resolves host names for
+ its own use.
+ Note that the DNS proxy debug prints do not
+ use this environment variable. For that, one
+ can use "-d src/dnsproxy.c" command line option.
+ CONNMAN_SUPPLICANT_DEBUG Debugging prints for communication between
+ connmand and wpa_supplicant processes.
+ CONNMAN_WEB_DEBUG Debug information when ConnMan does Internet
+ connectivity check in Wispr and 6to4 components.
+
+Example:
+ CONNMAN_WEB_DEBUG=1 src/connmand -n
+
+If timing conditions are relevant then it is recommended command to
+get log traces as follows:
+ connmand -d 2>&1 | ts '[%H:%M:%.S]' | tee connman.log
+
+The 'ts' program is normaly avialable in the moreutils package.
+
+
+Kernel configuration
+====================
+
+In order to support tethering, the following kernel configuration options
+need to be enabled either as modules (m) or builtin (y):
+
+CONFIG_BRIDGE
+CONFIG_IP_NF_TARGET_MASQUERADE
+
+In order to enable CONFIG_IP_NF_TARGET_MASQUERADE, the following options need
+to be enabled also as modules (m) or builtin (y):
+
+CONFIG_NETFILTER
+CONFIG_NF_CONNTRACK_IPV4
+CONFIG_NF_NAT_IPV4
+
+For routing and statistic support in Sessions, the following options
+need to be enabled as modules (m) or builtin (y):
+
+CONFIG_IP_NF_IPTABLES
+CONFIG_IP_MULTIPLE_TABLES
+CONFIG_NETFILTER_NETLINK_ACCT
+CONFIG_NETFILTER_XT_MATCH_NFACCT
+CONFIG_NETFILTER_XT_CONNMARK
+CONFIG_NETFILTER_XT_TARGET_CONNMARK
+CONFIG_NETFILTER_XT_MATCH_CONNMARK
+
+In order to support USB gadget tethering, the following kernel configuration
+options need to be enabled:
+
+CONFIG_USB_GADGET
+CONFIG_USB_ETH
+
+
+wpa_supplicant configuration
+============================
+
+In order to get wpa_supplicant and Connection Manager working properly
+together you should edit wpa_supplicant .config file and set:
+
+CONFIG_WPS=y
+CONFIG_AP=y
+CONFIG_CTRL_IFACE_DBUS_NEW=y
+
+add:
+
+CONFIG_BGSCAN_SIMPLE=y
+
+This last option will enable the support of background scanning while being
+connected, which is necessary when roaming on wifi.
+
+It is recommended to use wpa_supplicant 2.x or later.
+
+If wpa_supplicant is configured to D-Bus autostart, then ConnMan will
+trigger the autostart of wpa_supplicant. However please keep in mind
+that this trigger only happens once. If wpa_supplicant stops or crashes,
+ConnMan does not periodically try to autostart it. It is up to systemd or
+similar service management tool to autostart it.
+
+
+VPN
+===
+
+In order to compile pptp and l2tp VPN plugins, you need ppp development
+package.
+
+To run l2tp you will need
+ - xl2tpd, http://www.xelerance.com/services/software/xl2tpd
+
+To run pptp you will need
+ - pptp client, http://pptpclient.sourceforge.net
+
+Both l2tp and pptp also need pppd.
+
+
+OpenVPN
+=======
+
+Up to version 2.2 of OpenVPN, pushing additional routes from the
+server will not always work. Some of the symptons are that additional
+routes will not be set by ConnMan if the uplink is a cellular
+network. While the same setup works well for a WiFi or ethernet
+uplink.
+
+
+Online check
+============
+
+ConnMan tries to detect if it has Internet connection or not when
+a service is connected. If the online check succeeds the service
+enters Online state, if not it stays in Ready state. The online
+check is also used to detect whether ConnMan is behind a captive
+portal like when you are in hotel and need to pay for connectivity.
+
+The online check is done by trying to fetch status.html document
+from ipv4.connman.net (for IPv4 connectivity) and ipv6.connman.net
+(for IPv6 connectivity). The used URL looks like this
+http://ipv{4|6}.connman.net/online/status.html
+
+During the online check procedure, ConnMan will temporarily install
+a host route to both the ipv4.connman.net and ipv6.connman.net so that
+the online check query can be directed via the correct network
+interface which the connected service is using. This host route is
+automatically removed when the online check is done.
+
+ConnMan sends this very minimal information in http header when doing
+the online check request (example):
+ Host: ipv4.connman.net
+ User-Agent: ConnMan/1.23 wispr
+ Connection: close
+
+Currently following information is returned from connman.net if
+the connection is successfull (200 OK http response code is returned):
+ Server: nginx
+ Date: Mon, 09 Jun 2014 09:25:42 GMT
+ Content-Type: text/html
+ Connection: close
+ X-ConnMan-Status: online
+
+The X-ConnMan-Status field is used in portal detection, if it is missing
+ConnMan will call RequestBrowser method in net.connman.Agent dbus
+interface to handle the portal login if the portal does not support WISPr.
+See doc/agent-api.txt for more details.
+
+
+Information
+===========
+
+Mailing list:
+ connman@connman.net
+
+For additional information about the project visit ConnMan web site:
+ https://01.org/connman
+ http://www.connman.net
+
+You can report bugs at https://01.org/jira/browse/CM
diff --git a/TODO b/TODO
new file mode 100644
index 0000000..dac2ea2
--- /dev/null
+++ b/TODO
@@ -0,0 +1,222 @@
+Background
+==========
+
+- Priority scale: High, Medium and Low
+
+- Complexity scale: C1, C2, C4 and C8.
+ The complexity scale is exponential, with complexity 1 being the
+ lowest complexity. Complexity is a function of both task 'complexity'
+ and task 'scope'.
+
+
+Core
+====
+
+- Personal firewall
+
+ Priority: Low
+ Complexity: C8
+
+ Discuss and implement a basic and safe firewalling strategy into
+ Connman. Provide a D-Bus API for personal firewalling.
+
+
+- PACRunner extensions
+
+ Priority: Low
+ Complexity: C4
+
+ Support more URI schemes, support multiple connections, tighter
+ security integration.
+
+
+- Check logging produced by connman_info()
+
+ Priority: Medium
+ Complexity: C1
+
+ Check that logging produced by connman_info() contains meaningful messages
+ and get rid of the unnecessary ones.
+
+
+- Remove --nobacktrace option
+
+ Priority: Medium
+ Complexity: C1
+ When: 2.0
+
+ Remove the --nobacktrace option or change it to --backtrace depending on
+ the level of systemd integration or other factors.
+
+
+- Clean up data structure usage
+
+ Priority: Medium
+ Complexity: C4
+
+ Use hash tables, queues and lists in the code. Check on the currently used
+ data structures and see if something can be simplified.
+
+
+- Unit tests for DHCP, DNS and HTTP
+
+ Priority: Low
+ Complexity: C4
+
+ Create unit tests for these components starting with DHCP. Use gtest
+ from GLib for this task similarly to what has been done for OBEX in Bluez
+ and oFono in general.
+
+
+- Support other time sources than NTP
+
+ Priority: Low
+ Complexity: C2
+
+ Support other time sources like cellular, GPS in addition to NTP.
+
+
+- Get interface names from src/device.c
+
+ Priority: Low
+ Complexity: C2
+
+ Instead of using ioctls in connman_inet_ifindex and connman_inet_ifname,
+ utilize the information already provided by netlink in src/device.c.
+
+
+- Simplify gateway selection code
+
+ Priority: Low
+ Complexity: C4
+
+ The service list is always sorted according to preference with the
+ first service always owning the default route. See if update_order and
+ find_default_gateway in src/connection.c can be modified to use the
+ sorted service list instead of walking through the gateway_hash.
+
+
+- Support D-Bus ObjectManager
+
+ Priority: Medium
+ Complexity: C4
+
+ Support D-Bus ObjectManager by using functionality already present in
+ ./gdbus. Method calls and signals are already registered with gdbus, but
+ properties and replies especially in Agent are still handled with plain
+ dbus library function calls.
+
+ With this, Manager API is removed, and a WiFi P2P API based on
+ ObjectManager common to Linux desktops can be implemented.
+
+
+WiFi
+====
+
+- Clean up WiFi data structure usage
+
+ Priority: Medium
+ Complexity: C2
+
+ Struct wifi_data is passed as a pointer in some of the wifi plugin
+ callbacks. For example removing a WiFi USB stick causes RTNL and
+ wpa_supplicant to call the wifi plugin at the same time causing the
+ freeing of the wifi data structure. Fix up the code to have proper
+ reference counting or other handling in place for the shared wifi data
+ and the members in the data structure.
+
+
+- EAP-AKA/SIM
+
+ Priority: Medium
+ Complexity: C2
+
+ This EAP is needed for SIM card based network authentication.
+ ConnMan here plays a minor role: Once wpa_supplicant is set up for
+ starting and EAP-AKA/SIM authentication, it will talk to a SIM card
+ through its pcsc-lite API.
+
+
+- EAP-FAST
+
+ Priority: Low
+ Complexity: C1
+
+
+- Removing wpa_supplicant 0.7.x legacy support
+
+ Priority: Low
+ Complexity: C1
+
+ Removing global country property setter in gsupplicant, and removing
+ wifi's technology set_regdom implementation. Removing autoscan fallback.
+ (Note: should be done around the end 2012)
+
+Bluetooth
+=========
+
+- Remove Bluez 4.x support
+
+ Priority: Low
+ Complexity: C1
+
+ Remove plugins/bluetooth-legacy.c support in about 6 month (July 2013) or
+ when Bluez 4.x usage becomes minimal.
+
+Cellular
+========
+
+
+VPN
+===
+
+- IPsec
+
+ Priority: Medium
+ Complexity: C4
+
+
+- L2TP & PPTP compatibility prefix removal
+
+ Priority: Medium
+ Complexity: C1
+ When: connman 2.0
+
+ The VPN config file provisioning patchset contains code that makes
+ PPP options to be marked by "PPPD." prefix. The code supports also
+ old "L2TP." and "PPTP." prefix for PPP options. Remove the compatibility
+ code and only allow "PPPD." prefix for PPP options.
+
+
+- Update VPNC and OpenVPN with Agent support
+
+ Priority: Medium
+ Complexity: C2
+
+ Update VPNC and OpenVPN with VPN Agent support to request possible user
+ ids and passphrases.
+
+
+Tools
+=====
+
+- Add Clock API and MoveBefore/MoveAfter support to connmanctl
+
+ Priority: Low
+ Complexity: C2
+
+ The connmanctl command line tool should support Clock API and Service API
+ MoveBefore/MoveAfter.
+
+
+User Interface
+==============
+
+- GNOME3 UI
+
+ Priority: Low
+ Complexity: C4
+
+ A GNOME3 shell user interface would make it easier for mainstream distros
+ users to use ConnMan. Continue/restart the work at
+ https://github.com/connectivity/gnome-extension-connman
diff --git a/acinclude.m4 b/acinclude.m4
new file mode 100644
index 0000000..9e8e0dc
--- /dev/null
+++ b/acinclude.m4
@@ -0,0 +1,27 @@
+AC_DEFUN([AC_PROG_CC_PIE], [
+ AC_CACHE_CHECK([whether ${CC-cc} accepts -fPIE], ac_cv_prog_cc_pie, [
+ echo 'void f(){}' > conftest.c
+ if test -z "`${CC-cc} -fPIE -pie -c conftest.c 2>&1`"; then
+ ac_cv_prog_cc_pie=yes
+ else
+ ac_cv_prog_cc_pie=no
+ fi
+ rm -rf conftest*
+ ])
+])
+
+AC_DEFUN([COMPILER_FLAGS], [
+ if (test "${CFLAGS}" = ""); then
+ CFLAGS="-Wall -O2 -U_FORTIFY_SOURCE -D_FORTIFY_SOURCE=2"
+ fi
+ if (test "$USE_MAINTAINER_MODE" = "yes"); then
+ CFLAGS+=" -Werror -Wextra"
+ CFLAGS+=" -Wno-unused-parameter"
+ CFLAGS+=" -Wno-missing-field-initializers"
+ CFLAGS+=" -Wdeclaration-after-statement"
+ CFLAGS+=" -Wmissing-declarations"
+ CFLAGS+=" -Wredundant-decls"
+ CFLAGS+=" -Wcast-align"
+ CFLAGS="$CFLAGS -DG_DISABLE_DEPRECATED"
+ fi
+])
diff --git a/bootstrap b/bootstrap
new file mode 100755
index 0000000..fb2c692
--- /dev/null
+++ b/bootstrap
@@ -0,0 +1,9 @@
+#!/bin/sh
+
+cd "`dirname $0`"
+
+aclocal && \
+ autoheader && \
+ libtoolize --automake --copy --force && \
+ automake --add-missing --copy && \
+ autoconf
diff --git a/bootstrap-configure b/bootstrap-configure
new file mode 100755
index 0000000..070c676
--- /dev/null
+++ b/bootstrap-configure
@@ -0,0 +1,20 @@
+#!/bin/sh
+
+if [ -f config.status ]; then
+ make maintainer-clean
+fi
+
+./bootstrap && \
+ ./configure --enable-maintainer-mode \
+ --enable-debug \
+ --prefix=/usr \
+ --mandir=/usr/share/man \
+ --localstatedir=/var \
+ --sysconfdir=/etc \
+ --disable-datafiles \
+ --enable-openconnect=builtin \
+ --enable-openvpn=builtin \
+ --enable-vpnc=builtin \
+ --enable-session-policy-local=builtin \
+ --enable-nmcompat \
+ --enable-polkit $*
diff --git a/client/agent.c b/client/agent.c
new file mode 100644
index 0000000..d020889
--- /dev/null
+++ b/client/agent.c
@@ -0,0 +1,910 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <string.h>
+#include <ctype.h>
+
+#include <gdbus.h>
+
+#include "input.h"
+#include "dbus_helpers.h"
+#include "agent.h"
+
+#define AGENT_INTERFACE "net.connman.Agent"
+#define VPN_AGENT_INTERFACE "net.connman.vpn.Agent"
+
+static DBusConnection *agent_connection;
+
+struct agent_input_data {
+ const char *attribute;
+ bool requested;
+ char *prompt;
+ connmanctl_input_func_t func;
+};
+
+struct agent_data {
+ struct agent_input_data *input;
+ char *interface;
+ bool registered;
+ DBusMessage *message;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ GDBusMethodFunction pending_function;
+};
+
+static void request_input_ssid_return(char *input, void *user_data);
+static void request_input_passphrase_return(char *input, void *user_data);
+static void request_input_string_return(char *input, void *user_data);
+
+enum requestinput {
+ SSID = 0,
+ IDENTITY = 1,
+ PASSPHRASE = 2,
+ WPS = 3,
+ WISPR_USERNAME = 4,
+ WISPR_PASSPHRASE = 5,
+ REQUEST_INPUT_MAX = 6,
+};
+
+static struct agent_input_data agent_input_handler[] = {
+ { "Name", false, "Hidden SSID name? ", request_input_ssid_return },
+ { "Identity", false, "EAP username? ", request_input_string_return },
+ { "Passphrase", false, "Passphrase? ",
+ request_input_passphrase_return },
+ { "WPS", false, "WPS PIN (empty line for pushbutton)? " ,
+ request_input_string_return },
+ { "Username", false, "WISPr username? ", request_input_string_return },
+ { "Password", false, "WISPr password? ", request_input_string_return },
+ { },
+};
+
+static struct agent_data agent_request = {
+ agent_input_handler,
+ AGENT_INTERFACE,
+};
+
+static struct agent_input_data vpnagent_input_handler[] = {
+ { "OpenConnect.Cookie", false, "OpenConnect Cookie? ",
+ request_input_string_return },
+ { "OpenConnect.ServerCert", false,
+ "OpenConnect server certificate hash? ",
+ request_input_string_return },
+ { "OpenConnect.VPNHost", false, "OpenConnect VPN server? ",
+ request_input_string_return },
+ { "Username", false, "VPN username? ", request_input_string_return },
+ { "Password", false, "VPN password? ", request_input_string_return },
+ { },
+};
+
+static struct agent_data vpn_agent_request = {
+ vpnagent_input_handler,
+ VPN_AGENT_INTERFACE,
+};
+
+static int confirm_input(char *input)
+{
+ int i;
+
+ if (!input)
+ return -1;
+
+ for (i = 0; input[i] != '\0'; i++)
+ if (isspace(input[i]) == 0)
+ break;
+
+ if (strcasecmp(&input[i], "yes") == 0 ||
+ strcasecmp(&input[i], "y") == 0)
+ return 1;
+
+ if (strcasecmp(&input[i], "no") == 0 ||
+ strcasecmp(&input[i], "n") == 0)
+ return 0;
+
+ return -1;
+}
+
+static char *strip_path(char *path)
+{
+ char *name = strrchr(path, '/');
+ if (name)
+ name++;
+ else
+ name = path;
+
+ return name;
+}
+
+static char *agent_path(void)
+{
+ static char *path = NULL;
+
+ if (!path)
+ path = g_strdup_printf("/net/connman/connmanctl%d", getpid());
+
+ return path;
+}
+
+static void pending_message_remove(struct agent_data *request)
+{
+ if (request->message) {
+ dbus_message_unref(request->message);
+ request->message = NULL;
+ }
+
+ if (request->reply) {
+ dbus_message_unref(request->reply);
+ request->reply = NULL;
+ }
+}
+
+static void pending_command_complete(char *message)
+{
+ struct agent_data *next_request = NULL;
+ DBusMessage *pending_message;
+ GDBusMethodFunction pending_function;
+
+ __connmanctl_save_rl();
+
+ fprintf(stdout, "%s", message);
+
+ __connmanctl_redraw_rl();
+
+ if (__connmanctl_is_interactive() == true)
+ __connmanctl_command_mode();
+ else
+ __connmanctl_agent_mode("", NULL, NULL);
+
+ if (agent_request.message)
+ next_request = &agent_request;
+ else if (vpn_agent_request.message)
+ next_request = &vpn_agent_request;
+
+ if (!next_request)
+ return;
+
+ pending_message = next_request->message;
+ pending_function = next_request->pending_function;
+ next_request->pending_function = NULL;
+
+ pending_function(agent_connection, next_request->message,
+ next_request);
+
+ dbus_message_unref(pending_message);
+}
+
+static bool handle_message(DBusMessage *message, struct agent_data *request,
+ GDBusMethodFunction function)
+{
+ if (!agent_request.pending_function &&
+ !vpn_agent_request.pending_function)
+ return true;
+
+ request->message = dbus_message_ref(message);
+ request->pending_function = function;
+
+ return false;
+}
+
+static DBusMessage *agent_release(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+
+ if (handle_message(message, request, agent_release) == false)
+ return NULL;
+
+ g_dbus_unregister_interface(connection, agent_path(),
+ request->interface);
+ request->registered = false;
+
+ pending_message_remove(request);
+
+ if (strcmp(request->interface, AGENT_INTERFACE) == 0)
+ pending_command_complete("Agent unregistered by ConnMan\n");
+ else
+ pending_command_complete("VPN Agent unregistered by ConnMan "
+ "VPNd\n");
+
+ if (__connmanctl_is_interactive() == false)
+ __connmanctl_quit();
+
+ return dbus_message_new_method_return(message);
+}
+
+static DBusMessage *agent_cancel(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+
+ if (handle_message(message, request, agent_cancel) == false)
+ return NULL;
+
+ pending_message_remove(request);
+
+ if (strcmp(request->interface, AGENT_INTERFACE) == 0)
+ pending_command_complete("Agent request cancelled by "
+ "ConnMan\n");
+ else
+ pending_command_complete("VPN Agent request cancelled by "
+ "ConnMan VPNd\n");
+
+ return dbus_message_new_method_return(message);
+}
+
+static void request_browser_return(char *input, void *user_data)
+{
+ struct agent_data *request = user_data;
+
+ switch (confirm_input(input)) {
+ case 1:
+ g_dbus_send_reply(agent_connection, request->message,
+ DBUS_TYPE_INVALID);
+ break;
+ case 0:
+ g_dbus_send_error(agent_connection, request->message,
+ "net.connman.Agent.Error.Canceled", NULL);
+ break;
+ default:
+ return;
+ }
+
+ pending_message_remove(request);
+ pending_command_complete("");
+}
+
+static DBusMessage *agent_request_browser(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+ DBusMessageIter iter;
+ char *service, *url;
+
+ if (handle_message(message, request, agent_request_browser) == false)
+ return NULL;
+
+ dbus_message_iter_init(message, &iter);
+
+ dbus_message_iter_get_basic(&iter, &service);
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_get_basic(&iter, &url);
+
+ __connmanctl_save_rl();
+ fprintf(stdout, "Agent RequestBrowser %s\n", strip_path(service));
+ fprintf(stdout, " %s\n", url);
+ __connmanctl_redraw_rl();
+
+ request->message = dbus_message_ref(message);
+ __connmanctl_agent_mode("Connected (yes/no)? ",
+ request_browser_return, request);
+
+ return NULL;
+}
+
+static void report_error_return(char *input, void *user_data)
+{
+ struct agent_data *request = user_data;
+
+ switch (confirm_input(input)) {
+ case 1:
+ if (strcmp(request->interface, AGENT_INTERFACE) == 0)
+ g_dbus_send_error(agent_connection, request->message,
+ "net.connman.Agent.Error.Retry", NULL);
+ else
+ g_dbus_send_error(agent_connection, request->message,
+ "net.connman.vpn.Agent.Error.Retry",
+ NULL);
+ break;
+ case 0:
+ g_dbus_send_reply(agent_connection, request->message,
+ DBUS_TYPE_INVALID);
+ break;
+ default:
+ return;
+ }
+
+ pending_message_remove(request);
+ pending_command_complete("");
+}
+
+static DBusMessage *agent_report_error(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+ DBusMessageIter iter;
+ char *path, *service, *error;
+
+ if (handle_message(message, request, agent_report_error) == false)
+ return NULL;
+
+ dbus_message_iter_init(message, &iter);
+
+ dbus_message_iter_get_basic(&iter, &path);
+ service = strip_path(path);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_get_basic(&iter, &error);
+
+ __connmanctl_save_rl();
+ if (strcmp(request->interface, AGENT_INTERFACE) == 0)
+ fprintf(stdout, "Agent ReportError %s\n", service);
+ else
+ fprintf(stdout, "VPN Agent ReportError %s\n", service);
+ fprintf(stdout, " %s\n", error);
+ __connmanctl_redraw_rl();
+
+ request->message = dbus_message_ref(message);
+ __connmanctl_agent_mode("Retry (yes/no)? ", report_error_return,
+ request);
+
+ return NULL;
+}
+
+static DBusMessage *agent_report_peer_error(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+ char *path, *peer, *error;
+ DBusMessageIter iter;
+
+ if (handle_message(message, request,
+ agent_report_peer_error) == false)
+ return NULL;
+
+ dbus_message_iter_init(message, &iter);
+
+ dbus_message_iter_get_basic(&iter, &path);
+ peer = strip_path(path);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_get_basic(&iter, &error);
+
+ __connmanctl_save_rl();
+ fprintf(stdout, "Agent ReportPeerError %s\n", peer);
+ fprintf(stdout, " %s\n", error);
+ __connmanctl_redraw_rl();
+
+ request->message = dbus_message_ref(message);
+ __connmanctl_agent_mode("Retry (yes/no)? ",
+ report_error_return, request);
+ return NULL;
+}
+
+static void request_input_next(struct agent_data *request)
+{
+ int i;
+
+ for (i = 0; request->input[i].attribute; i++) {
+ if (request->input[i].requested == true) {
+ if (request->input[i].func)
+ __connmanctl_agent_mode(request->input[i].prompt,
+ request->input[i].func,
+ request);
+ else
+ request->input[i].requested = false;
+ return;
+ }
+ }
+
+ dbus_message_iter_close_container(&request->iter, &request->dict);
+
+ g_dbus_send_message(agent_connection, request->reply);
+ request->reply = NULL;
+
+ pending_message_remove(request);
+ pending_command_complete("");
+
+ __connmanctl_redraw_rl();
+}
+
+static void request_input_append(struct agent_data *request,
+ const char *attribute, char *value)
+{
+ __connmanctl_dbus_append_dict_entry(&request->dict, attribute,
+ DBUS_TYPE_STRING, &value);
+}
+
+static void request_input_ssid_return(char *input,
+ void *user_data)
+{
+ struct agent_data *request = user_data;
+ int len = 0;
+
+ if (input)
+ len = strlen(input);
+
+ if (len > 0 && len <= 32) {
+ request->input[SSID].requested = false;
+ request_input_append(request, request->input[SSID].attribute,
+ input);
+
+ request_input_next(request);
+ }
+}
+
+static void request_input_passphrase_return(char *input, void *user_data)
+{
+ struct agent_data *request = user_data;
+ int len = 0;
+
+ /* TBD passphrase length checking */
+
+ if (input)
+ len = strlen(input);
+
+ if (len == 0 && request->input[WPS].requested == false)
+ return;
+
+ request->input[PASSPHRASE].requested = false;
+
+ if (len > 0) {
+ request_input_append(request,
+ request->input[PASSPHRASE].attribute, input);
+
+ request->input[WPS].requested = false;
+ }
+
+ request_input_next(request);
+}
+
+static void request_input_string_return(char *input, void *user_data)
+{
+ struct agent_data *request = user_data;
+ int i;
+
+ for (i = 0; request->input[i].attribute; i++) {
+ if (request->input[i].requested == true) {
+ request_input_append(request,
+ request->input[i].attribute, input);
+ request->input[i].requested = false;
+ break;
+ }
+ }
+
+ request_input_next(request);
+}
+
+static void parse_agent_request(struct agent_data *request,
+ DBusMessageIter *iter)
+{
+ DBusMessageIter dict, entry, variant, dict_entry;
+ DBusMessageIter field_entry, field_value;
+ char *field, *argument, *value;
+ char *attr_type = NULL;
+ int i;
+
+ dbus_message_iter_recurse(iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ dbus_message_iter_get_basic(&entry, &field);
+
+ dbus_message_iter_next(&entry);
+
+ dbus_message_iter_recurse(&entry, &variant);
+ dbus_message_iter_recurse(&variant, &dict_entry);
+
+ while (dbus_message_iter_get_arg_type(&dict_entry)
+ == DBUS_TYPE_DICT_ENTRY) {
+ dbus_message_iter_recurse(&dict_entry, &field_entry);
+
+ dbus_message_iter_get_basic(&field_entry, &argument);
+
+ dbus_message_iter_next(&field_entry);
+
+ dbus_message_iter_recurse(&field_entry, &field_value);
+
+ if (strcmp(argument, "Type") == 0) {
+ dbus_message_iter_get_basic(&field_value,
+ &value);
+ attr_type = g_strdup(value);
+ }
+
+ dbus_message_iter_next(&dict_entry);
+ }
+
+ for (i = 0; request->input[i].attribute; i++) {
+ if (strcmp(field, request->input[i].attribute) == 0) {
+ request->input[i].requested = true;
+ break;
+ }
+ }
+
+ g_free(attr_type);
+ attr_type = NULL;
+
+ dbus_message_iter_next(&dict);
+ }
+}
+
+static DBusMessage *agent_request_input(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+ DBusMessageIter iter, dict;
+ char *service, *str;
+
+ if (handle_message(message, request, agent_request_input) == false)
+ return NULL;
+
+ dbus_message_iter_init(message, &iter);
+
+ dbus_message_iter_get_basic(&iter, &str);
+ service = strip_path(str);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &dict);
+
+ __connmanctl_save_rl();
+ if (strcmp(request->interface, AGENT_INTERFACE) == 0)
+ fprintf(stdout, "Agent RequestInput %s\n", service);
+ else
+ fprintf(stdout, "VPN Agent RequestInput %s\n", service);
+ __connmanctl_dbus_print(&dict, " ", " = ", "\n");
+ fprintf(stdout, "\n");
+
+ parse_agent_request(request, &iter);
+
+ request->reply = dbus_message_new_method_return(message);
+ dbus_message_iter_init_append(request->reply, &request->iter);
+
+ dbus_message_iter_open_container(&request->iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &request->dict);
+
+ request_input_next(request);
+
+ return NULL;
+}
+
+static void request_authorization_return(char *input, void *user_data)
+{
+ struct agent_data *request = user_data;
+
+ switch (confirm_input(input)) {
+ case 1:
+ request->reply = dbus_message_new_method_return(
+ request->message);
+ dbus_message_iter_init_append(request->reply, &request->iter);
+
+ dbus_message_iter_open_container(&request->iter,
+ DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &request->dict);
+ dbus_message_iter_close_container(&request->iter,
+ &request->dict);
+ g_dbus_send_message(agent_connection, request->reply);
+ request->reply = NULL;
+ break;
+ case 0:
+ g_dbus_send_error(agent_connection, request->message,
+ "net.connman.Agent.Error.Rejected", NULL);
+ break;
+ default:
+ g_dbus_send_error(agent_connection, request->message,
+ "net.connman.Agent.Error.Canceled", NULL);
+ break;
+ }
+
+ pending_message_remove(request);
+ pending_command_complete("");
+}
+
+static DBusMessage *
+agent_request_peer_authorization(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct agent_data *request = user_data;
+ DBusMessageIter iter, dict;
+ char *peer, *str;
+ bool input;
+ int i;
+
+ if (handle_message(message, request, agent_request_peer_authorization)
+ == false)
+ return NULL;
+
+ dbus_message_iter_init(message, &iter);
+
+ dbus_message_iter_get_basic(&iter, &str);
+ peer = strip_path(str);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &dict);
+
+ __connmanctl_save_rl();
+ fprintf(stdout, "Agent RequestPeerAuthorization %s\n", peer);
+ __connmanctl_dbus_print(&dict, " ", " = ", "\n");
+ fprintf(stdout, "\n");
+
+ parse_agent_request(request, &iter);
+
+ for (input = false, i = 0; request->input[i].attribute; i++) {
+ if (request->input[i].requested == true) {
+ input = true;
+ break;
+ }
+ }
+
+ if (!input) {
+ request->message = dbus_message_ref(message);
+ __connmanctl_agent_mode("Accept connection (yes/no)? ",
+ request_authorization_return, request);
+ return NULL;
+ }
+
+ request->reply = dbus_message_new_method_return(message);
+ dbus_message_iter_init_append(request->reply, &request->iter);
+
+ dbus_message_iter_open_container(&request->iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &request->dict);
+
+ request_input_next(request);
+
+ return NULL;
+}
+
+static const GDBusMethodTable agent_methods[] = {
+ { GDBUS_ASYNC_METHOD("Release", NULL, NULL, agent_release) },
+ { GDBUS_ASYNC_METHOD("Cancel", NULL, NULL, agent_cancel) },
+ { GDBUS_ASYNC_METHOD("RequestBrowser",
+ GDBUS_ARGS({ "service", "o" },
+ { "url", "s" }),
+ NULL, agent_request_browser) },
+ { GDBUS_ASYNC_METHOD("ReportError",
+ GDBUS_ARGS({ "service", "o" },
+ { "error", "s" }),
+ NULL, agent_report_error) },
+ { GDBUS_ASYNC_METHOD("ReportPeerError",
+ GDBUS_ARGS({ "peer", "o" },
+ { "error", "s" }),
+ NULL, agent_report_peer_error) },
+ { GDBUS_ASYNC_METHOD("RequestInput",
+ GDBUS_ARGS({ "service", "o" },
+ { "fields", "a{sv}" }),
+ GDBUS_ARGS({ "fields", "a{sv}" }),
+ agent_request_input) },
+ { GDBUS_ASYNC_METHOD("RequestPeerAuthorization",
+ GDBUS_ARGS({ "peer", "o" },
+ { "fields", "a{sv}" }),
+ GDBUS_ARGS({ "fields", "a{sv}" }),
+ agent_request_peer_authorization) },
+ { },
+};
+
+static int agent_register_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ DBusConnection *connection = user_data;
+
+ if (error) {
+ g_dbus_unregister_interface(connection, agent_path(),
+ AGENT_INTERFACE);
+ fprintf(stderr, "Error registering Agent: %s\n", error);
+ return 0;
+ }
+
+ agent_request.registered = true;
+ fprintf(stdout, "Agent registered\n");
+
+ return -EINPROGRESS;
+}
+
+static void append_path(DBusMessageIter *iter, void *user_data)
+{
+ const char *path = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
+}
+
+int __connmanctl_agent_register(DBusConnection *connection)
+{
+ char *path = agent_path();
+ int result;
+
+ if (agent_request.registered == true) {
+ fprintf(stderr, "Agent already registered\n");
+ return -EALREADY;
+ }
+
+ agent_connection = connection;
+
+ if (!g_dbus_register_interface(connection, path,
+ AGENT_INTERFACE, agent_methods,
+ NULL, NULL, &agent_request, NULL)) {
+ fprintf(stderr, "Error: Failed to register Agent callbacks\n");
+ return 0;
+ }
+
+ result = __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
+ CONNMAN_PATH, "net.connman.Manager", "RegisterAgent",
+ agent_register_return, connection, append_path, path);
+
+ if (result != -EINPROGRESS) {
+ g_dbus_unregister_interface(connection, agent_path(),
+ AGENT_INTERFACE);
+
+ fprintf(stderr, "Error: Failed to register Agent\n");
+ }
+
+ return result;
+}
+
+static int agent_unregister_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error unregistering Agent: %s\n", error);
+ return 0;
+ }
+
+ agent_request.registered = false;
+ fprintf(stdout, "Agent unregistered\n");
+
+ return 0;
+}
+
+int __connmanctl_agent_unregister(DBusConnection *connection)
+{
+ char *path = agent_path();
+ int result;
+
+ if (agent_request.registered == false) {
+ fprintf(stderr, "Agent not registered\n");
+ return -EALREADY;
+ }
+
+ g_dbus_unregister_interface(connection, agent_path(), AGENT_INTERFACE);
+
+ result = __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
+ CONNMAN_PATH, "net.connman.Manager", "UnregisterAgent",
+ agent_unregister_return, NULL, append_path, path);
+
+ if (result != -EINPROGRESS)
+ fprintf(stderr, "Error: Failed to unregister Agent\n");
+
+ return result;
+}
+
+static const GDBusMethodTable vpn_agent_methods[] = {
+ { GDBUS_ASYNC_METHOD("Release", NULL, NULL, agent_release) },
+ { GDBUS_ASYNC_METHOD("Cancel", NULL, NULL, agent_cancel) },
+ { GDBUS_ASYNC_METHOD("ReportError",
+ GDBUS_ARGS({ "service", "o" },
+ { "error", "s" }),
+ NULL, agent_report_error) },
+ { GDBUS_ASYNC_METHOD("RequestInput",
+ GDBUS_ARGS({ "service", "o" },
+ { "fields", "a{sv}" }),
+ GDBUS_ARGS({ "fields", "a{sv}" }),
+ agent_request_input) },
+ { },
+};
+
+static int vpn_agent_register_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ DBusConnection *connection = user_data;
+
+ if (error) {
+ g_dbus_unregister_interface(connection, agent_path(),
+ VPN_AGENT_INTERFACE);
+ fprintf(stderr, "Error registering VPN Agent: %s\n", error);
+ return 0;
+ }
+
+ vpn_agent_request.registered = true;
+ fprintf(stdout, "VPN Agent registered\n");
+
+ return -EINPROGRESS;
+}
+
+int __connmanctl_vpn_agent_register(DBusConnection *connection)
+{
+ char *path = agent_path();
+ int result;
+
+ if (vpn_agent_request.registered == true) {
+ fprintf(stderr, "VPN Agent already registered\n");
+ return -EALREADY;
+ }
+
+ agent_connection = connection;
+
+ if (!g_dbus_register_interface(connection, path,
+ VPN_AGENT_INTERFACE, vpn_agent_methods,
+ NULL, NULL, &vpn_agent_request, NULL)) {
+ fprintf(stderr, "Error: Failed to register VPN Agent "
+ "callbacks\n");
+ return 0;
+ }
+
+ result = __connmanctl_dbus_method_call(connection, VPN_SERVICE,
+ VPN_PATH, "net.connman.vpn.Manager", "RegisterAgent",
+ vpn_agent_register_return, connection, append_path,
+ path);
+
+ if (result != -EINPROGRESS) {
+ g_dbus_unregister_interface(connection, agent_path(),
+ VPN_AGENT_INTERFACE);
+
+ fprintf(stderr, "Error: Failed to register VPN Agent\n");
+ }
+
+ return result;
+}
+
+static int vpn_agent_unregister_return(DBusMessageIter *iter,
+ const char *error, void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error unregistering VPN Agent: %s\n", error);
+ return 0;
+ }
+
+ vpn_agent_request.registered = false;
+ fprintf(stdout, "VPN Agent unregistered\n");
+
+ return 0;
+}
+
+int __connmanctl_vpn_agent_unregister(DBusConnection *connection)
+{
+ char *path = agent_path();
+ int result;
+
+ if (vpn_agent_request.registered == false) {
+ fprintf(stderr, "VPN Agent not registered\n");
+ return -EALREADY;
+ }
+
+ g_dbus_unregister_interface(connection, agent_path(),
+ VPN_AGENT_INTERFACE);
+
+ result = __connmanctl_dbus_method_call(connection, VPN_SERVICE,
+ VPN_PATH, "net.connman.vpn.Manager", "UnregisterAgent",
+ vpn_agent_unregister_return, NULL, append_path, path);
+
+ if (result != -EINPROGRESS)
+ fprintf(stderr, "Error: Failed to unregister VPN Agent\n");
+
+ return result;
+}
diff --git a/client/agent.h b/client/agent.h
new file mode 100644
index 0000000..669a593
--- /dev/null
+++ b/client/agent.h
@@ -0,0 +1,42 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_AGENT_H
+#define __CONNMANCTL_AGENT_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __connmanctl_agent_register(DBusConnection *connection);
+int __connmanctl_agent_unregister(DBusConnection *connection);
+
+int __connmanctl_vpn_agent_register(DBusConnection *connection);
+int __connmanctl_vpn_agent_unregister(DBusConnection *connection);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_AGENT_H */
diff --git a/client/commands.c b/client/commands.c
new file mode 100644
index 0000000..9bed4f6
--- /dev/null
+++ b/client/commands.c
@@ -0,0 +1,2867 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdbool.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <ctype.h>
+
+#include <glib.h>
+#include <gdbus.h>
+
+#include "dbus_helpers.h"
+#include "input.h"
+#include "services.h"
+#include "peers.h"
+#include "commands.h"
+#include "agent.h"
+#include "vpnconnections.h"
+
+static DBusConnection *connection;
+static GHashTable *service_hash;
+static GHashTable *peer_hash;
+static GHashTable *technology_hash;
+static char *session_notify_path;
+static char *session_path;
+static bool session_connected;
+
+struct connman_option {
+ const char *name;
+ const char val;
+ const char *desc;
+};
+
+static char *ipv4[] = {
+ "Method",
+ "Address",
+ "Netmask",
+ "Gateway",
+ NULL
+};
+
+static char *ipv6[] = {
+ "Method",
+ "Address",
+ "PrefixLength",
+ "Gateway",
+ NULL
+};
+
+static int cmd_help(char *args[], int num, struct connman_option *options);
+
+static bool check_dbus_name(const char *name)
+{
+ /*
+ * Valid dbus chars should be [A-Z][a-z][0-9]_
+ * and should not start with number.
+ */
+ unsigned int i;
+
+ if (!name || name[0] == '\0')
+ return false;
+
+ for (i = 0; name[i] != '\0'; i++)
+ if (!((name[i] >= 'A' && name[i] <= 'Z') ||
+ (name[i] >= 'a' && name[i] <= 'z') ||
+ (name[i] >= '0' && name[i] <= '9') ||
+ name[i] == '_'))
+ return false;
+
+ return true;
+}
+
+static int parse_boolean(char *arg)
+{
+ if (!arg)
+ return -1;
+
+ if (strcasecmp(arg, "no") == 0 ||
+ strcasecmp(arg, "false") == 0 ||
+ strcasecmp(arg, "off" ) == 0 ||
+ strcasecmp(arg, "disable" ) == 0 ||
+ strcasecmp(arg, "n") == 0 ||
+ strcasecmp(arg, "f") == 0 ||
+ strcasecmp(arg, "0") == 0)
+ return 0;
+
+ if (strcasecmp(arg, "yes") == 0 ||
+ strcasecmp(arg, "true") == 0 ||
+ strcasecmp(arg, "on") == 0 ||
+ strcasecmp(arg, "enable" ) == 0 ||
+ strcasecmp(arg, "y") == 0 ||
+ strcasecmp(arg, "t") == 0 ||
+ strcasecmp(arg, "1") == 0)
+ return 1;
+
+ return -1;
+}
+
+static int parse_args(char *arg, struct connman_option *options)
+{
+ int i;
+
+ if (!arg)
+ return -1;
+
+ for (i = 0; options[i].name; i++) {
+ if (strcmp(options[i].name, arg) == 0 ||
+ (strncmp(arg, "--", 2) == 0 &&
+ strcmp(&arg[2], options[i].name) == 0))
+ return options[i].val;
+ }
+
+ return '?';
+}
+
+static int enable_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *tech = user_data;
+ char *str;
+
+ str = strrchr(tech, '/');
+ if (str)
+ str++;
+ else
+ str = tech;
+
+ if (!error)
+ fprintf(stdout, "Enabled %s\n", str);
+ else
+ fprintf(stderr, "Error %s: %s\n", str, error);
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int cmd_enable(char *args[], int num, struct connman_option *options)
+{
+ char *tech;
+ dbus_bool_t b = TRUE;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ if (check_dbus_name(args[1]) == false)
+ return -EINVAL;
+
+ if (strcmp(args[1], "offline") == 0) {
+ tech = g_strdup(args[1]);
+ return __connmanctl_dbus_set_property(connection, "/",
+ "net.connman.Manager", enable_return, tech,
+ "OfflineMode", DBUS_TYPE_BOOLEAN, &b);
+ }
+
+ tech = g_strdup_printf("/net/connman/technology/%s", args[1]);
+ return __connmanctl_dbus_set_property(connection, tech,
+ "net.connman.Technology", enable_return, tech,
+ "Powered", DBUS_TYPE_BOOLEAN, &b);
+}
+
+static int disable_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *tech = user_data;
+ char *str;
+
+ str = strrchr(tech, '/');
+ if (str)
+ str++;
+ else
+ str = tech;
+
+ if (!error)
+ fprintf(stdout, "Disabled %s\n", str);
+ else
+ fprintf(stderr, "Error %s: %s\n", str, error);
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int cmd_disable(char *args[], int num, struct connman_option *options)
+{
+ char *tech;
+ dbus_bool_t b = FALSE;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ if (check_dbus_name(args[1]) == false)
+ return -EINVAL;
+
+ if (strcmp(args[1], "offline") == 0) {
+ tech = g_strdup(args[1]);
+ return __connmanctl_dbus_set_property(connection, "/",
+ "net.connman.Manager", disable_return, tech,
+ "OfflineMode", DBUS_TYPE_BOOLEAN, &b);
+ }
+
+ tech = g_strdup_printf("/net/connman/technology/%s", args[1]);
+ return __connmanctl_dbus_set_property(connection, tech,
+ "net.connman.Technology", disable_return, tech,
+ "Powered", DBUS_TYPE_BOOLEAN, &b);
+}
+
+static int state_print(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ DBusMessageIter entry;
+
+ if (error) {
+ fprintf(stderr, "Error: %s", error);
+ return 0;
+ }
+
+ dbus_message_iter_recurse(iter, &entry);
+ __connmanctl_dbus_print(&entry, " ", " = ", "\n");
+ fprintf(stdout, "\n");
+
+ return 0;
+}
+
+static int cmd_state(char *args[], int num, struct connman_option *options)
+{
+ if (num > 1)
+ return -E2BIG;
+
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
+ CONNMAN_PATH, "net.connman.Manager", "GetProperties",
+ state_print, NULL, NULL, NULL);
+}
+
+static int services_list(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (!error) {
+ __connmanctl_services_list(iter);
+ fprintf(stdout, "\n");
+ } else {
+ fprintf(stderr, "Error: %s\n", error);
+ }
+
+ return 0;
+}
+
+static int peers_list(DBusMessageIter *iter,
+ const char *error, void *user_data)
+{
+ if (!error) {
+ __connmanctl_peers_list(iter);
+ fprintf(stdout, "\n");
+ } else
+ fprintf(stderr, "Error: %s\n", error);
+
+ return 0;
+}
+
+static int object_properties(DBusMessageIter *iter,
+ const char *error, void *user_data)
+{
+ char *path = user_data;
+ char *str;
+ DBusMessageIter dict;
+
+ if (!error) {
+ fprintf(stdout, "%s\n", path);
+
+ dbus_message_iter_recurse(iter, &dict);
+ __connmanctl_dbus_print(&dict, " ", " = ", "\n");
+
+ fprintf(stdout, "\n");
+
+ } else {
+ str = strrchr(path, '/');
+ if (str)
+ str++;
+ else
+ str = path;
+
+ fprintf(stderr, "Error %s: %s\n", str, error);
+ }
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int cmd_services(char *args[], int num, struct connman_option *options)
+{
+ char *service_name = NULL;
+ char *path;
+ int c;
+
+ if (num > 3)
+ return -E2BIG;
+
+ c = parse_args(args[1], options);
+ switch (c) {
+ case -1:
+ break;
+ case 'p':
+ if (num < 3)
+ return -EINVAL;
+ service_name = args[2];
+ break;
+ default:
+ if (num > 2)
+ return -E2BIG;
+ service_name = args[1];
+ break;
+ }
+
+ if (!service_name) {
+ return __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, CONNMAN_PATH,
+ "net.connman.Manager", "GetServices",
+ services_list, NULL, NULL, NULL);
+ }
+
+ if (check_dbus_name(service_name) == false)
+ return -EINVAL;
+
+ path = g_strdup_printf("/net/connman/service/%s", service_name);
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE, path,
+ "net.connman.Service", "GetProperties",
+ object_properties, path, NULL, NULL);
+}
+
+static int cmd_peers(char *args[], int num, struct connman_option *options)
+{
+ char *peer_name = NULL;
+ char *path;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num == 2)
+ peer_name = args[1];
+
+ if (!peer_name) {
+ return __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, CONNMAN_PATH,
+ "net.connman.Manager", "GetPeers",
+ peers_list, NULL, NULL, NULL);
+ }
+
+ if (check_dbus_name(peer_name) == false)
+ return -EINVAL;
+
+ path = g_strdup_printf("/net/connman/peer/%s", peer_name);
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
+ path, "net.connman.Peer", "GetProperties",
+ object_properties, path, NULL, NULL);
+}
+
+static int technology_print(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ DBusMessageIter array;
+
+ if (error) {
+ fprintf(stderr, "Error: %s\n", error);
+ return 0;
+ }
+
+ dbus_message_iter_recurse(iter, &array);
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter entry, dict;
+ const char *path;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &path);
+ fprintf(stdout, "%s\n", path);
+
+ dbus_message_iter_next(&entry);
+
+ dbus_message_iter_recurse(&entry, &dict);
+ __connmanctl_dbus_print(&dict, " ", " = ", "\n");
+ fprintf(stdout, "\n");
+
+ dbus_message_iter_next(&array);
+ }
+
+ return 0;
+}
+
+static int cmd_technologies(char *args[], int num,
+ struct connman_option *options)
+{
+ if (num > 1)
+ return -E2BIG;
+
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
+ CONNMAN_PATH, "net.connman.Manager", "GetTechnologies",
+ technology_print, NULL, NULL, NULL);
+}
+
+struct tether_enable {
+ char *path;
+ dbus_bool_t enable;
+};
+
+static int tether_set_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ struct tether_enable *tether = user_data;
+ char *str;
+
+ str = strrchr(tether->path, '/');
+ if (str)
+ str++;
+ else
+ str = tether->path;
+
+ if (!error) {
+ fprintf(stdout, "%s tethering for %s\n",
+ tether->enable ? "Enabled" : "Disabled",
+ str);
+ } else
+ fprintf(stderr, "Error %s %s tethering: %s\n",
+ tether->enable ?
+ "enabling" : "disabling", str, error);
+
+ g_free(tether->path);
+ g_free(user_data);
+
+ return 0;
+}
+
+static int tether_set(char *technology, int set_tethering)
+{
+ struct tether_enable *tether = g_new(struct tether_enable, 1);
+
+ switch(set_tethering) {
+ case 1:
+ tether->enable = TRUE;
+ break;
+ case 0:
+ tether->enable = FALSE;
+ break;
+ default:
+ g_free(tether);
+ return 0;
+ }
+
+ tether->path = g_strdup_printf("/net/connman/technology/%s",
+ technology);
+
+ return __connmanctl_dbus_set_property(connection, tether->path,
+ "net.connman.Technology", tether_set_return,
+ tether, "Tethering", DBUS_TYPE_BOOLEAN,
+ &tether->enable);
+}
+
+struct tether_properties {
+ int ssid_result;
+ int passphrase_result;
+ int set_tethering;
+};
+
+static int tether_update(struct tether_properties *tether)
+{
+ if (tether->ssid_result == 0 && tether->passphrase_result == 0)
+ return tether_set("wifi", tether->set_tethering);
+
+ if (tether->ssid_result != -EINPROGRESS &&
+ tether->passphrase_result != -EINPROGRESS) {
+ g_free(tether);
+ return 0;
+ }
+
+ return -EINPROGRESS;
+}
+
+static int tether_set_ssid_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ struct tether_properties *tether = user_data;
+
+ if (!error) {
+ fprintf(stdout, "Wifi SSID set\n");
+ tether->ssid_result = 0;
+ } else {
+ fprintf(stderr, "Error setting wifi SSID: %s\n", error);
+ tether->ssid_result = -EINVAL;
+ }
+
+ return tether_update(tether);
+}
+
+static int tether_set_passphrase_return(DBusMessageIter *iter,
+ const char *error, void *user_data)
+{
+ struct tether_properties *tether = user_data;
+
+ if (!error) {
+ fprintf(stdout, "Wifi passphrase set\n");
+ tether->passphrase_result = 0;
+ } else {
+ fprintf(stderr, "Error setting wifi passphrase: %s\n", error);
+ tether->passphrase_result = -EINVAL;
+ }
+
+ return tether_update(tether);
+}
+
+static int tether_set_ssid(char *ssid, char *passphrase, int set_tethering)
+{
+ struct tether_properties *tether = g_new(struct tether_properties, 1);
+
+ tether->set_tethering = set_tethering;
+
+ tether->ssid_result = __connmanctl_dbus_set_property(connection,
+ "/net/connman/technology/wifi",
+ "net.connman.Technology",
+ tether_set_ssid_return, tether,
+ "TetheringIdentifier", DBUS_TYPE_STRING, &ssid);
+
+ tether->passphrase_result =__connmanctl_dbus_set_property(connection,
+ "/net/connman/technology/wifi",
+ "net.connman.Technology",
+ tether_set_passphrase_return, tether,
+ "TetheringPassphrase", DBUS_TYPE_STRING, &passphrase);
+
+ if (tether->ssid_result != -EINPROGRESS &&
+ tether->passphrase_result != -EINPROGRESS) {
+ g_free(tether);
+ return -ENXIO;
+ }
+
+ return -EINPROGRESS;
+}
+
+static int cmd_tether(char *args[], int num, struct connman_option *options)
+{
+ char *ssid, *passphrase;
+ int set_tethering;
+
+ if (num < 3)
+ return -EINVAL;
+
+ passphrase = args[num - 1];
+ ssid = args[num - 2];
+
+ set_tethering = parse_boolean(args[2]);
+
+ if (strcmp(args[1], "wifi") == 0) {
+
+ if (num > 5)
+ return -E2BIG;
+
+ if (num == 5 && set_tethering == -1)
+ return -EINVAL;
+
+ if (num == 4)
+ set_tethering = -1;
+
+ if (num > 3)
+ return tether_set_ssid(ssid, passphrase, set_tethering);
+ }
+
+ if (num > 3)
+ return -E2BIG;
+
+ if (set_tethering == -1)
+ return -EINVAL;
+
+ if (check_dbus_name(args[1]) == false)
+ return -EINVAL;
+
+ return tether_set(args[1], set_tethering);
+}
+
+static int scan_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *path = user_data;
+
+ if (!error) {
+ char *str = strrchr(path, '/');
+ str++;
+ fprintf(stdout, "Scan completed for %s\n", str);
+ } else
+ fprintf(stderr, "Error %s: %s\n", path, error);
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int cmd_scan(char *args[], int num, struct connman_option *options)
+{
+ char *path;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ if (check_dbus_name(args[1]) == false)
+ return -EINVAL;
+
+ path = g_strdup_printf("/net/connman/technology/%s", args[1]);
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE, path,
+ "net.connman.Technology", "Scan",
+ scan_return, path, NULL, NULL);
+}
+
+static int connect_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *path = user_data;
+
+ if (!error) {
+ char *str = strrchr(path, '/');
+ str++;
+ fprintf(stdout, "Connected %s\n", str);
+ } else
+ fprintf(stderr, "Error %s: %s\n", path, error);
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int cmd_connect(char *args[], int num, struct connman_option *options)
+{
+ const char *iface = "net.connman.Service";
+ char *path;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ if (check_dbus_name(args[1]) == false)
+ return -EINVAL;
+
+ if (g_strstr_len(args[1], 5, "peer_") == args[1]) {
+ iface = "net.connman.Peer";
+ path = g_strdup_printf("/net/connman/peer/%s", args[1]);
+ } else
+ path = g_strdup_printf("/net/connman/service/%s", args[1]);
+
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE, path,
+ iface, "Connect", connect_return, path, NULL, NULL);
+}
+
+static int disconnect_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *path = user_data;
+
+ if (!error) {
+ char *str = strrchr(path, '/');
+ str++;
+ fprintf(stdout, "Disconnected %s\n", str);
+ } else
+ fprintf(stderr, "Error %s: %s\n", path, error);
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int cmd_disconnect(char *args[], int num, struct connman_option *options)
+{
+ const char *iface = "net.connman.Service";
+ char *path;
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ if (check_dbus_name(args[1]) == false)
+ return -EINVAL;
+
+ if (g_strstr_len(args[1], 5, "peer_") == args[1]) {
+ iface = "net.connman.Peer";
+ path = g_strdup_printf("/net/connman/peer/%s", args[1]);
+ } else
+ path = g_strdup_printf("/net/connman/service/%s", args[1]);
+
+ return __connmanctl_dbus_method_call(connection, CONNMAN_SERVICE,
+ path, iface, "Disconnect",
+ disconnect_return, path, NULL, NULL);
+}
+
+static int config_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *service_name = user_data;
+
+ if (error)
+ fprintf(stderr, "Error %s: %s\n", service_name, error);
+
+ g_free(user_data);
+
+ return 0;
+}
+
+struct config_append {
+ char **opts;
+ int values;
+};
+
+static void config_append_ipv4(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+ int i = 0;
+
+ if (!opts)
+ return;
+
+ while (opts[i] && ipv4[i]) {
+ __connmanctl_dbus_append_dict_entry(iter, ipv4[i],
+ DBUS_TYPE_STRING, &opts[i]);
+ i++;
+ }
+
+ append->values = i;
+}
+
+static void config_append_ipv6(DBusMessageIter *iter, void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+
+ if (!opts)
+ return;
+
+ append->values = 1;
+
+ if (g_strcmp0(opts[0], "auto") == 0) {
+ char *str;
+
+ switch (parse_boolean(opts[1])) {
+ case 0:
+ append->values = 2;
+
+ str = "disabled";
+ __connmanctl_dbus_append_dict_entry(iter, "Privacy",
+ DBUS_TYPE_STRING, &str);
+ break;
+
+ case 1:
+ append->values = 2;
+
+ str = "enabled";
+ __connmanctl_dbus_append_dict_entry(iter, "Privacy",
+ DBUS_TYPE_STRING, &str);
+ break;
+
+ default:
+ if (opts[1]) {
+ append->values = 2;
+
+ if (g_strcmp0(opts[1], "prefered") != 0 &&
+ g_strcmp0(opts[1],
+ "preferred") != 0) {
+ fprintf(stderr, "Error %s: %s\n",
+ opts[1],
+ strerror(EINVAL));
+ return;
+ }
+
+ str = "prefered";
+ __connmanctl_dbus_append_dict_entry(iter,
+ "Privacy", DBUS_TYPE_STRING,
+ &str);
+ }
+ break;
+ }
+ } else if (g_strcmp0(opts[0], "manual") == 0) {
+ int i = 1;
+
+ while (opts[i] && ipv6[i]) {
+ if (i == 2) {
+ int value = atoi(opts[i]);
+ __connmanctl_dbus_append_dict_entry(iter,
+ ipv6[i], DBUS_TYPE_BYTE,
+ &value);
+ } else {
+ __connmanctl_dbus_append_dict_entry(iter,
+ ipv6[i], DBUS_TYPE_STRING,
+ &opts[i]);
+ }
+ i++;
+ }
+
+ append->values = i;
+
+ } else if (g_strcmp0(opts[0], "off") != 0) {
+ fprintf(stderr, "Error %s: %s\n", opts[0], strerror(EINVAL));
+
+ return;
+ }
+
+ __connmanctl_dbus_append_dict_entry(iter, "Method", DBUS_TYPE_STRING,
+ &opts[0]);
+}
+
+static void config_append_str(DBusMessageIter *iter, void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+ int i = 0;
+
+ if (!opts)
+ return;
+
+ while (opts[i]) {
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &opts[i]);
+ i++;
+ }
+
+ append->values = i;
+}
+
+static void append_servers(DBusMessageIter *iter, void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+ int i = 1;
+
+ if (!opts)
+ return;
+
+ while (opts[i] && g_strcmp0(opts[i], "--excludes") != 0) {
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &opts[i]);
+ i++;
+ }
+
+ append->values = i;
+}
+
+static void append_excludes(DBusMessageIter *iter, void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+ int i = append->values;
+
+ if (!opts || !opts[i] ||
+ g_strcmp0(opts[i], "--excludes") != 0)
+ return;
+
+ i++;
+ while (opts[i]) {
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &opts[i]);
+ i++;
+ }
+
+ append->values = i;
+}
+
+static void config_append_proxy(DBusMessageIter *iter, void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+
+ if (!opts)
+ return;
+
+ if (g_strcmp0(opts[0], "manual") == 0) {
+ __connmanctl_dbus_append_dict_string_array(iter, "Servers",
+ append_servers, append);
+
+ __connmanctl_dbus_append_dict_string_array(iter, "Excludes",
+ append_excludes, append);
+
+ } else if (g_strcmp0(opts[0], "auto") == 0) {
+ if (opts[1]) {
+ __connmanctl_dbus_append_dict_entry(iter, "URL",
+ DBUS_TYPE_STRING, &opts[1]);
+ append->values++;
+ }
+
+ } else if (g_strcmp0(opts[0], "direct") != 0)
+ return;
+
+ __connmanctl_dbus_append_dict_entry(iter, "Method",DBUS_TYPE_STRING,
+ &opts[0]);
+
+ append->values++;
+}
+
+static int cmd_config(char *args[], int num, struct connman_option *options)
+{
+ int result = 0, res = 0, index = 2, oldindex = 0;
+ int c;
+ char *service_name, *path;
+ char **opt_start;
+ dbus_bool_t val;
+ dbus_int32_t order;
+ struct config_append append;
+
+ service_name = args[1];
+ if (!service_name)
+ return -EINVAL;
+
+ if (check_dbus_name(service_name) == false)
+ return -EINVAL;
+
+ while (index < num && args[index]) {
+ c = parse_args(args[index], options);
+ opt_start = &args[index + 1];
+ append.opts = opt_start;
+ append.values = 0;
+
+ res = 0;
+
+ oldindex = index;
+ path = g_strdup_printf("/net/connman/service/%s", service_name);
+
+ switch (c) {
+ case 'a':
+ switch (parse_boolean(*opt_start)) {
+ case 1:
+ val = TRUE;
+ break;
+ case 0:
+ val = FALSE;
+ break;
+ default:
+ res = -EINVAL;
+ break;
+ }
+
+ index++;
+
+ if (res == 0) {
+ res = __connmanctl_dbus_set_property(connection,
+ path, "net.connman.Service",
+ config_return,
+ g_strdup(service_name),
+ "AutoConnect",
+ DBUS_TYPE_BOOLEAN, &val);
+ }
+ break;
+ case 'i':
+ res = __connmanctl_dbus_set_property_dict(connection,
+ path, "net.connman.Service",
+ config_return, g_strdup(service_name),
+ "IPv4.Configuration", DBUS_TYPE_STRING,
+ config_append_ipv4, &append);
+ index += append.values;
+ break;
+
+ case 'v':
+ res = __connmanctl_dbus_set_property_dict(connection,
+ path, "net.connman.Service",
+ config_return, g_strdup(service_name),
+ "IPv6.Configuration", DBUS_TYPE_STRING,
+ config_append_ipv6, &append);
+ index += append.values;
+ break;
+
+ case 'n':
+ res = __connmanctl_dbus_set_property_array(connection,
+ path, "net.connman.Service",
+ config_return, g_strdup(service_name),
+ "Nameservers.Configuration",
+ DBUS_TYPE_STRING, config_append_str,
+ &append);
+ index += append.values;
+ break;
+
+ case 't':
+ res = __connmanctl_dbus_set_property_array(connection,
+ path, "net.connman.Service",
+ config_return, g_strdup(service_name),
+ "Timeservers.Configuration",
+ DBUS_TYPE_STRING, config_append_str,
+ &append);
+ index += append.values;
+ break;
+
+ case 'd':
+ res = __connmanctl_dbus_set_property_array(connection,
+ path, "net.connman.Service",
+ config_return, g_strdup(service_name),
+ "Domains.Configuration",
+ DBUS_TYPE_STRING, config_append_str,
+ &append);
+ index += append.values;
+ break;
+
+ case 'x':
+ res = __connmanctl_dbus_set_property_dict(connection,
+ path, "net.connman.Service",
+ config_return, g_strdup(service_name),
+ "Proxy.Configuration",
+ DBUS_TYPE_STRING, config_append_proxy,
+ &append);
+ index += append.values;
+ break;
+ case 'r':
+ res = __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, path,
+ "net.connman.Service", "Remove",
+ config_return, g_strdup(service_name),
+ NULL, NULL);
+ break;
+
+ case 'o':
+ order = atoi(*opt_start);
+ res = __connmanctl_dbus_set_property(connection,
+ path, "net.connman.Service",
+ config_return,
+ g_strdup(service_name),
+ "Order",
+ DBUS_TYPE_INT32, &order);
+ index++;
+ break;
+
+ default:
+ res = -EINVAL;
+ break;
+ }
+
+ g_free(path);
+
+ if (res < 0) {
+ if (res == -EINPROGRESS)
+ result = -EINPROGRESS;
+ else
+ printf("Error '%s': %s\n", args[oldindex],
+ strerror(-res));
+ } else
+ index += res;
+
+ index++;
+ }
+
+ return result;
+}
+
+static DBusHandlerResult monitor_changed(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter;
+ const char *interface, *path;
+
+ interface = dbus_message_get_interface(message);
+ if (!interface)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (strncmp(interface, "net.connman.", 12) != 0)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (!strcmp(interface, "net.connman.Agent") ||
+ !strcmp(interface, "net.connman.vpn.Agent") ||
+ !strcmp(interface, "net.connman.Session") ||
+ !strcmp(interface, "net.connman.Notification"))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ interface = strrchr(interface, '.');
+ if (interface && *interface != '\0')
+ interface++;
+
+ path = strrchr(dbus_message_get_path(message), '/');
+ if (path && *path != '\0')
+ path++;
+
+ __connmanctl_save_rl();
+
+ if (dbus_message_is_signal(message, "net.connman.Manager",
+ "ServicesChanged")) {
+
+ fprintf(stdout, "%-12s %-20s = {\n", interface,
+ "ServicesChanged");
+ dbus_message_iter_init(message, &iter);
+ __connmanctl_services_list(&iter);
+ fprintf(stdout, "\n}\n");
+
+ __connmanctl_redraw_rl();
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ } else if (dbus_message_is_signal(message, "net.connman.Manager",
+ "PeersChanged")) {
+ fprintf(stdout, "%-12s %-20s = {\n", interface,
+ "PeersChanged");
+ dbus_message_iter_init(message, &iter);
+ __connmanctl_peers_list(&iter);
+ fprintf(stdout, "\n}\n");
+
+ __connmanctl_redraw_rl();
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ } else if (dbus_message_is_signal(message, "net.connman.vpn.Manager",
+ "ConnectionAdded") ||
+ dbus_message_is_signal(message,
+ "net.connman.vpn.Manager",
+ "ConnectionRemoved")) {
+ interface = "vpn.Manager";
+ path = dbus_message_get_member(message);
+
+ } else if (dbus_message_is_signal(message, "net.connman.Manager",
+ "TechnologyAdded") ||
+ dbus_message_is_signal(message, "net.connman.Manager",
+ "TechnologyRemoved"))
+ path = dbus_message_get_member(message);
+
+ fprintf(stdout, "%-12s %-20s ", interface, path);
+ dbus_message_iter_init(message, &iter);
+
+ __connmanctl_dbus_print(&iter, "", " = ", " = ");
+ fprintf(stdout, "\n");
+
+ __connmanctl_redraw_rl();
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static struct {
+ char *interface;
+ bool enabled;
+} monitor[] = {
+ { "Service", false },
+ { "Technology", false },
+ { "Manager", false },
+ { "vpn.Manager", false },
+ { "vpn.Connection", false },
+ { NULL, },
+};
+
+static void monitor_add(char *interface)
+{
+ bool add_filter = true, found = false;
+ int i;
+ char *rule;
+ DBusError err;
+
+ for (i = 0; monitor[i].interface; i++) {
+ if (monitor[i].enabled == true)
+ add_filter = false;
+
+ if (g_strcmp0(interface, monitor[i].interface) == 0) {
+ if (monitor[i].enabled == true)
+ return;
+
+ monitor[i].enabled = true;
+ found = true;
+ }
+ }
+
+ if (found == false)
+ return;
+
+ if (add_filter == true)
+ dbus_connection_add_filter(connection, monitor_changed,
+ NULL, NULL);
+
+ dbus_error_init(&err);
+ rule = g_strdup_printf("type='signal',interface='net.connman.%s'",
+ interface);
+ dbus_bus_add_match(connection, rule, &err);
+ g_free(rule);
+
+ if (dbus_error_is_set(&err))
+ fprintf(stderr, "Error: %s\n", err.message);
+}
+
+static void monitor_del(char *interface)
+{
+ bool del_filter = true, found = false;
+ int i;
+ char *rule;
+
+
+ for (i = 0; monitor[i].interface; i++) {
+ if (g_strcmp0(interface, monitor[i].interface) == 0) {
+ if (monitor[i].enabled == false)
+ return;
+
+ monitor[i].enabled = false;
+ found = true;
+ }
+
+ if (monitor[i].enabled == true)
+ del_filter = false;
+ }
+
+ if (found == false)
+ return;
+
+ rule = g_strdup_printf("type='signal',interface='net.connman.%s'",
+ interface);
+ dbus_bus_remove_match(connection, rule, NULL);
+ g_free(rule);
+
+ if (del_filter == true)
+ dbus_connection_remove_filter(connection, monitor_changed,
+ NULL);
+}
+
+static int cmd_monitor(char *args[], int num, struct connman_option *options)
+{
+ bool add = true;
+ int c;
+
+ if (num > 3)
+ return -E2BIG;
+
+ if (num == 3) {
+ switch (parse_boolean(args[2])) {
+ case 0:
+ add = false;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ c = parse_args(args[1], options);
+ switch (c) {
+ case -1:
+ monitor_add("Service");
+ monitor_add("Technology");
+ monitor_add("Manager");
+ monitor_add("vpn.Manager");
+ monitor_add("vpn.Connection");
+ break;
+
+ case 's':
+ if (add == true)
+ monitor_add("Service");
+ else
+ monitor_del("Service");
+ break;
+
+ case 'c':
+ if (add == true)
+ monitor_add("Technology");
+ else
+ monitor_del("Technology");
+ break;
+
+ case 'm':
+ if (add == true)
+ monitor_add("Manager");
+ else
+ monitor_del("Manager");
+ break;
+
+ case 'M':
+ if (add == true)
+ monitor_add("vpn.Manager");
+ else
+ monitor_del("vpn.Manager");
+ break;
+
+ case 'C':
+ if (add == true)
+ monitor_add("vpn.Connection");
+ else
+ monitor_del("vpn.Connection");
+ break;
+
+ default:
+ switch(parse_boolean(args[1])) {
+ case 0:
+ monitor_del("Service");
+ monitor_del("Technology");
+ monitor_del("Manager");
+ monitor_del("vpn.Manager");
+ monitor_del("vpn.Connection");
+ break;
+
+ case 1:
+ monitor_add("Service");
+ monitor_add("Technology");
+ monitor_add("Manager");
+ monitor_add("vpn.Manager");
+ monitor_add("vpn.Connection");
+ break;
+
+ default:
+ return -EINVAL;
+ }
+ }
+
+ if (add == true)
+ return -EINPROGRESS;
+
+ return 0;
+}
+
+static int cmd_agent(char *args[], int num, struct connman_option *options)
+{
+ if (!__connmanctl_is_interactive()) {
+ fprintf(stderr, "Error: Not supported in non-interactive "
+ "mode\n");
+ return 0;
+ }
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ switch(parse_boolean(args[1])) {
+ case 0:
+ __connmanctl_agent_unregister(connection);
+ break;
+
+ case 1:
+ if (__connmanctl_agent_register(connection) == -EINPROGRESS)
+ return -EINPROGRESS;
+
+ break;
+
+ default:
+ return -EINVAL;
+ break;
+ }
+
+ return 0;
+}
+
+static int vpnconnections_properties(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *path = user_data;
+ char *str;
+ DBusMessageIter dict;
+
+ if (!error) {
+ fprintf(stdout, "%s\n", path);
+
+ dbus_message_iter_recurse(iter, &dict);
+ __connmanctl_dbus_print(&dict, " ", " = ", "\n");
+
+ fprintf(stdout, "\n");
+
+ } else {
+ str = strrchr(path, '/');
+ if (str)
+ str++;
+ else
+ str = path;
+
+ fprintf(stderr, "Error %s: %s\n", str, error);
+ }
+
+ g_free(user_data);
+
+ return 0;
+}
+
+static int vpnconnections_list(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (!error)
+ __connmanctl_vpnconnections_list(iter);
+ else
+ fprintf(stderr, "Error: %s\n", error);
+
+ return 0;
+}
+
+static int cmd_vpnconnections(char *args[], int num,
+ struct connman_option *options)
+{
+ char *vpnconnection_name, *path;
+
+ if (num > 2)
+ return -E2BIG;
+
+ vpnconnection_name = args[1];
+
+ if (!vpnconnection_name)
+ return __connmanctl_dbus_method_call(connection,
+ VPN_SERVICE, VPN_PATH,
+ "net.connman.vpn.Manager", "GetConnections",
+ vpnconnections_list, NULL,
+ NULL, NULL);
+
+ if (check_dbus_name(vpnconnection_name) == false)
+ return -EINVAL;
+
+ path = g_strdup_printf("/net/connman/vpn/connection/%s",
+ vpnconnection_name);
+ return __connmanctl_dbus_method_call(connection, VPN_SERVICE, path,
+ "net.connman.vpn.Connection", "GetProperties",
+ vpnconnections_properties, path, NULL, NULL);
+
+}
+
+static int cmd_vpnagent(char *args[], int num, struct connman_option *options)
+{
+ if (!__connmanctl_is_interactive()) {
+ fprintf(stderr, "Error: Not supported in non-interactive "
+ "mode\n");
+ return 0;
+ }
+
+ if (num > 2)
+ return -E2BIG;
+
+ if (num < 2)
+ return -EINVAL;
+
+ switch(parse_boolean(args[1])) {
+ case 0:
+ __connmanctl_vpn_agent_unregister(connection);
+ break;
+
+ case 1:
+ if (__connmanctl_vpn_agent_register(connection) ==
+ -EINPROGRESS)
+ return -EINPROGRESS;
+
+ break;
+
+ default:
+ return -EINVAL;
+ break;
+ }
+
+ return 0;
+}
+
+static DBusMessage *session_release(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ __connmanctl_save_rl();
+
+ fprintf(stdout, "Session %s released\n", session_path);
+
+ __connmanctl_redraw_rl();
+
+ g_free(session_path);
+ session_path = NULL;
+ session_connected = false;
+
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *session_update(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter, dict;
+
+ __connmanctl_save_rl();
+
+ fprintf(stdout, "Session Update = {\n");
+
+ dbus_message_iter_init(message, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+
+ __connmanctl_dbus_print(&dict, "", " = ", "\n");
+ fprintf(stdout, "\n}\n");
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, variant;
+ char *field, *state;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ dbus_message_iter_get_basic(&entry, &field);
+
+ if (dbus_message_iter_get_arg_type(&entry)
+ == DBUS_TYPE_STRING
+ && !strcmp(field, "State")) {
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &variant);
+ if (dbus_message_iter_get_arg_type(&variant)
+ != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&variant, &state);
+
+ if (!session_connected && (!strcmp(state, "connected")
+ || !strcmp(state, "online"))) {
+
+ fprintf(stdout, "Session %s connected\n",
+ session_path);
+ session_connected = true;
+
+ break;
+ }
+
+ if (!strcmp(state, "disconnected") &&
+ session_connected) {
+
+ fprintf(stdout, "Session %s disconnected\n",
+ session_path);
+ session_connected = false;
+ }
+ break;
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ __connmanctl_redraw_rl();
+
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable notification_methods[] = {
+ { GDBUS_METHOD("Release", NULL, NULL, session_release) },
+ { GDBUS_METHOD("Update", GDBUS_ARGS({"settings", "a{sv}"}),
+ NULL, session_update) },
+ { },
+};
+
+static int session_notify_add(const char *path)
+{
+ if (session_notify_path)
+ return 0;
+
+ if (!g_dbus_register_interface(connection, path,
+ "net.connman.Notification",
+ notification_methods, NULL, NULL,
+ NULL, NULL)) {
+ fprintf(stderr, "Error: Failed to register VPN Agent "
+ "callbacks\n");
+ return -EIO;
+ }
+
+ session_notify_path = g_strdup(path);
+
+ return 0;
+}
+
+static void session_notify_remove(void)
+{
+ if (!session_notify_path)
+ return;
+
+ g_dbus_unregister_interface(connection, session_notify_path,
+ "net.connman.Notification");
+
+ g_free(session_notify_path);
+ session_notify_path = NULL;
+}
+
+static int session_connect_cb(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error: %s", error);
+ return 0;
+ }
+
+ return -EINPROGRESS;
+}
+
+
+static int session_connect(void)
+{
+ return __connmanctl_dbus_method_call(connection, "net.connman",
+ session_path, "net.connman.Session", "Connect",
+ session_connect_cb, NULL, NULL, NULL);
+}
+
+static int session_disconnect_cb(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (error)
+ fprintf(stderr, "Error: %s", error);
+
+ return 0;
+}
+
+static int session_disconnect(void)
+{
+ return __connmanctl_dbus_method_call(connection, "net.connman",
+ session_path, "net.connman.Session", "Disconnect",
+ session_disconnect_cb, NULL, NULL, NULL);
+}
+
+static int session_create_cb(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ gboolean connect = GPOINTER_TO_INT(user_data);
+ char *str;
+
+ if (error) {
+ fprintf(stderr, "Error creating session: %s", error);
+ session_notify_remove();
+ return 0;
+ }
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH) {
+ fprintf(stderr, "Error creating session: No session path\n");
+ return -EINVAL;
+ }
+
+ g_free(session_path);
+
+ dbus_message_iter_get_basic(iter, &str);
+ session_path = g_strdup(str);
+
+ fprintf(stdout, "Session %s created\n", session_path);
+
+ if (connect)
+ return session_connect();
+
+ return -EINPROGRESS;
+}
+
+static void session_create_append(DBusMessageIter *iter, void *user_data)
+{
+ const char *notify_path = user_data;
+
+ __connmanctl_dbus_append_dict(iter, NULL, NULL);
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+ ¬ify_path);
+}
+
+static int session_create(gboolean connect)
+{
+ int res;
+ char *notify_path;
+
+ notify_path = g_strdup_printf("/net/connman/connmanctl%d", getpid());
+ session_notify_add(notify_path);
+
+ res = __connmanctl_dbus_method_call(connection, "net.connman", "/",
+ "net.connman.Manager", "CreateSession",
+ session_create_cb, GINT_TO_POINTER(connect),
+ session_create_append, notify_path);
+
+ g_free(notify_path);
+
+ if (res < 0 && res != -EINPROGRESS)
+ session_notify_remove();
+
+ return res;
+}
+
+static int session_destroy_cb(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error destroying session: %s", error);
+ return 0;
+ }
+
+ fprintf(stdout, "Session %s ended\n", session_path);
+
+ g_free(session_path);
+ session_path = NULL;
+ session_connected = false;
+
+ return 0;
+}
+
+static void session_destroy_append(DBusMessageIter *iter, void *user_data)
+{
+ const char *path = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
+}
+
+static int session_destroy(void)
+{
+ return __connmanctl_dbus_method_call(connection, "net.connman", "/",
+ "net.connman.Manager", "DestroySession",
+ session_destroy_cb, NULL,
+ session_destroy_append, session_path);
+}
+
+static int session_config_return(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ char *property_name = user_data;
+
+ if (error)
+ fprintf(stderr, "Error setting session %s: %s\n",
+ property_name, error);
+
+ return 0;
+}
+
+static void session_config_append_array(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct config_append *append = user_data;
+ char **opts = append->opts;
+ int i = 1;
+
+ if (!opts)
+ return;
+
+ while (opts[i] && strncmp(opts[i], "--", 2) != 0) {
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &opts[i]);
+ i++;
+ }
+
+ append->values = i;
+}
+
+static int session_config(char *args[], int num,
+ struct connman_option *options)
+{
+ int index = 0, res = 0;
+ struct config_append append;
+ char c;
+
+ while (index < num && args[index]) {
+ append.opts = &args[index];
+ append.values = 0;
+
+ c = parse_args(args[index], options);
+
+ switch (c) {
+ case 'b':
+ res = __connmanctl_dbus_session_change_array(connection,
+ session_path, session_config_return,
+ "AllowedBearers", "AllowedBearers",
+ session_config_append_array, &append);
+ break;
+ case 't':
+ if (!args[index + 1]) {
+ res = -EINVAL;
+ break;
+ }
+
+ res = __connmanctl_dbus_session_change(connection,
+ session_path, session_config_return,
+ "ConnectionType", "ConnectionType",
+ DBUS_TYPE_STRING, &args[index + 1]);
+ append.values = 2;
+ break;
+
+ default:
+ res = -EINVAL;
+ }
+
+ if (res < 0 && res != -EINPROGRESS) {
+ printf("Error '%s': %s\n", args[index],
+ strerror(-res));
+ return 0;
+ }
+
+ index += append.values;
+ }
+
+ return 0;
+}
+
+static int cmd_session(char *args[], int num, struct connman_option *options)
+{
+ char *command;
+
+ if (num < 2)
+ return -EINVAL;
+
+ command = args[1];
+
+ switch(parse_boolean(command)) {
+ case 0:
+ if (!session_path)
+ return -EALREADY;
+ return session_destroy();
+
+ case 1:
+ if (session_path)
+ return -EALREADY;
+ return session_create(FALSE);
+
+ default:
+ if (!strcmp(command, "connect")) {
+ if (!session_path)
+ return session_create(TRUE);
+
+ return session_connect();
+
+ } else if (!strcmp(command, "disconnect")) {
+
+ if (!session_path) {
+ fprintf(stdout, "Session does not exist\n");
+ return 0;
+ }
+
+ return session_disconnect();
+ } else if (!strcmp(command, "config")) {
+ if (!session_path) {
+ fprintf(stdout, "Session does not exist\n");
+ return 0;
+ }
+
+ if (num == 2)
+ return -EINVAL;
+
+ return session_config(&args[2], num - 2, options);
+ }
+
+ }
+
+ return -EINVAL;
+}
+
+static int cmd_exit(char *args[], int num, struct connman_option *options)
+{
+ return 1;
+}
+
+static char *lookup_service(const char *text, int state)
+{
+ static int len = 0;
+ static GHashTableIter iter;
+ gpointer key, value;
+
+ if (state == 0) {
+ g_hash_table_iter_init(&iter, service_hash);
+ len = strlen(text);
+ }
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ const char *service = key;
+ if (strncmp(text, service, len) == 0)
+ return strdup(service);
+ }
+
+ return NULL;
+}
+
+static char *lookup_service_arg(const char *text, int state)
+{
+ if (__connmanctl_input_calc_level() > 1) {
+ __connmanctl_input_lookup_end();
+ return NULL;
+ }
+
+ return lookup_service(text, state);
+}
+
+static char *lookup_peer(const char *text, int state)
+{
+ static GHashTableIter iter;
+ gpointer key, value;
+ static int len = 0;
+
+ if (state == 0) {
+ g_hash_table_iter_init(&iter, peer_hash);
+ len = strlen(text);
+ }
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ const char *peer = key;
+ if (strncmp(text, peer, len) == 0)
+ return strdup(peer);
+ }
+
+ return NULL;
+}
+
+static char *lookup_peer_arg(const char *text, int state)
+{
+ if (__connmanctl_input_calc_level() > 1) {
+ __connmanctl_input_lookup_end();
+ return NULL;
+ }
+
+ return lookup_peer(text, state);
+}
+
+static char *lookup_technology(const char *text, int state)
+{
+ static int len = 0;
+ static GHashTableIter iter;
+ gpointer key, value;
+
+ if (state == 0) {
+ g_hash_table_iter_init(&iter, technology_hash);
+ len = strlen(text);
+ }
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ const char *technology = key;
+ if (strncmp(text, technology, len) == 0)
+ return strdup(technology);
+ }
+
+ return NULL;
+}
+
+static char *lookup_technology_arg(const char *text, int state)
+{
+ if (__connmanctl_input_calc_level() > 1) {
+ __connmanctl_input_lookup_end();
+ return NULL;
+ }
+
+ return lookup_technology(text, state);
+}
+
+static char *lookup_technology_offline(const char *text, int state)
+{
+ static int len = 0;
+ static bool end = false;
+ char *str;
+
+ if (__connmanctl_input_calc_level() > 1) {
+ __connmanctl_input_lookup_end();
+ return NULL;
+ }
+
+ if (state == 0) {
+ len = strlen(text);
+ end = false;
+ }
+
+ if (end)
+ return NULL;
+
+ str = lookup_technology(text, state);
+ if (str)
+ return str;
+
+ end = true;
+
+ if (strncmp(text, "offline", len) == 0)
+ return strdup("offline");
+
+ return NULL;
+}
+
+static char *lookup_on_off(const char *text, int state)
+{
+ char *onoff[] = { "on", "off", NULL };
+ static int idx = 0;
+ static int len = 0;
+
+ char *str;
+
+ if (!state) {
+ idx = 0;
+ len = strlen(text);
+ }
+
+ while (onoff[idx]) {
+ str = onoff[idx];
+ idx++;
+
+ if (!strncmp(text, str, len))
+ return strdup(str);
+ }
+
+ return NULL;
+}
+
+static char *lookup_tether(const char *text, int state)
+{
+ int level;
+
+ level = __connmanctl_input_calc_level();
+ if (level < 2)
+ return lookup_technology(text, state);
+
+ if (level == 2)
+ return lookup_on_off(text, state);
+
+ __connmanctl_input_lookup_end();
+
+ return NULL;
+}
+
+static char *lookup_agent(const char *text, int state)
+{
+ if (__connmanctl_input_calc_level() > 1) {
+ __connmanctl_input_lookup_end();
+ return NULL;
+ }
+
+ return lookup_on_off(text, state);
+}
+
+static struct connman_option service_options[] = {
+ {"properties", 'p', "[<service>] (obsolete)"},
+ { NULL, }
+};
+
+static struct connman_option config_options[] = {
+ {"nameservers", 'n', "<dns1> [<dns2>] [<dns3>]"},
+ {"timeservers", 't', "<ntp1> [<ntp2>] [...]"},
+ {"domains", 'd', "<domain1> [<domain2>] [...]"},
+ {"ipv6", 'v', "off|auto [enable|disable|preferred]|\n"
+ "\t\t\tmanual <address> <prefixlength> <gateway>"},
+ {"proxy", 'x', "direct|auto <URL>|manual <URL1> [<URL2>] [...]\n"
+ "\t\t\t[exclude <exclude1> [<exclude2>] [...]]"},
+ {"autoconnect", 'a', "yes|no"},
+ {"ipv4", 'i', "off|dhcp|manual <address> <netmask> <gateway>"},
+ {"remove", 'r', " Remove service"},
+ {"order", 'o', " <order> set service order manually"},
+ { NULL, }
+};
+
+static struct connman_option monitor_options[] = {
+ {"services", 's', "[off] Monitor only services"},
+ {"tech", 'c', "[off] Monitor only technologies"},
+ {"manager", 'm', "[off] Monitor only manager interface"},
+ {"vpnmanager", 'M', "[off] Monitor only VPN manager "
+ "interface"},
+ {"vpnconnection", 'C', "[off] Monitor only VPN "
+ "connections" },
+ { NULL, }
+};
+
+static struct connman_option session_options[] = {
+ {"bearers", 'b', "<technology1> [<technology2> [...]]"},
+ {"type", 't', "local|internet|any"},
+ { NULL, }
+};
+
+static char *lookup_options(struct connman_option *options, const char *text,
+ int state)
+{
+ static int idx = 0;
+ static int len = 0;
+ const char *str;
+
+ if (state == 0) {
+ idx = 0;
+ len = strlen(text);
+ }
+
+ while (options[idx].name) {
+ str = options[idx].name;
+ idx++;
+
+ if (str && strncmp(text, str, len) == 0)
+ return strdup(str);
+ }
+
+ return NULL;
+}
+
+static char *lookup_monitor(const char *text, int state)
+{
+ int level;
+
+ level = __connmanctl_input_calc_level();
+
+ if (level < 2)
+ return lookup_options(monitor_options, text, state);
+
+ if (level == 2)
+ return lookup_on_off(text, state);
+
+ __connmanctl_input_lookup_end();
+ return NULL;
+}
+
+static char *lookup_config(const char *text, int state)
+{
+ if (__connmanctl_input_calc_level() < 2)
+ return lookup_service(text, state);
+
+ return lookup_options(config_options, text, state);
+}
+
+static char *lookup_session(const char *text, int state)
+{
+ return lookup_options(session_options, text, state);
+}
+
+static int peer_service_cb(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ bool registration = GPOINTER_TO_INT(user_data);
+
+ if (error)
+ fprintf(stderr, "Error %s peer service: %s\n",
+ registration ? "registering" : "unregistering", error);
+ else
+ fprintf(stdout, "Peer service %s\n",
+ registration ? "registered" : "unregistered");
+
+ return 0;
+}
+
+struct _peer_service {
+ unsigned char *bjr_query;
+ int bjr_query_len;
+ unsigned char *bjr_response;
+ int bjr_response_len;
+ unsigned char *wfd_ies;
+ int wfd_ies_len;
+ char *upnp_service;
+ int version;
+ int master;
+};
+
+static void append_dict_entry_fixed_array(DBusMessageIter *iter,
+ const char *property, void *value, int length)
+{
+ DBusMessageIter dict_entry, variant, array;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY,
+ NULL, &dict_entry);
+ dbus_message_iter_append_basic(&dict_entry, DBUS_TYPE_STRING,
+ &property);
+ dbus_message_iter_open_container(&dict_entry, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING,
+ &variant);
+ dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_BYTE_AS_STRING, &array);
+ dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
+ value, length);
+ dbus_message_iter_close_container(&variant, &array);
+ dbus_message_iter_close_container(&dict_entry, &variant);
+ dbus_message_iter_close_container(iter, &dict_entry);
+}
+
+static void append_peer_service_dict(DBusMessageIter *iter, void *user_data)
+{
+ struct _peer_service *service = user_data;
+
+ if (service->bjr_query && service->bjr_response) {
+ append_dict_entry_fixed_array(iter, "BonjourQuery",
+ &service->bjr_query, service->bjr_query_len);
+ append_dict_entry_fixed_array(iter, "BonjourResponse",
+ &service->bjr_response, service->bjr_response_len);
+ } else if (service->upnp_service && service->version) {
+ __connmanctl_dbus_append_dict_entry(iter, "UpnpVersion",
+ DBUS_TYPE_INT32, &service->version);
+ __connmanctl_dbus_append_dict_entry(iter, "UpnpService",
+ DBUS_TYPE_STRING, &service->upnp_service);
+ } else if (service->wfd_ies) {
+ append_dict_entry_fixed_array(iter, "WiFiDisplayIEs",
+ &service->wfd_ies, service->wfd_ies_len);
+ }
+}
+
+static void peer_service_append(DBusMessageIter *iter, void *user_data)
+{
+ struct _peer_service *service = user_data;
+ dbus_bool_t master;
+
+ __connmanctl_dbus_append_dict(iter, append_peer_service_dict, service);
+
+ if (service->master < 0)
+ return;
+
+ master = service->master == 1 ? TRUE : FALSE;
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &master);
+}
+
+static struct _peer_service *fill_in_peer_service(unsigned char *bjr_query,
+ int bjr_query_len, unsigned char *bjr_response,
+ int bjr_response_len, char *upnp_service,
+ int version, unsigned char *wfd_ies,
+ int wfd_ies_len)
+{
+ struct _peer_service *service;
+
+ service = dbus_malloc0(sizeof(*service));
+
+ if (bjr_query_len && bjr_response_len) {
+ service->bjr_query = dbus_malloc0(bjr_query_len);
+ memcpy(service->bjr_query, bjr_query, bjr_query_len);
+ service->bjr_query_len = bjr_query_len;
+
+ service->bjr_response = dbus_malloc0(bjr_response_len);
+ memcpy(service->bjr_response, bjr_response, bjr_response_len);
+ service->bjr_response_len = bjr_response_len;
+ } else if (upnp_service && version) {
+ service->upnp_service = strdup(upnp_service);
+ service->version = version;
+ } else if (wfd_ies && wfd_ies_len) {
+ service->wfd_ies = dbus_malloc0(wfd_ies_len);
+ memcpy(service->wfd_ies, wfd_ies, wfd_ies_len);
+ service->wfd_ies_len = wfd_ies_len;
+ } else {
+ dbus_free(service);
+ service = NULL;
+ }
+
+ return service;
+}
+
+static void free_peer_service(struct _peer_service *service)
+{
+ dbus_free(service->bjr_query);
+ dbus_free(service->bjr_response);
+ dbus_free(service->wfd_ies);
+ free(service->upnp_service);
+ dbus_free(service);
+}
+
+static int peer_service_register(unsigned char *bjr_query, int bjr_query_len,
+ unsigned char *bjr_response, int bjr_response_len,
+ char *upnp_service, int version,
+ unsigned char *wfd_ies, int wfd_ies_len, int master)
+{
+ struct _peer_service *service;
+ bool registration = true;
+ int ret;
+
+ service = fill_in_peer_service(bjr_query, bjr_query_len, bjr_response,
+ bjr_response_len, upnp_service, version,
+ wfd_ies, wfd_ies_len);
+ if (!service)
+ return -EINVAL;
+
+ service->master = master;
+
+ ret = __connmanctl_dbus_method_call(connection, "net.connman", "/",
+ "net.connman.Manager", "RegisterPeerService",
+ peer_service_cb, GINT_TO_POINTER(registration),
+ peer_service_append, service);
+
+ free_peer_service(service);
+
+ return ret;
+}
+
+static int peer_service_unregister(unsigned char *bjr_query, int bjr_query_len,
+ unsigned char *bjr_response, int bjr_response_len,
+ char *upnp_service, int version,
+ unsigned char *wfd_ies, int wfd_ies_len)
+{
+ struct _peer_service *service;
+ bool registration = false;
+ int ret;
+
+ service = fill_in_peer_service(bjr_query, bjr_query_len, bjr_response,
+ bjr_response_len, upnp_service, version,
+ wfd_ies, wfd_ies_len);
+ if (!service)
+ return -EINVAL;
+
+ service->master = -1;
+
+ ret = __connmanctl_dbus_method_call(connection, "net.connman", "/",
+ "net.connman.Manager", "UnregisterPeerService",
+ peer_service_cb, GINT_TO_POINTER(registration),
+ peer_service_append, service);
+
+ free_peer_service(service);
+
+ return ret;
+}
+
+static int parse_spec_array(char *command, unsigned char spec[1024])
+{
+ int length, pos, end;
+ char b[3] = {};
+ char *e;
+
+ end = strlen(command);
+ for (e = NULL, length = pos = 0; command[pos] != '\0'; length++) {
+ if (pos+2 > end)
+ return -EINVAL;
+
+ b[0] = command[pos];
+ b[1] = command[pos+1];
+
+ spec[length] = strtol(b, &e, 16);
+ if (e && *e != '\0')
+ return -EINVAL;
+
+ pos += 2;
+ }
+
+ return length;
+}
+
+static int cmd_peer_service(char *args[], int num,
+ struct connman_option *options)
+{
+ unsigned char bjr_query[1024] = {};
+ unsigned char bjr_response[1024] = {};
+ unsigned char wfd_ies[1024] = {};
+ char *upnp_service = NULL;
+ int bjr_query_len = 0, bjr_response_len = 0;
+ int version = 0, master = 0, wfd_ies_len = 0;
+ int limit;
+
+ if (num < 4)
+ return -EINVAL;
+
+ if (!strcmp(args[2], "wfd_ies")) {
+ wfd_ies_len = parse_spec_array(args[3], wfd_ies);
+ if (wfd_ies_len == -EINVAL)
+ return -EINVAL;
+ limit = 5;
+ goto master;
+ }
+
+ if (num < 6)
+ return -EINVAL;
+
+ limit = 7;
+ if (!strcmp(args[2], "bjr_query")) {
+ if (strcmp(args[4], "bjr_response"))
+ return -EINVAL;
+ bjr_query_len = parse_spec_array(args[3], bjr_query);
+ bjr_response_len = parse_spec_array(args[5], bjr_response);
+
+ if (bjr_query_len == -EINVAL || bjr_response_len == -EINVAL)
+ return -EINVAL;
+ } else if (!strcmp(args[2], "upnp_service")) {
+ char *e = NULL;
+
+ if (strcmp(args[4], "upnp_version"))
+ return -EINVAL;
+ upnp_service = args[3];
+ version = strtol(args[5], &e, 10);
+ if (*e != '\0')
+ return -EINVAL;
+ }
+
+master:
+ if (num == limit) {
+ master = parse_boolean(args[6]);
+ if (master < 0)
+ return -EINVAL;
+ }
+
+ if (!strcmp(args[1], "register")) {
+ return peer_service_register(bjr_query, bjr_query_len,
+ bjr_response, bjr_response_len, upnp_service,
+ version, wfd_ies, wfd_ies_len, master);
+ } else if (!strcmp(args[1], "unregister")) {
+ return peer_service_unregister(bjr_query, bjr_query_len,
+ bjr_response, bjr_response_len, upnp_service,
+ version, wfd_ies, wfd_ies_len);
+ }
+
+ return -EINVAL;
+}
+
+static const struct {
+ const char *cmd;
+ const char *argument;
+ struct connman_option *options;
+ int (*func) (char *args[], int num, struct connman_option *options);
+ const char *desc;
+ __connmanctl_lookup_cb cb;
+} cmd_table[] = {
+ { "state", NULL, NULL, cmd_state,
+ "Shows if the system is online or offline", NULL },
+ { "technologies", NULL, NULL, cmd_technologies,
+ "Display technologies", NULL },
+ { "enable", "<technology>|offline", NULL, cmd_enable,
+ "Enables given technology or offline mode",
+ lookup_technology_offline },
+ { "disable", "<technology>|offline", NULL, cmd_disable,
+ "Disables given technology or offline mode",
+ lookup_technology_offline },
+ { "tether", "<technology> on|off\n"
+ " wifi [on|off] <ssid> <passphrase> ",
+ NULL, cmd_tether,
+ "Enable, disable tethering, set SSID and passphrase for wifi",
+ lookup_tether },
+ { "services", "[<service>]", service_options, cmd_services,
+ "Display services", lookup_service_arg },
+ { "peers", "[peer]", NULL, cmd_peers,
+ "Display peers", lookup_peer_arg },
+ { "scan", "<technology>", NULL, cmd_scan,
+ "Scans for new services for given technology",
+ lookup_technology_arg },
+ { "connect", "<service/peer>", NULL, cmd_connect,
+ "Connect a given service or peer", lookup_service_arg },
+ { "disconnect", "<service/peer>", NULL, cmd_disconnect,
+ "Disconnect a given service or peer", lookup_service_arg },
+ { "config", "<service>", config_options, cmd_config,
+ "Set service configuration options", lookup_config },
+ { "monitor", "[off]", monitor_options, cmd_monitor,
+ "Monitor signals from interfaces", lookup_monitor },
+ { "agent", "on|off", NULL, cmd_agent,
+ "Agent mode", lookup_agent },
+ {"vpnconnections", "[<connection>]", NULL, cmd_vpnconnections,
+ "Display VPN connections", NULL },
+ { "vpnagent", "on|off", NULL, cmd_vpnagent,
+ "VPN Agent mode", lookup_agent },
+ { "session", "on|off|connect|disconnect|config", session_options,
+ cmd_session, "Enable or disable a session", lookup_session },
+ { "peer_service", "register|unregister <specs> <master>\n"
+ "Where specs are:\n"
+ "\tbjr_query <query> bjr_response <response>\n"
+ "\tupnp_service <service> upnp_version <version>\n"
+ "\twfd_ies <ies>\n", NULL,
+ cmd_peer_service, "(Un)Register a Peer Service", NULL },
+ { "help", NULL, NULL, cmd_help,
+ "Show help", NULL },
+ { "exit", NULL, NULL, cmd_exit,
+ "Exit", NULL },
+ { "quit", NULL, NULL, cmd_exit,
+ "Quit", NULL },
+ { NULL, },
+};
+
+static int cmd_help(char *args[], int num, struct connman_option *options)
+{
+ bool interactive = __connmanctl_is_interactive();
+ int i, j;
+
+ if (interactive == false)
+ fprintf(stdout, "Usage: connmanctl [[command] [args]]\n");
+
+ for (i = 0; cmd_table[i].cmd; i++) {
+ const char *cmd = cmd_table[i].cmd;
+ const char *argument = cmd_table[i].argument;
+ const char *desc = cmd_table[i].desc;
+
+ printf("%-16s%-22s%s\n", cmd? cmd: "",
+ argument? argument: "",
+ desc? desc: "");
+
+ if (cmd_table[i].options) {
+ for (j = 0; cmd_table[i].options[j].name;
+ j++) {
+ const char *options_desc =
+ cmd_table[i].options[j].desc ?
+ cmd_table[i].options[j].desc: "";
+
+ printf(" --%-16s%s\n",
+ cmd_table[i].options[j].name,
+ options_desc);
+ }
+ }
+ }
+
+ if (interactive == false)
+ fprintf(stdout, "\nNote: arguments and output are considered "
+ "EXPERIMENTAL for now.\n");
+
+ return 0;
+}
+
+__connmanctl_lookup_cb __connmanctl_get_lookup_func(const char *text)
+{
+ int i, cmdlen, textlen;
+
+ if (!text)
+ return NULL;
+
+ textlen = strlen(text);
+
+ for (i = 0; cmd_table[i].cmd; i++) {
+ cmdlen = strlen(cmd_table[i].cmd);
+
+ if (textlen > cmdlen && text[cmdlen] != ' ')
+ continue;
+
+ if (strncmp(cmd_table[i].cmd, text, cmdlen) == 0)
+ return cmd_table[i].cb;
+ }
+
+ return NULL;
+}
+
+int __connmanctl_commands(DBusConnection *dbus_conn, char *argv[], int argc)
+{
+ int i, result;
+
+ connection = dbus_conn;
+
+ for (i = 0; cmd_table[i].cmd; i++) {
+ if (g_strcmp0(cmd_table[i].cmd, argv[0]) == 0 &&
+ cmd_table[i].func) {
+ result = cmd_table[i].func(argv, argc,
+ cmd_table[i].options);
+ if (result < 0 && result != -EINPROGRESS)
+ fprintf(stderr, "Error '%s': %s\n", argv[0],
+ strerror(-result));
+ return result;
+ }
+ }
+
+ fprintf(stderr, "Error '%s': Unknown command\n", argv[0]);
+ return -EINVAL;
+}
+
+char *__connmanctl_lookup_command(const char *text, int state)
+{
+ static int i = 0;
+ static int len = 0;
+
+ if (state == 0) {
+ i = 0;
+ len = strlen(text);
+ }
+
+ while (cmd_table[i].cmd) {
+ const char *command = cmd_table[i].cmd;
+
+ i++;
+
+ if (strncmp(text, command, len) == 0)
+ return strdup(command);
+ }
+
+ return NULL;
+}
+
+static char *get_path(char *full_path)
+{
+ char *path;
+
+ path = strrchr(full_path, '/');
+ if (path && *path != '\0')
+ path++;
+ else
+ path = full_path;
+
+ return path;
+}
+
+static void add_service_id(const char *path)
+{
+ g_hash_table_replace(service_hash, g_strdup(path),
+ GINT_TO_POINTER(TRUE));
+}
+
+static void remove_service_id(const char *path)
+{
+ g_hash_table_remove(service_hash, path);
+}
+
+static void services_added(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+ char *path = NULL;
+
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
+
+ dbus_message_iter_recurse(iter, &array);
+ if (dbus_message_iter_get_arg_type(&array) !=
+ DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(&array, &path);
+ add_service_id(get_path(path));
+
+ dbus_message_iter_next(iter);
+ }
+}
+
+static void update_services(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+ char *path;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ services_added(&array);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ while (dbus_message_iter_get_arg_type(&array) ==
+ DBUS_TYPE_OBJECT_PATH) {
+ dbus_message_iter_get_basic(&array, &path);
+ remove_service_id(get_path(path));
+
+ dbus_message_iter_next(&array);
+ }
+}
+
+static int populate_service_hash(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error getting services: %s", error);
+ return 0;
+ }
+
+ update_services(iter);
+ return 0;
+}
+
+static void add_peer_id(const char *path)
+{
+ g_hash_table_replace(peer_hash, g_strdup(path), GINT_TO_POINTER(TRUE));
+}
+
+static void remove_peer_id(const char *path)
+{
+ g_hash_table_remove(peer_hash, path);
+}
+
+static void peers_added(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+ char *path = NULL;
+
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
+
+ dbus_message_iter_recurse(iter, &array);
+ if (dbus_message_iter_get_arg_type(&array) !=
+ DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(&array, &path);
+ add_peer_id(get_path(path));
+
+ dbus_message_iter_next(iter);
+ }
+}
+
+static void update_peers(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+ char *path;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ peers_added(&array);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ while (dbus_message_iter_get_arg_type(&array) ==
+ DBUS_TYPE_OBJECT_PATH) {
+ dbus_message_iter_get_basic(&array, &path);
+ remove_peer_id(get_path(path));
+
+ dbus_message_iter_next(&array);
+ }
+}
+
+static int populate_peer_hash(DBusMessageIter *iter,
+ const char *error, void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error getting peers: %s", error);
+ return 0;
+ }
+
+ update_peers(iter);
+ return 0;
+}
+
+static void add_technology_id(const char *path)
+{
+ g_hash_table_replace(technology_hash, g_strdup(path),
+ GINT_TO_POINTER(TRUE));
+}
+
+static void remove_technology_id(const char *path)
+{
+ g_hash_table_remove(technology_hash, path);
+}
+
+static void remove_technology(DBusMessageIter *iter)
+{
+ char *path = NULL;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(iter, &path);
+ remove_technology_id(get_path(path));
+}
+
+static void add_technology(DBusMessageIter *iter)
+{
+ char *path = NULL;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(iter, &path);
+ add_technology_id(get_path(path));
+}
+
+static void update_technologies(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter object_path;
+
+ dbus_message_iter_recurse(&array, &object_path);
+
+ add_technology(&object_path);
+
+ dbus_message_iter_next(&array);
+ }
+}
+
+static int populate_technology_hash(DBusMessageIter *iter, const char *error,
+ void *user_data)
+{
+ if (error) {
+ fprintf(stderr, "Error getting technologies: %s", error);
+ return 0;
+ }
+
+ update_technologies(iter);
+
+ return 0;
+}
+
+static DBusHandlerResult monitor_completions_changed(
+ DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ bool *enabled = user_data;
+ DBusMessageIter iter;
+ DBusHandlerResult handled;
+
+ if (*enabled)
+ handled = DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ else
+ handled = DBUS_HANDLER_RESULT_HANDLED;
+
+ if (dbus_message_is_signal(message, "net.connman.Manager",
+ "ServicesChanged")) {
+ dbus_message_iter_init(message, &iter);
+ update_services(&iter);
+ return handled;
+ }
+
+ if (dbus_message_is_signal(message, "net.connman.Manager",
+ "PeersChanged")) {
+ dbus_message_iter_init(message, &iter);
+ update_peers(&iter);
+ return handled;
+ }
+
+ if (dbus_message_is_signal(message, "net.connman.Manager",
+ "TechnologyAdded")) {
+ dbus_message_iter_init(message, &iter);
+ add_technology(&iter);
+ return handled;
+ }
+
+ if (dbus_message_is_signal(message, "net.connman.Manager",
+ "TechnologyRemoved")) {
+ dbus_message_iter_init(message, &iter);
+ remove_technology(&iter);
+ return handled;
+ }
+
+ if (!g_strcmp0(dbus_message_get_interface(message),
+ "net.connman.Manager"))
+ return handled;
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+void __connmanctl_monitor_completions(DBusConnection *dbus_conn)
+{
+ bool *manager_enabled = NULL;
+ DBusError err;
+ int i;
+
+ for (i = 0; monitor[i].interface; i++) {
+ if (!strcmp(monitor[i].interface, "Manager")) {
+ manager_enabled = &monitor[i].enabled;
+ break;
+ }
+ }
+
+ if (!dbus_conn) {
+ g_hash_table_destroy(service_hash);
+ g_hash_table_destroy(technology_hash);
+
+ dbus_bus_remove_match(connection,
+ "type='signal',interface='net.connman.Manager'", NULL);
+ dbus_connection_remove_filter(connection,
+ monitor_completions_changed,
+ manager_enabled);
+ return;
+ }
+
+ connection = dbus_conn;
+
+ service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, NULL);
+
+ peer_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, NULL);
+
+ technology_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, NULL);
+
+ __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, CONNMAN_PATH,
+ "net.connman.Manager", "GetServices",
+ populate_service_hash, NULL, NULL, NULL);
+
+ __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, CONNMAN_PATH,
+ "net.connman.Manager", "GetPeers",
+ populate_peer_hash, NULL, NULL, NULL);
+
+ __connmanctl_dbus_method_call(connection,
+ CONNMAN_SERVICE, CONNMAN_PATH,
+ "net.connman.Manager", "GetTechnologies",
+ populate_technology_hash, NULL, NULL, NULL);
+
+ dbus_connection_add_filter(connection,
+ monitor_completions_changed, manager_enabled,
+ NULL);
+
+ dbus_error_init(&err);
+ dbus_bus_add_match(connection,
+ "type='signal',interface='net.connman.Manager'", &err);
+
+ if (dbus_error_is_set(&err))
+ fprintf(stderr, "Error: %s\n", err.message);
+}
diff --git a/client/commands.h b/client/commands.h
new file mode 100644
index 0000000..d5d1bec
--- /dev/null
+++ b/client/commands.h
@@ -0,0 +1,43 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_COMMANDS_H
+#define __CONNMANCTL_COMMANDS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef char *(*__connmanctl_lookup_cb)(const char *text, int state);
+
+int __connmanctl_commands(DBusConnection *connection, char *argv[], int argc);
+char *__connmanctl_lookup_command(const char *text, int state);
+void __connmanctl_monitor_completions(DBusConnection *dbus_conn);
+__connmanctl_lookup_cb __connmanctl_get_lookup_func(const char *text);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_COMMANDS_H */
diff --git a/client/dbus_helpers.c b/client/dbus_helpers.c
new file mode 100644
index 0000000..d905746
--- /dev/null
+++ b/client/dbus_helpers.c
@@ -0,0 +1,456 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <glib.h>
+
+#include "input.h"
+#include "dbus_helpers.h"
+
+#define TIMEOUT 120000
+
+void __connmanctl_dbus_print(DBusMessageIter *iter, const char *pre,
+ const char *dict, const char *sep)
+{
+ int arg_type;
+ dbus_bool_t b;
+ unsigned char c;
+ dbus_uint16_t u16;
+ dbus_uint32_t u;
+ dbus_int32_t i;
+ double d;
+
+ char *str;
+ DBusMessageIter entry;
+
+ if (!pre)
+ pre = "";
+
+ while ((arg_type = dbus_message_iter_get_arg_type(iter))
+ != DBUS_TYPE_INVALID) {
+
+ fprintf(stdout, "%s", pre);
+
+ switch (arg_type) {
+ case DBUS_TYPE_STRUCT:
+ fprintf(stdout, "{ ");
+ dbus_message_iter_recurse(iter, &entry);
+ __connmanctl_dbus_print(&entry, "", "=", " ");
+ fprintf(stdout, " }");
+ break;
+
+ case DBUS_TYPE_ARRAY:
+ fprintf(stdout, "[ ");
+
+ dbus_message_iter_recurse(iter, &entry);
+ __connmanctl_dbus_print(&entry, "", "=", ", ");
+
+ fprintf(stdout, " ]");
+ break;
+
+ case DBUS_TYPE_DICT_ENTRY:
+
+ dbus_message_iter_recurse(iter, &entry);
+ __connmanctl_dbus_print(&entry, "", dict, dict);
+ break;
+
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_OBJECT_PATH:
+ dbus_message_iter_get_basic(iter, &str);
+ fprintf(stdout, "%s", str);
+ break;
+
+ case DBUS_TYPE_VARIANT:
+ dbus_message_iter_recurse(iter, &entry);
+ __connmanctl_dbus_print(&entry, pre, dict, sep);
+ break;
+
+ case DBUS_TYPE_BOOLEAN:
+ dbus_message_iter_get_basic(iter, &b);
+ if (!b)
+ fprintf(stdout, "False");
+ else
+ fprintf(stdout, "True");
+ break;
+
+ case DBUS_TYPE_BYTE:
+ dbus_message_iter_get_basic(iter, &c);
+ fprintf(stdout, "%d", c);
+ break;
+
+ case DBUS_TYPE_UINT16:
+ dbus_message_iter_get_basic(iter, &u16);
+ fprintf(stdout, "%u", u16);
+ break;
+
+ case DBUS_TYPE_UINT32:
+ dbus_message_iter_get_basic(iter, &u);
+ fprintf(stdout, "%d", u);
+ break;
+
+ case DBUS_TYPE_INT32:
+ dbus_message_iter_get_basic(iter, &i);
+ fprintf(stdout, "%d", i);
+ break;
+
+ case DBUS_TYPE_DOUBLE:
+ dbus_message_iter_get_basic(iter, &d);
+ fprintf(stdout, "%f", d);
+ break;
+
+ default:
+ fprintf(stdout, "<type %c>", arg_type);
+ break;
+ }
+
+ if (dbus_message_iter_has_next(iter))
+ fprintf(stdout, "%s", sep);
+
+ dbus_message_iter_next(iter);
+ }
+}
+
+struct dbus_callback {
+ connmanctl_dbus_method_return_func_t cb;
+ void *user_data;
+};
+
+static void dbus_method_reply(DBusPendingCall *call, void *user_data)
+{
+ struct dbus_callback *callback = user_data;
+ int res = 0;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+
+ __connmanctl_save_rl();
+
+ reply = dbus_pending_call_steal_reply(call);
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ DBusError err;
+
+ dbus_error_init(&err);
+ dbus_set_error_from_message(&err, reply);
+
+ callback->cb(NULL, err.message, callback->user_data);
+
+ dbus_error_free(&err);
+ goto end;
+ }
+
+ dbus_message_iter_init(reply, &iter);
+ res = callback->cb(&iter, NULL, callback->user_data);
+
+end:
+ __connmanctl_redraw_rl();
+ if (__connmanctl_is_interactive() == false && res != -EINPROGRESS)
+ __connmanctl_quit();
+
+ g_free(callback);
+ dbus_message_unref(reply);
+}
+
+static int send_method_call(DBusConnection *connection,
+ DBusMessage *message, connmanctl_dbus_method_return_func_t cb,
+ void *user_data)
+{
+ int res = -ENXIO;
+ DBusPendingCall *call;
+ struct dbus_callback *callback;
+
+ if (!dbus_connection_send_with_reply(connection, message, &call, TIMEOUT))
+ goto end;
+
+ if (!call)
+ goto end;
+
+ if (cb) {
+ callback = g_new0(struct dbus_callback, 1);
+ callback->cb = cb;
+ callback->user_data = user_data;
+ dbus_pending_call_set_notify(call, dbus_method_reply,
+ callback, NULL);
+ res = -EINPROGRESS;
+ }
+
+end:
+ dbus_message_unref(message);
+ return res;
+}
+
+static int append_variant(DBusMessageIter *iter, const char *property,
+ int type, void *value)
+{
+ DBusMessageIter variant;
+ char *type_str;
+
+ switch(type) {
+ case DBUS_TYPE_BOOLEAN:
+ type_str = DBUS_TYPE_BOOLEAN_AS_STRING;
+ break;
+ case DBUS_TYPE_BYTE:
+ type_str = DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ case DBUS_TYPE_STRING:
+ type_str = DBUS_TYPE_STRING_AS_STRING;
+ break;
+ case DBUS_TYPE_INT32:
+ type_str = DBUS_TYPE_INT32_AS_STRING;
+ break;
+ default:
+ return -EOPNOTSUPP;
+ }
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &property);
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT, type_str,
+ &variant);
+ dbus_message_iter_append_basic(&variant, type, value);
+ dbus_message_iter_close_container(iter, &variant);
+
+ return 0;
+}
+
+int __connmanctl_dbus_method_call(DBusConnection *connection,
+ const char *service, const char *path, const char *interface,
+ const char *method, connmanctl_dbus_method_return_func_t cb,
+ void *user_data, connmanctl_dbus_append_func_t append_func,
+ void *append_data)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+
+ message = dbus_message_new_method_call(service, path, interface,
+ method);
+
+ if (!message)
+ return -ENOMEM;
+
+ if (append_func) {
+ dbus_message_iter_init_append(message, &iter);
+ append_func(&iter, append_data);
+ }
+
+ return send_method_call(connection, message, cb, user_data);
+}
+
+int __connmanctl_dbus_set_property(DBusConnection *connection,
+ const char *path, const char *interface,
+ connmanctl_dbus_method_return_func_t cb, void * user_data,
+ const char *property, int type, void *value)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+
+ message = dbus_message_new_method_call("net.connman", path,
+ interface, "SetProperty");
+
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ if (append_variant(&iter, property, type, value) < 0) {
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ return send_method_call(connection, message, cb, user_data);
+}
+
+void __connmanctl_dbus_append_dict(DBusMessageIter *iter,
+ connmanctl_dbus_append_func_t append_fn, void *append_data)
+{
+ DBusMessageIter dict;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ if (append_fn)
+ append_fn(&dict, append_data);
+
+ dbus_message_iter_close_container(iter, &dict);
+}
+
+void __connmanctl_dbus_append_dict_entry(DBusMessageIter *iter,
+ const char *property, int type, void *value)
+{
+ DBusMessageIter dict_entry;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL,
+ &dict_entry);
+
+ append_variant(&dict_entry, property, type, value);
+
+ dbus_message_iter_close_container(iter, &dict_entry);
+}
+
+int __connmanctl_dbus_set_property_dict(DBusConnection *connection,
+ const char *path, const char *interface,
+ connmanctl_dbus_method_return_func_t cb, void *user_data,
+ const char *property, int type,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data)
+{
+ DBusMessage *message;
+ DBusMessageIter iter, variant, dict;
+
+ message = dbus_message_new_method_call("net.connman", path,
+ interface, "SetProperty");
+
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &property);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &variant);
+
+ dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &dict);
+
+ append_fn(&dict, append_user_data);
+
+ dbus_message_iter_close_container(&variant, &dict);
+ dbus_message_iter_close_container(&iter, &variant);
+
+ return send_method_call(connection, message, cb, user_data);
+}
+
+static void append_variant_array(DBusMessageIter *iter, const char *property,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data)
+{
+ DBusMessageIter variant, array;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &property);
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING,
+ &variant);
+
+ dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &array);
+
+ append_fn(&array, append_user_data);
+
+ dbus_message_iter_close_container(&variant, &array);
+ dbus_message_iter_close_container(iter, &variant);
+}
+
+void __connmanctl_dbus_append_dict_string_array(DBusMessageIter *iter,
+ const char *property, connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data)
+{
+ DBusMessageIter dict_entry;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_DICT_ENTRY, NULL,
+ &dict_entry);
+
+ append_variant_array(&dict_entry, property, append_fn,
+ append_user_data);
+
+ dbus_message_iter_close_container(iter, &dict_entry);
+}
+
+int __connmanctl_dbus_set_property_array(DBusConnection *connection,
+ const char *path, const char *interface,
+ connmanctl_dbus_method_return_func_t cb, void *user_data,
+ const char *property, int type,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+
+ if (type != DBUS_TYPE_STRING)
+ return -EOPNOTSUPP;
+
+ message = dbus_message_new_method_call("net.connman", path,
+ interface, "SetProperty");
+
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ append_variant_array(&iter, property, append_fn, append_user_data);
+
+ return send_method_call(connection, message, cb, user_data);
+}
+
+int __connmanctl_dbus_session_change(DBusConnection *connection,
+ const char *session_path,
+ connmanctl_dbus_method_return_func_t cb, void * user_data,
+ const char *property, int type, void *value)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+
+ message = dbus_message_new_method_call("net.connman", session_path,
+ "net.connman.Session", "Change");
+
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ if (append_variant(&iter, property, type, value) < 0) {
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ return send_method_call(connection, message, cb, user_data);
+}
+
+int __connmanctl_dbus_session_change_array(DBusConnection *connection,
+ const char *session_path,
+ connmanctl_dbus_method_return_func_t cb, void *user_data,
+ const char *property,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+
+ message = dbus_message_new_method_call("net.connman", session_path,
+ "net.connman.Session", "Change");
+
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ append_variant_array(&iter, property, append_fn, append_user_data);
+
+ return send_method_call(connection, message, cb, user_data);
+}
diff --git a/client/dbus_helpers.h b/client/dbus_helpers.h
new file mode 100644
index 0000000..395808a
--- /dev/null
+++ b/client/dbus_helpers.h
@@ -0,0 +1,96 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_DBUS_HELPERS_H
+#define __CONNMANCTL_DBUS_HELPERS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONNMAN_SERVICE "net.connman"
+#define CONNMAN_PATH "/"
+#define VPN_SERVICE CONNMAN_SERVICE ".vpn"
+#define VPN_PATH "/"
+
+void __connmanctl_dbus_print(DBusMessageIter *iter, const char *pre,
+ const char *dict, const char *sep);
+
+typedef int (*connmanctl_dbus_method_return_func_t)(DBusMessageIter *iter,
+ const char *error, void *user_data);
+
+typedef void (*connmanctl_dbus_append_func_t)(DBusMessageIter *iter,
+ void *user_data);
+
+int __connmanctl_dbus_method_call(DBusConnection *connection,
+ const char *service, const char *path, const char *interface,
+ const char *method, connmanctl_dbus_method_return_func_t cb,
+ void * user_data, connmanctl_dbus_append_func_t append_fn,
+ void *append_data);
+
+int __connmanctl_dbus_set_property(DBusConnection *connection,
+ const char *path, const char *interface,
+ connmanctl_dbus_method_return_func_t cb, void * user_data,
+ const char *property, int type, void *value);
+
+void __connmanctl_dbus_append_dict(DBusMessageIter *iter,
+ connmanctl_dbus_append_func_t append_fn, void *append_data);
+
+void __connmanctl_dbus_append_dict_entry(DBusMessageIter *iter,
+ const char *property, int type, void *value);
+
+int __connmanctl_dbus_set_property_dict(DBusConnection *connection,
+ const char *path, const char *interface,
+ connmanctl_dbus_method_return_func_t cb, void * user_data,
+ const char *property, int type,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data);
+
+void __connmanctl_dbus_append_dict_string_array(DBusMessageIter *iter,
+ const char *property, connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data);
+int __connmanctl_dbus_set_property_array(DBusConnection *connection,
+ const char *path, const char *interface,
+ connmanctl_dbus_method_return_func_t cb, void *user_data,
+ const char *property, int type,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data);
+
+int __connmanctl_dbus_session_change(DBusConnection *connection,
+ const char *session_path,
+ connmanctl_dbus_method_return_func_t cb, void * user_data,
+ const char *property, int type, void *value);
+
+int __connmanctl_dbus_session_change_array(DBusConnection *connection,
+ const char *session_path,
+ connmanctl_dbus_method_return_func_t cb, void *user_data,
+ const char *property,
+ connmanctl_dbus_append_func_t append_fn,
+ void *append_user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/client/input.c b/client/input.c
new file mode 100644
index 0000000..f0c4ab2
--- /dev/null
+++ b/client/input.c
@@ -0,0 +1,295 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <glib.h>
+#include <readline/readline.h>
+#include <readline/history.h>
+
+#include <gdbus.h>
+#include "input.h"
+#include "commands.h"
+
+static DBusConnection *connection;
+static GMainLoop *main_loop;
+static bool interactive = false;
+
+static bool save_input;
+static char *saved_line;
+static int saved_point;
+
+void __connmanctl_quit(void)
+{
+ if (main_loop)
+ g_main_loop_quit(main_loop);
+}
+
+bool __connmanctl_is_interactive(void)
+{
+ return interactive;
+}
+
+void __connmanctl_save_rl(void)
+{
+#if 0
+ save_input = !RL_ISSTATE(RL_STATE_DONE);
+
+ if (save_input) {
+ saved_point = rl_point;
+ saved_line = rl_copy_text(0, rl_end);
+ rl_save_prompt();
+ rl_replace_line("", 0);
+ rl_redisplay();
+ }
+#endif
+}
+
+void __connmanctl_redraw_rl(void)
+{
+#if 0
+ if (save_input) {
+ rl_restore_prompt();
+ rl_replace_line(saved_line, 0);
+ rl_point = saved_point;
+ rl_redisplay();
+ free(saved_line);
+ }
+
+ save_input = 0;
+#endif
+}
+
+static void rl_handler(char *input)
+{
+ char **args, **trim_args;
+ int num, len, err, i;
+
+ if (!input) {
+ rl_newline(1, '\n');
+ g_main_loop_quit(main_loop);
+ return;
+ }
+
+ args = g_strsplit(input, " ", 0);
+ num = g_strv_length(args);
+
+ trim_args = g_new0(char *, num + 1);
+ for (i = 0, len = 0; i < num; i++) {
+ if (*args[i] != '\0') {
+ trim_args[len] = args[i];
+ len++;
+ }
+ }
+
+ if (len > 0) {
+
+ add_history(input);
+
+ err = __connmanctl_commands(connection, trim_args, len);
+
+ if (err > 0)
+ g_main_loop_quit(main_loop);
+ }
+
+ rl_callback_handler_install("connmanctl> ", rl_handler);
+
+ g_strfreev(args);
+ g_free(trim_args);
+}
+
+static gboolean input_handler(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
+ g_main_loop_quit(main_loop);
+ return FALSE;
+ }
+
+ rl_callback_read_char();
+ return TRUE;
+}
+
+static char **complete_agent(const char *text, int start, int end)
+{
+ rl_attempted_completion_over = 1;
+
+ return NULL;
+}
+
+/* Return how many parameters we have typed */
+int __connmanctl_input_calc_level(void)
+{
+ int count = 0;
+ char *ptr;
+
+ ptr = rl_line_buffer;
+
+ while (*ptr) {
+ if (*ptr == ' ') {
+ if (*(ptr + 1) == ' ') {
+ ptr++;
+ continue;
+ } else
+ count++;
+ }
+ ptr++;
+ }
+
+ return count;
+}
+
+void __connmanctl_input_lookup_end(void)
+{
+ rl_attempted_completion_over = 1;
+}
+
+static char **complete_command(const char *text, int start, int end)
+{
+ if (start == 0) {
+ return rl_completion_matches(text,
+ __connmanctl_lookup_command);
+
+ } else {
+ __connmanctl_lookup_cb cb;
+ char **str = NULL;
+
+ cb = __connmanctl_get_lookup_func(rl_line_buffer);
+ if (cb)
+ str = rl_completion_matches(text, cb);
+ else
+ rl_attempted_completion_over = 1;
+
+ return str;
+ }
+}
+
+static struct {
+ connmanctl_input_func_t cb;
+ void *user_data;
+} agent_handler;
+
+static void rl_agent_handler(char *input)
+{
+ agent_handler.cb(input, agent_handler.user_data);
+}
+
+void __connmanctl_agent_mode(const char *prompt,
+ connmanctl_input_func_t input_handler, void *user_data)
+{
+ agent_handler.cb = input_handler;
+ agent_handler.user_data = user_data;
+
+ if (input_handler)
+ rl_callback_handler_install(prompt, rl_agent_handler);
+ else {
+ rl_set_prompt(prompt);
+ rl_callback_handler_remove();
+ rl_redisplay();
+ }
+ rl_attempted_completion_function = complete_agent;
+}
+
+void __connmanctl_command_mode(void)
+{
+ rl_callback_handler_install("connmanctl> ", rl_handler);
+ rl_attempted_completion_function = complete_command;
+}
+
+int __connmanctl_input_init(int argc, char *argv[])
+{
+ char *help[] = {
+ "help",
+ NULL
+ };
+ guint source = 0;
+ int err;
+ DBusError dbus_err;
+ GIOChannel *channel;
+
+ dbus_error_init(&dbus_err);
+ connection = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &dbus_err);
+
+ if (dbus_error_is_set(&dbus_err)) {
+ fprintf(stderr, "Error: %s\n", dbus_err.message);
+ dbus_error_free(&dbus_err);
+ return 1;
+ }
+
+ if (argc < 2) {
+ interactive = true;
+
+ channel = g_io_channel_unix_new(fileno(stdin));
+ source = g_io_add_watch(channel,
+ G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL,
+ input_handler, NULL);
+ g_io_channel_unref(channel);
+
+ __connmanctl_monitor_completions(connection);
+
+ __connmanctl_command_mode();
+
+ err = -EINPROGRESS;
+ } else {
+ interactive = false;
+
+ if (strcmp(argv[1], "--help") == 0 ||
+ strcmp(argv[1], "-h") == 0)
+ err = __connmanctl_commands(connection, help, 1);
+ else
+ err = __connmanctl_commands(connection, argv + 1,
+ argc - 1);
+ }
+
+ if (err == -EINPROGRESS) {
+ main_loop = g_main_loop_new(NULL, FALSE);
+ g_main_loop_run(main_loop);
+
+ err = 0;
+ }
+
+ if (interactive) {
+ g_source_remove(source);
+ __connmanctl_monitor_completions(NULL);
+
+ rl_callback_handler_remove();
+#if 0
+ rl_message("");
+#endif
+ }
+
+ dbus_connection_unref(connection);
+ if (main_loop)
+ g_main_loop_unref(main_loop);
+
+ if (err < 0)
+ err = -err;
+ else
+ err = 0;
+
+ return err;
+}
diff --git a/client/input.h b/client/input.h
new file mode 100644
index 0000000..c7256a4
--- /dev/null
+++ b/client/input.h
@@ -0,0 +1,48 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_INPUT_H
+#define __CONNMANCTL_INPUT_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __connmanctl_quit(void);
+bool __connmanctl_is_interactive(void);
+void __connmanctl_save_rl(void);
+void __connmanctl_redraw_rl(void);
+int __connmanctl_input_calc_level(void);
+void __connmanctl_input_lookup_end(void);
+typedef void (* connmanctl_input_func_t) (char *input, void *user_data);
+void __connmanctl_agent_mode(const char *prompt,
+ connmanctl_input_func_t input_handler, void *user_data);
+void __connmanctl_command_mode(void);
+int __connmanctl_input_init(int argc, char *argv[]);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_INPUT_H */
diff --git a/client/main.c b/client/main.c
new file mode 100644
index 0000000..6d3c57f
--- /dev/null
+++ b/client/main.c
@@ -0,0 +1,28 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include "input.h"
+
+int main(int argc, char *argv[])
+{
+ return __connmanctl_input_init(argc, argv);
+}
diff --git a/client/peers.c b/client/peers.c
new file mode 100644
index 0000000..bf1aa0e
--- /dev/null
+++ b/client/peers.c
@@ -0,0 +1,122 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include "peers.h"
+
+static void print_peer(char *path, DBusMessageIter *iter)
+{
+ char *name = "", *state = "";
+ char *str, *property;
+ DBusMessageIter entry, val;
+ int count = 0;
+
+ while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ dbus_message_iter_recurse(iter, &entry);
+ dbus_message_iter_get_basic(&entry, &property);
+
+ if (strcmp(property, "Name") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &name);
+ } else if (strcmp(property, "State") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &state);
+ }
+
+ dbus_message_iter_next(iter);
+ count++;
+ }
+
+ str = strrchr(path, '/');
+ if (str)
+ str++;
+ else
+ str = path;
+
+ if (count > 0)
+ fprintf(stdout, "%s %s %s", name, state, str);
+ else
+ fprintf(stdout, "%s %s", "unchanged", str);
+}
+
+static void list_peer_array(DBusMessageIter *iter)
+{
+ DBusMessageIter array, dict;
+ char *path = NULL;
+
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
+ dbus_message_iter_recurse(iter, &array);
+ if (dbus_message_iter_get_arg_type(&array)
+ != DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(&array, &path);
+
+ dbus_message_iter_next(&array);
+ if (dbus_message_iter_get_arg_type(&array)
+ == DBUS_TYPE_ARRAY) {
+ dbus_message_iter_recurse(&array, &dict);
+ print_peer(path, &dict);
+ }
+
+ if (dbus_message_iter_has_next(iter))
+ fprintf(stdout, "\n");
+
+ dbus_message_iter_next(iter);
+ }
+}
+
+void __connmanctl_peers_list(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+ char *path;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ list_peer_array(&array);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ fprintf(stdout, "\n}, {");
+
+ dbus_message_iter_recurse(iter, &array);
+ while (dbus_message_iter_get_arg_type(&array)
+ == DBUS_TYPE_OBJECT_PATH) {
+ dbus_message_iter_get_basic(&array, &path);
+ fprintf(stdout, "\n%s %s", "removed", path);
+
+ dbus_message_iter_next(&array);
+ }
+
+}
diff --git a/client/peers.h b/client/peers.h
new file mode 100644
index 0000000..fdf7ce7
--- /dev/null
+++ b/client/peers.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_PEERS_H
+#define __CONNMANCTL_PEERS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __connmanctl_peers_list(DBusMessageIter *iter);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_PEERS_H */
diff --git a/client/services.c b/client/services.c
new file mode 100644
index 0000000..0c18669
--- /dev/null
+++ b/client/services.c
@@ -0,0 +1,156 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include "services.h"
+
+static void print_service(char *path, DBusMessageIter *iter)
+{
+ char *name = "", *str = NULL;
+ int autoconn = 0, favorite = 0, count = 0;
+ char *property;
+ char state = ' ';
+ DBusMessageIter entry, val;
+
+ while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+
+ dbus_message_iter_recurse(iter, &entry);
+ dbus_message_iter_get_basic(&entry, &property);
+ if (strcmp(property, "Name") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &name);
+
+ } else if (strcmp(property, "State") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &str);
+
+ if (str) {
+ if (strcmp(str, "online") == 0)
+ state = 'O';
+ else if (strcmp(str, "ready") == 0)
+ state = 'R';
+ else if (!strcmp(str, "association"))
+ state = 'a';
+ else if (!strcmp(str, "configuration"))
+ state = 'c';
+ else if (!strcmp(str, "disconnect"))
+ state = 'd';
+ }
+
+ } else if (strcmp(property, "AutoConnect") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &autoconn);
+
+ } else if (strcmp(property, "Favorite") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &favorite);
+ }
+
+ count++;
+ dbus_message_iter_next(iter);
+ }
+
+ str = strrchr(path, '/');
+ if (str)
+ str++;
+ else
+ str = path;
+
+ if (count > 0)
+ fprintf(stdout, "%c%c%c %-20s %s", favorite != 0 ? '*' : ' ',
+ autoconn != 0 ? 'A' : ' ', state, name, str);
+ else
+ fprintf(stdout, "%-24s %s", "unchanged", str);
+
+}
+
+static void list_service_array(DBusMessageIter *iter)
+{
+ DBusMessageIter array, dict;
+ char *path = NULL;
+
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRUCT) {
+
+ dbus_message_iter_recurse(iter, &array);
+ if (dbus_message_iter_get_arg_type(&array)
+ != DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(&array, &path);
+
+ dbus_message_iter_next(&array);
+ if (dbus_message_iter_get_arg_type(&array)
+ == DBUS_TYPE_ARRAY) {
+ dbus_message_iter_recurse(&array, &dict);
+ print_service(path, &dict);
+ }
+
+ if (dbus_message_iter_has_next(iter))
+ fprintf(stdout, "\n");
+
+ dbus_message_iter_next(iter);
+ }
+}
+
+void __connmanctl_services_list(DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+ char *path;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+ list_service_array(&array);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ fprintf(stdout, "\n}, {");
+
+ dbus_message_iter_recurse(iter, &array);
+ while (dbus_message_iter_get_arg_type(&array)
+ == DBUS_TYPE_OBJECT_PATH) {
+ dbus_message_iter_get_basic(&array, &path);
+ fprintf(stdout, "\n%-24s %s", "removed", path);
+
+ dbus_message_iter_next(&array);
+ }
+
+}
diff --git a/client/services.h b/client/services.h
new file mode 100644
index 0000000..9b555fe
--- /dev/null
+++ b/client/services.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_SERVICES_H
+#define __CONNMANCTL_SERVICES_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __connmanctl_services_list(DBusMessageIter *iter);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_SERVICES_H */
diff --git a/client/vpnconnections.c b/client/vpnconnections.c
new file mode 100644
index 0000000..d7bcbfe
--- /dev/null
+++ b/client/vpnconnections.c
@@ -0,0 +1,111 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+
+#include "vpnconnections.h"
+
+static void print_connection(char *path, DBusMessageIter *iter)
+{
+ char *name = "";
+ char state = ' ';
+ char *str;
+ char *property;
+ DBusMessageIter entry, val;
+
+ while (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+
+ dbus_message_iter_recurse(iter, &entry);
+ dbus_message_iter_get_basic(&entry, &property);
+ if (strcmp(property, "Name") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &name);
+
+ } else if (strcmp(property, "State") == 0) {
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &val);
+ dbus_message_iter_get_basic(&val, &str);
+
+ if (str) {
+ if (strcmp(str, "ready") == 0)
+ state = 'R';
+ else if (strcmp(str, "configuration") == 0)
+ state = 'C';
+ else if (strcmp(str, "failure") == 0)
+ state = 'F';
+ }
+ }
+
+ dbus_message_iter_next(iter);
+ }
+
+ str = strrchr(path, '/');
+ if (str)
+ str++;
+ else
+ str = path;
+
+ fprintf(stdout, " %c %-20s %s", state, name, str);
+}
+
+void __connmanctl_vpnconnections_list(DBusMessageIter *iter)
+{
+ DBusMessageIter array, entry, dict;
+ char *path = NULL;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRUCT) {
+
+ dbus_message_iter_recurse(&array, &entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_OBJECT_PATH)
+ return;
+
+ dbus_message_iter_get_basic(&entry, &path);
+
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ == DBUS_TYPE_ARRAY) {
+ dbus_message_iter_recurse(&entry, &dict);
+ print_connection(path, &dict);
+ }
+
+ if (dbus_message_iter_has_next(&array))
+ fprintf(stdout, "\n");
+
+ dbus_message_iter_next(&array);
+ }
+
+ fprintf(stdout, "\n");
+}
diff --git a/client/vpnconnections.h b/client/vpnconnections.h
new file mode 100644
index 0000000..a915c84
--- /dev/null
+++ b/client/vpnconnections.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMANCTL_VPNCONNECTIONS_H
+#define __CONNMANCTL_VPNCONNECTIONS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void __connmanctl_vpnconnections_list(DBusMessageIter *iter);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMANCTL_VPNCONNECTIONS_H */
diff --git a/configure.ac b/configure.ac
new file mode 100644
index 0000000..95c90da
--- /dev/null
+++ b/configure.ac
@@ -0,0 +1,399 @@
+AC_PREREQ(2.60)
+AC_INIT(connman, 1.29)
+
+AM_INIT_AUTOMAKE([foreign subdir-objects color-tests])
+AC_CONFIG_HEADERS([config.h])
+
+m4_ifdef([AM_SILENT_RULES], [AM_SILENT_RULES([yes])])
+
+AM_MAINTAINER_MODE
+
+AC_PREFIX_DEFAULT(/usr/local)
+
+PKG_PROG_PKG_CONFIG
+
+COMPILER_FLAGS
+
+AC_SUBST(abs_top_srcdir)
+AC_SUBST(abs_top_builddir)
+
+AC_LANG_C
+
+AC_PROG_CC
+AM_PROG_CC_C_O
+AC_PROG_CC_PIE
+AC_PROG_INSTALL
+AC_PROG_MKDIR_P
+
+m4_define([_LT_AC_TAGCONFIG], [])
+m4_ifdef([AC_LIBTOOL_TAGS], [AC_LIBTOOL_TAGS([])])
+
+AC_DISABLE_STATIC
+AC_PROG_LIBTOOL
+
+AC_ARG_ENABLE(optimization, AC_HELP_STRING([--disable-optimization],
+ [disable code optimization through compiler]), [
+ if (test "${enableval}" = "no"); then
+ CFLAGS="$CFLAGS -O0 -U_FORTIFY_SOURCE"
+ fi
+])
+
+AC_ARG_ENABLE(debug, AC_HELP_STRING([--enable-debug],
+ [enable compiling with debugging information]), [
+ if (test "${enableval}" = "yes" &&
+ test "${ac_cv_prog_cc_g}" = "yes"); then
+ CFLAGS="$CFLAGS -g"
+ AC_DEFINE(CONNMAN_DEBUG, 1, [Enable connman debugging code?])
+ fi
+])
+
+AC_ARG_ENABLE(pie, AC_HELP_STRING([--enable-pie],
+ [enable position independent executables flag]), [
+ if (test "${enableval}" = "yes" &&
+ test "${ac_cv_prog_cc_pie}" = "yes"); then
+ CFLAGS="$CFLAGS -fPIE"
+ LDFLAGS="$LDFLAGS -pie"
+ fi
+])
+
+AC_ARG_ENABLE(hh2serial-gps,
+ AC_HELP_STRING([--enable-hh2serial-gps], [enable hh2serial GPS support]),
+ [enable_hh2serial_gps=${enableval}], [enable_hh2serial_gps="no"])
+AM_CONDITIONAL(HH2SERIAL_GPS, test "${enable_hh2serial_gps}" != "no")
+AM_CONDITIONAL(HH2SERIAL_GPS_BUILTIN, test "${enable_hh2serial_gps}" = "builtin")
+
+AC_ARG_WITH(openconnect, AC_HELP_STRING([--with-openconnect=PROGRAM],
+ [specify location of openconnect binary]), [path_openconnect=${withval}])
+
+AC_ARG_ENABLE(openconnect,
+ AC_HELP_STRING([--enable-openconnect], [enable openconnect support]),
+ [enable_openconnect=${enableval}], [enable_openconnect="no"])
+if (test "${enable_openconnect}" != "no"); then
+ if (test -z "${path_openconnect}"); then
+ AC_PATH_PROG(OPENCONNECT, [openconnect], [], $PATH:/sbin:/usr/sbin)
+ if (test -z "${OPENCONNECT}"); then
+ AC_MSG_ERROR(openconnect binary not found)
+ fi
+ else
+ OPENCONNECT="${path_openconnect}"
+ AC_SUBST(OPENCONNECT)
+ fi
+fi
+AM_CONDITIONAL(OPENCONNECT, test "${enable_openconnect}" != "no")
+AM_CONDITIONAL(OPENCONNECT_BUILTIN, test "${enable_openconnect}" = "builtin")
+
+AC_ARG_WITH(openvpn, AC_HELP_STRING([--with-openvpn=PROGRAM],
+ [specify location of openvpn binary]), [path_openvpn=${withval}])
+
+AC_ARG_ENABLE(openvpn,
+ AC_HELP_STRING([--enable-openvpn], [enable openvpn support]),
+ [enable_openvpn=${enableval}], [enable_openvpn="no"])
+if (test "${enable_openvpn}" != "no"); then
+ if (test -z "${path_openvpn}"); then
+ AC_PATH_PROG(OPENVPN, [openvpn], [], $PATH:/sbin:/usr/sbin)
+ if (test -z "${OPENVPN}"); then
+ AC_MSG_ERROR(openvpn binary not found)
+ fi
+ else
+ OPENVPN="${path_openvpn}"
+ AC_SUBST(OPENVPN)
+ fi
+fi
+AM_CONDITIONAL(OPENVPN, test "${enable_openvpn}" != "no")
+AM_CONDITIONAL(OPENVPN_BUILTIN, test "${enable_openvpn}" = "builtin")
+
+AC_ARG_WITH(vpnc, AC_HELP_STRING([--with-vpnc=PROGRAM],
+ [specify location of vpnc binary]), [path_vpnc=${withval}])
+
+AC_ARG_ENABLE(vpnc,
+ AC_HELP_STRING([--enable-vpnc], [enable vpnc support]),
+ [enable_vpnc=${enableval}], [enable_vpnc="no"])
+if (test "${enable_vpnc}" != "no"); then
+ if (test -z "${path_vpnc}"); then
+ AC_PATH_PROG(VPNC, [vpnc], [], $PATH:/sbin:/usr/sbin)
+ if (test -z "${VPNC}"); then
+ AC_MSG_ERROR(vpnc binary not found)
+ fi
+ else
+ VPNC="${path_vpnc}"
+ AC_SUBST(VPNC)
+ fi
+fi
+AM_CONDITIONAL(VPNC, test "${enable_vpnc}" != "no")
+AM_CONDITIONAL(VPNC_BUILTIN, test "${enable_vpnc}" = "builtin")
+
+AC_ARG_WITH(l2tp, AC_HELP_STRING([--with-l2tp=PROGRAM],
+ [specify location of l2tp binary]), [path_l2tp=${withval}])
+
+AC_ARG_ENABLE(l2tp,
+ AC_HELP_STRING([--enable-l2tp], [enable l2tp support]),
+ [enable_l2tp=${enableval}], [enable_l2tp="no"])
+if (test "${enable_l2tp}" != "no"); then
+ if (test -z "${path_pppd}"); then
+ AC_PATH_PROG(PPPD, [pppd], [/usr/sbin/pppd], $PATH:/sbin:/usr/sbin)
+ else
+ PPPD="${path_pppd}"
+ AC_SUBST(PPPD)
+ fi
+ AC_CHECK_HEADERS(pppd/pppd.h, dummy=yes,
+ AC_MSG_ERROR(ppp header files are required))
+ if (test -z "${path_l2tp}"); then
+ AC_PATH_PROG(L2TP, [xl2tpd], [/usr/sbin/xl2tpd], $PATH:/sbin:/usr/sbin)
+ else
+ L2TP="${path_l2tp}"
+ AC_SUBST(L2TP)
+ fi
+fi
+AM_CONDITIONAL(L2TP, test "${enable_l2tp}" != "no")
+AM_CONDITIONAL(L2TP_BUILTIN, test "${enable_l2tp}" = "builtin")
+
+AC_ARG_WITH(pptp, AC_HELP_STRING([--with-pptp=PROGRAM],
+ [specify location of pptp binary]), [path_pptp=${withval}])
+
+AC_ARG_ENABLE(pptp,
+ AC_HELP_STRING([--enable-pptp], [enable pptp support]),
+ [enable_pptp=${enableval}], [enable_pptp="no"])
+if (test "${enable_pptp}" != "no"); then
+ if (test -z "${path_pppd}"); then
+ AC_PATH_PROG(PPPD, [pppd], [/usr/sbin/pppd], $PATH:/sbin:/usr/sbin)
+ else
+ PPPD="${path_pppd}"
+ AC_SUBST(PPPD)
+ fi
+ AC_CHECK_HEADERS(pppd/pppd.h, dummy=yes,
+ AC_MSG_ERROR(ppp header files are required))
+ if (test -z "${path_pptp}"); then
+ AC_PATH_PROG(PPTP, [pptp], [/usr/sbin/pptp], $PATH:/sbin:/usr/sbin)
+ else
+ PPTP="${path_pptp}"
+ AC_SUBST(PPTP)
+ fi
+fi
+AM_CONDITIONAL(PPTP, test "${enable_pptp}" != "no")
+AM_CONDITIONAL(PPTP_BUILTIN, test "${enable_pptp}" = "builtin")
+
+AC_CHECK_HEADERS(resolv.h, dummy=yes,
+ AC_MSG_ERROR(resolver header files are required))
+AC_CHECK_LIB(resolv, ns_initparse, dummy=yes, [
+ AC_CHECK_LIB(resolv, __ns_initparse, dummy=yes,
+ AC_MSG_ERROR(resolver library support is required))
+])
+
+AC_CHECK_FUNC(signalfd, dummy=yes,
+ AC_MSG_ERROR(signalfd support is required))
+
+AC_CHECK_LIB(dl, dlopen, dummy=yes,
+ AC_MSG_ERROR(dynamic linking loader is required))
+
+AC_ARG_ENABLE(iospm, AC_HELP_STRING([--enable-iospm],
+ [enable Intel OSPM support]), [enable_iospm=${enableval}])
+AM_CONDITIONAL(IOSPM, test "${enable_iospm}" = "yes")
+
+AC_ARG_ENABLE(tist,
+ AC_HELP_STRING([--enable-tist], [enable TI Shared Transport support]),
+ [enable_tist=${enableval}], [enable_tist="no"])
+AM_CONDITIONAL(TIST, test "${enable_tist}" != "no")
+AM_CONDITIONAL(TIST_BUILTIN, test "${enable_tist}" = "builtin")
+
+AC_ARG_ENABLE(session-policy-local,
+ AC_HELP_STRING([--enable-session-policy-local], [enable local file Session policy configuration support]),
+ [enable_session_policy_local=${enableval}], [enable_session_policy_local="no"])
+AM_CONDITIONAL(SESSION_POLICY_LOCAL, test "${enable_session_policy_local}" != "no")
+AM_CONDITIONAL(SESSION_POLICY_LOCAL_BUILTIN, test "${enable_session_policy_local}" = "builtin")
+
+AC_ARG_WITH(stats-max-file-size, AC_HELP_STRING([--with-stats-max-file-size=SIZE],
+ [Maximal size of a statistics round robin file]),
+ [stats_max_file_size=${withval}])
+
+if (test -z "${stats_max_file_size}"); then
+ # default size is 16 kByte
+ stats_max_file_size="16 * 8 * 128"
+fi
+
+AC_DEFINE_UNQUOTED([STATS_MAX_FILE_SIZE], (${stats_max_file_size}), [Maximal size of a statistics round robin file])
+
+PKG_CHECK_MODULES(GLIB, glib-2.0 >= 2.28, dummy=yes,
+ AC_MSG_ERROR(GLib >= 2.28 is required))
+AC_SUBST(GLIB_CFLAGS)
+AC_SUBST(GLIB_LIBS)
+
+PKG_CHECK_MODULES(DBUS, dbus-1 >= 1.4, dummy=yes,
+ AC_MSG_ERROR(D-Bus >= 1.4 is required))
+AC_SUBST(DBUS_CFLAGS)
+AC_SUBST(DBUS_LIBS)
+
+AC_ARG_WITH(dbusconfdir, AC_HELP_STRING([--with-dbusconfdir=PATH],
+ [path to D-Bus config directory]), [path_dbusconf=${withval}],
+ [path_dbusconf="`$PKG_CONFIG --variable=sysconfdir dbus-1`"])
+if (test -z "${path_dbusconf}"); then
+ DBUS_CONFDIR="${sysconfdir}/dbus-1/system.d"
+else
+ DBUS_CONFDIR="${path_dbusconf}/dbus-1/system.d"
+fi
+AC_SUBST(DBUS_CONFDIR)
+
+AC_ARG_WITH(dbusdatadir, AC_HELP_STRING([--with-dbusdatadir=PATH],
+ [path to D-Bus data directory]), [path_dbusdata=${withval}],
+ [path_dbusdata="`$PKG_CONFIG --variable=datadir dbus-1`"])
+if (test -z "${path_dbusdata}"); then
+ DBUS_DATADIR="${datadir}/dbus-1/system-services"
+else
+ DBUS_DATADIR="${path_dbusdata}/dbus-1/system-services"
+fi
+AC_SUBST(DBUS_DATADIR)
+
+AC_ARG_WITH([systemdunitdir], AC_HELP_STRING([--with-systemdunitdir=DIR],
+ [path to systemd service directory]), [path_systemdunit=${withval}],
+ [path_systemdunit="`$PKG_CONFIG --variable=systemdsystemunitdir systemd`"])
+if (test -n "${path_systemdunit}"); then
+ SYSTEMD_UNITDIR="${path_systemdunit}"
+ AC_SUBST(SYSTEMD_UNITDIR)
+fi
+AM_CONDITIONAL(SYSTEMD, test -n "${path_systemdunit}")
+
+PKG_CHECK_MODULES(XTABLES, xtables >= 1.4.11, dummy=yes,
+ AC_MSG_ERROR(Xtables library is required))
+AC_SUBST(XTABLES_CFLAGS)
+AC_SUBST(XTABLES_LIBS)
+
+AC_ARG_ENABLE(test, AC_HELP_STRING([--enable-test],
+ [enable test/example scripts]), [enable_test=${enableval}])
+AM_CONDITIONAL(TEST, test "${enable_test}" = "yes")
+
+AC_ARG_ENABLE(nmcompat, AC_HELP_STRING([--enable-nmcompat],
+ [enable Network Manager support]),
+ [enable_nmcompat=${enableval}], [enable_nmcompat="no"])
+AM_CONDITIONAL(NMCOMPAT, test "${enable_nmcompat}" != "no")
+
+AC_ARG_ENABLE(polkit, AC_HELP_STRING([--enable-polkit],
+ [enable PolicyKit support]),
+ [enable_polkit=${enableval}], [enable_polkit="no"])
+if (test "${enable_polkit}" != "no"); then
+ POLKIT_DATADIR="`$PKG_CONFIG --variable=actiondir polkit`"
+ POLKIT_DATADIR=""
+ if (test -z "${POLKIT_DATADIR}"); then
+ POLKIT_DATADIR="${datadir}/polkit-1/actions"
+ fi
+ AC_SUBST(POLKIT_DATADIR)
+fi
+AM_CONDITIONAL(POLKIT, test "${enable_polkit}" != "no")
+
+AC_ARG_ENABLE(selinux, AC_HELP_STRING([--enable-selinux],
+ [enable selinux support]),
+ [enable_selinux=${enableval}], [enable_selinux="no"])
+AM_CONDITIONAL(SELINUX, test "${enable_selinux}" != "no")
+
+AC_ARG_ENABLE(loopback, AC_HELP_STRING([--disable-loopback],
+ [disable loopback support]),
+ [enable_loopback=${enableval}])
+AM_CONDITIONAL(LOOPBACK, test "${enable_loopback}" != "no")
+
+AC_ARG_ENABLE(ethernet, AC_HELP_STRING([--disable-ethernet],
+ [disable Ethernet support]),
+ [enable_ethernet=${enableval}])
+AM_CONDITIONAL(ETHERNET, test "${enable_ethernet}" != "no")
+
+AC_ARG_ENABLE(sleep, AC_HELP_STRING([--enable-sleep],
+ [enable sleep support]),
+ [enable_sleep=${enableval}], [enable_sleep="no"])
+AM_CONDITIONAL(SLEEP, test "${enable_sleep}" != "no")
+
+AC_ARG_ENABLE(gadget, AC_HELP_STRING([--disable-gadget],
+ [disable USB Gadget support]),
+ [enable_gadget=${enableval}])
+AM_CONDITIONAL(GADGET, test "${enable_gadget}" != "no")
+
+AC_ARG_ENABLE(wifi, AC_HELP_STRING([--disable-wifi],
+ [disable WiFi support]),
+ [enable_wifi=${enableval}])
+AM_CONDITIONAL(WIFI, test "${enable_wifi}" != "no")
+
+AC_ARG_ENABLE(bluetooth, AC_HELP_STRING([--disable-bluetooth],
+ [disable Bluetooth support]),
+ [enable_bluetooth=${enableval}])
+AM_CONDITIONAL(BLUETOOTH, test "${enable_bluetooth}" != "no")
+
+AC_ARG_ENABLE(ofono, AC_HELP_STRING([--disable-ofono],
+ [disable oFono support]),
+ [enable_ofono=${enableval}])
+AM_CONDITIONAL(OFONO, test "${enable_ofono}" != "no")
+
+AC_ARG_ENABLE(dundee, AC_HELP_STRING([--disable-dundee],
+ [disable dundee support (Bluetooth DUN)]),
+ [enable_dundee=${enableval}])
+AM_CONDITIONAL(DUNDEE, test "${enable_dundee}" != "no")
+
+AC_ARG_ENABLE(pacrunner, AC_HELP_STRING([--disable-pacrunner],
+ [disable PACrunner support]),
+ [enable_pacrunner=${enableval}])
+AM_CONDITIONAL(PACRUNNER, test "${enable_pacrunner}" != "no")
+
+AC_ARG_ENABLE(neard, AC_HELP_STRING([--disable-neard],
+ [disable Neard support]),
+ [enable_neard=${enableval}])
+AM_CONDITIONAL(NEARD, test "${enable_neard}" != "no")
+
+AC_ARG_ENABLE(wispr, AC_HELP_STRING([--disable-wispr],
+ [disable WISPr support]),
+ [enable_wispr=${enableval}])
+AM_CONDITIONAL(WISPR, test "${enable_wispr}" != "no")
+
+AC_ARG_ENABLE(tools, AC_HELP_STRING([--disable-tools],
+ [disable testing tools]),
+ [enable_tools=${enableval}])
+AM_CONDITIONAL(TOOLS, test "${enable_tools}" != "no")
+
+if (test "${enable_tools}" != "no"); then
+ AC_PATH_PROGS(IPTABLES_SAVE, [iptables-save], [],
+ $PATH:/sbin:/usr/sbin)
+ IPTABLES_SAVE=$ac_cv_path_IPTABLES_SAVE
+else
+ IPTABLES_SAVE=""
+fi
+AC_SUBST(IPTABLES_SAVE)
+
+AC_ARG_ENABLE(client, AC_HELP_STRING([--disable-client],
+ [disable command line client]),
+ [enable_client=${enableval}])
+AM_CONDITIONAL(CLIENT, test "${enable_client}" != "no")
+
+if (test "${enable_wispr}" != "no"); then
+ PKG_CHECK_MODULES(GNUTLS, gnutls, dummy=yes,
+ AC_MSG_ERROR(GnuTLS library is required))
+else
+ GNUTLS_CFLAGS=""
+ GNUTLS_LIBS=""
+fi
+AC_SUBST(GNUTLS_CFLAGS)
+AC_SUBST(GNUTLS_LIBS)
+
+if (test "${enable_loopback}" != "no"); then
+ AC_CHECK_HEADERS(sys/inotify.h, dummy=yes,
+ AC_MSG_ERROR(inotify header files are required))
+
+ AC_CHECK_LIB(c, inotify_init, dummy=yes,
+ AC_MSG_ERROR(inotify library support is required))
+fi
+
+if (test "${enable_wifi}" != "no"); then
+ AC_PATH_PROG(WPASUPPLICANT, [wpa_supplicant], [],
+ $PATH:/sbin:/usr/sbin)
+fi
+
+AC_ARG_ENABLE(datafiles, AC_HELP_STRING([--disable-datafiles],
+ [don't install configuration and data files]),
+ [enable_datafiles=${enableval}])
+AM_CONDITIONAL(DATAFILES, test "${enable_datafiles}" != "no")
+
+if (test "${enable_client}" != "no"); then
+ AC_CHECK_HEADERS(readline/readline.h, dummy=yes,
+ AC_MSG_ERROR(readline header files are required))
+fi
+
+AM_CONDITIONAL(VPN, test "${enable_openconnect}" != "no" -o \
+ "${enable_openvpn}" != "no" -o \
+ "${enable_vpnc}" != "no" -o \
+ "${enable_l2tp}" != "no" -o \
+ "${enable_pptp}" != "no")
+
+AC_OUTPUT(Makefile include/version.h connman.pc)
diff --git a/connman.pc.in b/connman.pc.in
new file mode 100644
index 0000000..2af3c2b
--- /dev/null
+++ b/connman.pc.in
@@ -0,0 +1,14 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+plugindir=${libdir}/connman/plugins
+scriptdir=${libdir}/connman/scripts
+
+Name: connman
+Description: Connection Manager
+Requires: glib-2.0 dbus-1
+Version: @VERSION@
+Libs: -module -avoid-version -export-symbols-regex connman_plugin_desc
+Cflags: -I${includedir}
diff --git a/doc/advanced-configuration.txt b/doc/advanced-configuration.txt
new file mode 100644
index 0000000..12c2250
--- /dev/null
+++ b/doc/advanced-configuration.txt
@@ -0,0 +1,61 @@
+Advanced configuration interface
+********************************
+
+
+Configuration basics
+====================
+
+The default configuration method for all services is automatic or something
+like DHCP. In almost every case that should be just good enough, but if it
+is not, Connection Manager supports manual configuration for Ethernet and
+IP settings.
+
+
+Configuration interface
+=======================
+
+Every service contains two properties. One represents the current active
+configuration and the other one allows manual configuration via the user.
+
+For IPv4 they are named "IPv4" and IPv4.Configuration".
+
+[ /profile/default/wifi_001122334455_42696720696e204a6170616e_managed_psk ]
+ Type = wifi
+ Name = Big in Japan
+ Mode = managed
+ Strength = 82
+ Security = rsn
+ Favorite = true
+ State = ready
+ IPv4.Configuration = { Method=dhcp }
+ IPv4 = { Netmask=255.255.255.0 Method=dhcp Address=192.168.1.198 }
+
+The above WiFi network shows how the default configuration would look like
+with a connected service. The configuration method is DHCP and the current
+IP address is 192.168.1.198.
+
+The "IPv4" property is read-only and will emit PropertyChanged signals in
+case the IP address of this interface changes. The "IPv4.Configuration"
+property is read-write and allows changes. For example to use a static IP
+configuration this call could be used:
+
+ service.SetProperty("IPv4.Configuration", { "Method": "manual",
+ "Address": "192.168.1.100",
+ "Netmask": "255.255.255.0" })
+
+The configuration itself is a dictionary with various fields. Not all of
+them need to be present. A lot of combinations are valid.
+
+For example the "Method" field has valid settings of "off", "fixed", "manual"
+and "dhcp". The "fixed" value however can not be set by any user program. It
+is an internal value that some 3G cards require. Switching to "off" will
+remove any IP configuration from the interface. The "manual" method allows
+for static address configuration. And "dhcp" will use DHCP to retrieve all
+required information automatically.
+
+With a manual configuration, the fields "Address" and "Netmask" should be
+given. In case "Netmask" is left out, the best netmask will be calculated.
+
+The "Gateway" field can be used to indicate the default route/gateway for
+this interface.
+
diff --git a/doc/agent-api.txt b/doc/agent-api.txt
new file mode 100644
index 0000000..2ddd19a
--- /dev/null
+++ b/doc/agent-api.txt
@@ -0,0 +1,305 @@
+Agent hierarchy
+===============
+
+Service unique name
+Interface net.connman.Agent
+Object path freely definable
+
+Methods void Release()
+
+ This method gets called when the service daemon
+ unregisters the agent. An agent can use it to do
+ cleanup tasks. There is no need to unregister the
+ agent, because when this method gets called it has
+ already been unregistered.
+
+ void ReportError(object service, string error)
+
+ This method gets called when an error has to be
+ reported to the user.
+
+ A special return value can be used to trigger a
+ retry of the failed transaction.
+
+ Possible Errors: net.connman.Agent.Error.Retry
+
+ void ReportPeerError(object peer, string error)
+
+ This method gets called when an error has to be
+ reported to the user about a peer connection.
+
+ A special return value can be used to trigger a
+ retry of the failed transaction.
+
+ Possible Errors: net.connman.Agent.Error.Retry
+
+ void RequestBrowser(object service, string url)
+
+ This method gets called when it is required
+ to ask the user to open a website to procceed
+ with login handling.
+
+ This can happen if connected to a hotspot portal
+ page without WISPr support.
+
+ Possible Errors: net.connman.Agent.Error.Canceled
+
+ dict RequestInput(object service, dict fields)
+
+ This method gets called when trying to connect to
+ a service and some extra input is required. For
+ example a passphrase or the name of a hidden network.
+
+ The return value should be a dictionary where the
+ keys are the field names and the values are the
+ actual fields. Alternatively an error indicating that
+ the request got canceled can be returned.
+
+ Most common return field names are "Name" and of
+ course "Passphrase".
+
+ The dictionary arguments contains field names with
+ their input parameters.
+
+ In case of WISPr credentials requests and if the user
+ prefers to login through the browser by himself, agent
+ will have to return a LaunchBrowser error (see below).
+
+ Possible Errors: net.connman.Agent.Error.Canceled
+ net.connman.Agent.Error.LaunchBrowser
+
+ dict RequestPeerAuthorization(object peer, dict fields) [experimental]
+
+ This method gets called when trying to connect to a
+ peer or when an incoming peer connection is requested,
+ for which some extra input is required. In this case,
+ it will only deal with WPS input as well as accepting
+ or rejecting an incoming connection.
+
+ The return value should be a dictionary where the
+ keys are the field names and the values are the
+ actual fields. Alternatively an error indicating that
+ the request got canceled or rejected can be returned.
+
+ The dictionary arguments contains field names with
+ their input parameters.
+
+ Possible Errors: net.connman.Agent.Error.Canceled
+ net.connman.Agent.Error.Rejected
+
+ void Cancel()
+
+ This method gets called to indicate that the agent
+ request failed before a reply was returned.
+
+Fields string Name
+
+ The name of a network. This field will be requested
+ when trying to connect to a hidden network.
+
+ array{byte} SSID
+
+ This field is an alternative to "Name" for WiFi
+ networks and can be used to return the exact binary
+ representation of a network name.
+
+ Normally returning the "Name" field is the better
+ option here.
+
+ string Identity
+
+ Identity (username) for EAP authentication methods.
+
+ string Passphrase
+
+ The passphrase for authentication. For example a WEP
+ key, a PSK passphrase or a passphrase for EAP
+ authentication methods.
+
+ string PreviousPassphrase
+
+ The previous passphrase successfully saved, i.e.
+ which lead to a successfull connection. This field is
+ provided as an informational argument when connecting
+ with it does not work anymore, for instance when it
+ has been changed on the AP. Such argument appears when
+ a RequestInput is raised after a retry. In case of WPS
+ association through PIN method: when retrying, the
+ previous wpspin will be provided.
+
+ string WPS
+
+ This field requests the use of WPS to get associated.
+ This is an alternate choice against Passphrase when
+ requested service supports WPS. The reply can contain
+ either empty pin, if user wants to use push-button
+ method, or a pin code if user wants to use the pin
+ method.
+
+ In case of a RequestPeerAuthorization, this field will
+ be set as mandatory.
+
+ string Username
+
+ Username for WISPr authentication. This field will be
+ requested when connecting to a WISPr-enabled hotspot.
+
+ string Password
+
+ Password for WISPr authentication. This field will be
+ requested when connecting to a WISPr-enabled hotspot.
+
+Arguments string Type
+
+ Contains the type of a field. For example "psk", "wep"
+ "passphrase", "response", "ssid", "wpspin" or plain
+ "string".
+
+ string Requirement
+
+ Contains the requirement option. Valid values are
+ "mandatory", "optional", "alternate" or
+ "informational".
+
+ The "alternate" value specifies that this field can be
+ returned as an alternative to another one. An example
+ would be the network name or SSID.
+
+ All "mandatory" fields must be returned, while the
+ "optional" can be returned if available.
+
+ Nothing needs to be returned for "informational", as it
+ is here only to provide an information so a value is
+ attached to it.
+
+ array{string} Alternates
+
+ Contains the list of alternate field names this
+ field can be represented by.
+
+ string Value
+
+ Contains data as a string, relatively to an
+ "informational" argument.
+
+Examples Requesting a passphrase for WPA2 network
+
+ RequestInput("/service1",
+ { "Passphrase" : { "Type" : "psk",
+ "Requirement" : "mandatory"
+ }
+ }
+ ==> { "Passphrase" : "secret123" }
+
+ Requesting a passphrase after an error on the previous one:
+
+ RequestInput("/service1",
+ { "Passphrase" : { "Type" : "psk",
+ "Requirement" : "mandatory"
+ },
+ "PreviousPassphrase" :
+ { "Type" : "psk",
+ "Requirement : "informational",
+ "Value" : "secret123"
+ }
+ }
+
+ Requesting name for hidden network
+
+ RequestInput("/service2",
+ { "Name" : { "Type" : "string",
+ "Requirement" : "mandatory",
+ "Alternates" : [ "SSID" ]
+ },
+ "SSID" : { "Type" : "ssid",
+ "Requirement" : "alternate"
+ }
+ }
+ ==> { "Name" : "My hidden network" }
+
+ Requesting a passphrase for a WPA2 network with WPS alternative:
+
+ RequestInput("/service3",
+ { "Passphrase" : { "Type" : "psk",
+ "Requirement" : "mandatory",
+ "Alternates" : [ "WPS" ]
+ },
+ "WPS" : { "Type" : "wpspin",
+ "Requirement" : "alternate"
+ }
+ }
+
+ ==> { "WPS" : "123456" }
+
+ Requesting a passphrase for a WPA2 network with WPS alternative
+ after an error on the previous one:
+
+ RequestInput("/service3",
+ { "Passphrase" : { "Type" : "psk",
+ "Requirement" : "mandatory",
+ "Alternates" : [ "WPS" ]
+ },
+ "WPS" : { "Type" : "wpspin",
+ "Requirement" : "alternate"
+ }
+ "PreviousPassphrase" :
+ { "Type" : "wpspin",
+ "Requirement : "informational",
+ "Value" : "123456"
+ }
+
+ Requesting passphrase for a WPA-Enterprise network:
+
+ RequestInput("/service4",
+ { "Identity" : { "Type" : "string",
+ "Requirement" : "mandatory"
+ },
+ "Passphrase" : { "Type" : "passphrase",
+ "Requirement" : "mandatory"
+ }
+ }
+
+ ==> { "Identity" : "alice", "Passphrase": "secret123" }
+
+ Requesting challenge response for a WPA-Enterprise network:
+
+ RequestInput("/service4",
+ { "Identity" : { "Type" : "string",
+ "Requirement" : "mandatory"
+ },
+ "Passphrase" : { "Type" : "response",
+ "Requirement" : "mandatory"
+ }
+ }
+
+ ==> { "Identity" : "bob", "Passphrase": "secret123" }
+
+ Requesting username and password for a WISPr-enabled hotspot:
+
+ RequestInput("/service5",
+ { "Username" : { "Type" : "string",
+ "Requirement" : "mandatory"
+ },
+ "Password" : { "Type" : "passphrase",
+ "Requirement" : "mandatory"
+ }
+ }
+
+ ==> { "Username" : "foo", "Password": "secret" }
+
+ Requesting a answer about an inconming peer connection:
+
+ RequestPeerAuthorization("/peer3", {})
+
+ ==> { }
+
+ Requesting the WPS details when connecting to a peer:
+
+ RequestPeerAuthorization("/peer4",
+ { "WPS":
+ { "Type" : "wpspin",
+ "Requirement" : "mandatory"
+ }
+ }
+
+ ==> { "WPS" : "" }
diff --git a/doc/backtrace.txt b/doc/backtrace.txt
new file mode 100644
index 0000000..ac8472c
--- /dev/null
+++ b/doc/backtrace.txt
@@ -0,0 +1,28 @@
+ConnMan backtraces
+******************
+
+ConnMan dumps backtraces upon segmentation faults, bus errors and other
+crashing signals. Regardless of the debug level you started connmand with, the
+backtrace will be dumped to syslog.
+
+The ConnMan backtraces start with the following line:
+ -------- backtrace --------
+and will try to display function names if those can be resolved from the stack
+addresses. All static functions name will not appear for example.
+
+For a more complete and useful stack frame output you can use the
+test/backtrace script. It takes the actual binary that crashed and the
+connmand logs. The logs can contain any connman debug strings on top of the
+backtrace.
+
+Here is an example of the backtrace script usage:
+
+me@localhost:[~]$ backtrace /sbin/connmand connman.log
+-------- backtrace --------
+[0]: __connman_debug_list_available() [log.c:117]
+[1]: connman_driver_register() [element.c:515]
+[2]: __connman_driver_rescan() [element.c:490]
+[3]: disable_technology() [manager.c:391]
+[4]: generic_message() [object.c:262]
+-----------------------------------
+
diff --git a/doc/behavior-api.txt b/doc/behavior-api.txt
new file mode 100644
index 0000000..5feea76
--- /dev/null
+++ b/doc/behavior-api.txt
@@ -0,0 +1,11 @@
+Interface behavior description
+******************************
+
+
+Ethernet service
+================
+
+The Ethernet based service is a special case since it has no children, but
+still can be manually connected and disconnected while also has an implicit
+behavior when physically plugging in or removing an Ethernet cable.
+
diff --git a/doc/clock-api.txt b/doc/clock-api.txt
new file mode 100644
index 0000000..6818f5a
--- /dev/null
+++ b/doc/clock-api.txt
@@ -0,0 +1,87 @@
+Clock hierarchy
+===============
+
+Service net.connman
+Interface net.connman.Clock
+Object path /
+
+Methods dict GetProperties() [experimental]
+
+ Returns all system clock properties. See the
+ properties section for available properties.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void SetProperty(string name, variant value) [experimental]
+
+ Changes the value of the specified property. Only
+ properties that are listed as read-write are
+ changeable. On success a PropertyChanged signal
+ will be emitted.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.InvalidProperty
+
+Signals PropertyChanged(string name, variant value) [experimental]
+
+ This signal indicates a changed value of the given
+ property.
+
+
+Properties uint64 Time [readonly or readwrite] [experimental]
+
+ Current system time in seconds since epoch.
+
+ This value is present for changing the system time
+ if TimeUpdates is set to manual.
+
+ It is not present for driving an updated display
+ of the system time. PropertyChanged signal for this
+ value are only send out if it gets changed or jumps
+ unexpectedly.
+
+ In general application interested in the current
+ time should be using gettimeofday() and related
+ system calls.
+
+ string TimeUpdates [readwrite] [experimental]
+
+ Possible values are "manual" and "auto" to indicate
+ time update policy.
+
+ With the "auto" setting the system tries to use as
+ many sources as possible to determine the correct
+ and updated time.
+
+ string Timezone [readonly or readwrite] [experimental]
+
+ Current system timezone string. Allowed values
+ are from the standard timezone data (tzdata)
+ package under /usr/share/zoneinfo. For example
+ strings like "America/Vancouver" or "Europe/Berlin".
+
+ This value is present for changing the timezone
+ if TimezoneUpdates is set to manual.
+
+ When the timezone gets changed a PropertyChanged
+ signal will be send out.
+
+ string TimezoneUpdates [readwrite] [experimental]
+
+ Possible values are "manual" and "auto" to indicate
+ timezone update policy.
+
+ With the "auto" setting the system tries to use as
+ many sources as possible to determine the correct
+ timezone.
+
+ array{string} Timeservers [readwrite] [experimental]
+
+ List of global default NTP servers. The list should
+ be sorted in order of preference.
+
+ If a service configuration provides NTP servers,
+ then they are preferred over the global ones.
+
+ This list of servers is used when TimeUpdates is set
+ to auto.
diff --git a/doc/coding-style.txt b/doc/coding-style.txt
new file mode 100644
index 0000000..97410ce
--- /dev/null
+++ b/doc/coding-style.txt
@@ -0,0 +1,344 @@
+Every project has its coding style, and ConnMan is not an exception. This
+document describes the preferred coding style for ConnMan code, in order to keep
+some level of consistency among developers so that code can be easily
+understood and maintained, and also to help your code survive under
+maintainer's fastidious eyes so that you can get a passport for your patch
+ASAP.
+
+First of all, ConnMan coding style must follow every rule for Linux kernel
+(http://www.kernel.org/doc/Documentation/CodingStyle). There also exists a tool
+named checkpatch.pl to help you check the compliance with it. Just type
+"checkpatch.pl --no-tree patch_name" to check your patch. In theory, you need
+to clean up all the warnings and errors except this one: "ERROR: Missing
+Signed-off-by: line(s)". ConnMan does not used Signed-Off lines, so including
+them is actually an error. In certain circumstances one can ignore the 80
+character per line limit. This is generally only allowed if the alternative
+would make the code even less readable.
+
+Besides the kernel coding style above, ConnMan has special flavors for its own.
+Some of them are mandatory (marked as 'M'), while some others are optional
+(marked as 'O'), but generally preferred.
+
+M1: Blank line before and after an if/while/do/for statement
+============================================================
+There should be a blank line before if statement unless the if is nested and
+not preceded by an expression or variable declaration.
+
+Example:
+1)
+a = 1;
+if (b) { // wrong
+
+2)
+a = 1
+
+if (b) {
+}
+a = 2; // wrong
+
+3)
+if (a) {
+ if (b) // correct
+
+4)
+b = 2;
+
+if (a) { // correct
+
+}
+
+b = 3;
+
+The only exception to this rule applies when a variable is being allocated:
+array = g_try_new0(int, 20);
+if (!array) // Correct
+ return;
+
+
+M2: Multiple line comment
+=========================
+If your comments have more then one line, please start it from the second line.
+
+Example:
+/*
+ * first line comment // correct
+ * ...
+ * last line comment
+ */
+
+
+M3: Space before and after operator
+===================================
+There should be a space before and after each operator.
+
+Example:
+a + b; // correct
+
+
+M4: Wrap long lines
+===================
+If your condition in if, while, for statement or a function declaration is too
+long to fit in one line, the new line needs to be indented not aligned with the
+body.
+
+Example:
+1)
+if (call->status == CALL_STATUS_ACTIVE ||
+ call->status == CALL_STATUS_HELD) { // wrong
+ connman_dbus_dict_append();
+
+2)
+if (call->status == CALL_STATUS_ACTIVE ||
+ call->status == CALL_STATUS_HELD) { // correct
+ connman_dbus_dict_append();
+
+3)
+gboolean sim_ust_is_available(unsigned char *service_ust, unsigned char len,
+ enum sim_ust_service index) // wrong
+{
+ int a;
+ ...
+}
+
+4)
+gboolean sim_ust_is_available(unsigned char *service_ust, unsigned char len,
+ enum sim_ust_service index) // correct
+{
+ int a;
+ ...
+}
+
+If the line being wrapped is a function call or function declaration, the
+preferred style is to indent at least past the opening parenthesis. Indenting
+further is acceptable as well (as long as you don't hit the 80 character
+limit).
+
+If this is not possible due to hitting the 80 character limit, then indenting
+as far as possible to the right without hitting the limit is preferred.
+
+Example:
+
+1)
+gboolean sim_ust_is_available(unsigned char *service_ust, unsigned char len,
+ enum sim_ust_service index); // worse
+
+2)
+gboolean sim_ust_is_available(unsigned char *service_ust, unsigned char len,
+ enum sim_ust_service index);
+ // better
+
+M5: Git commit message 50/72 formatting
+=======================================
+The commit message header should be within 50 characters. And if you have
+detailed explanatory text, wrap it to 72 character.
+
+
+M6: Space when doing type casting
+=================================
+There should be a space between new type and variable.
+
+Example:
+1)
+a = (int *)b; // wrong
+2)
+a = (int *) b; // correct
+
+
+M7: Don't initialize variable unnecessarily
+===========================================
+When declaring a variable, try not to initialize it unless necessary.
+
+Example:
+int i = 1; // wrong
+
+for (i = 0; i < 3; i++) {
+}
+
+
+M8: Use g_try_malloc instead of g_malloc
+========================================
+When g_malloc fails, the whole program would exit. Most of time, this is not
+the expected behavior, and you may want to use g_try_malloc instead.
+
+Example:
+additional = g_try_malloc(len - 1); // correct
+if (!additional)
+ return FALSE;
+
+
+M9: Follow the order of include header elements
+===============================================
+When writing an include header the various elements should be in the following
+order:
+ - #includes
+ - forward declarations
+ - #defines
+ - enums
+ - typedefs
+ - function declarations and inline function definitions
+
+
+M10: Internal headers must not use include guards
+=================================================
+Any time when creating a new header file with non-public API, that header
+must not contain include guards.
+
+
+M11: Naming of enums
+====================
+
+Enums must have a descriptive name. The enum type should be small caps and
+it should not be typedef-ed. Enum contents should be in CAPITAL letters and
+prefixed by the enum type name.
+
+Example:
+
+enum animal_type {
+ ANIMAL_TYPE_FOUR_LEGS,
+ ANIMAL_TYPE_EIGHT_LEGS,
+ ANIMAL_TYPE_TWO_LEGS,
+};
+
+If the enum contents have values (e.g. from specification) the formatting
+should be as follows:
+
+enum animal_type {
+ ANIMAL_TYPE_FOUR_LEGS = 4,
+ ANIMAL_TYPE_EIGHT_LEGS = 8,
+ ANIMAL_TYPE_TWO_LEGS = 2,
+};
+
+M12: Enum as switch variable
+====================
+
+If the variable of a switch is an enum, you must not include a default in
+switch body. The reason for this is: If later on you modify the enum by adding
+a new type, and forget to change the switch accordingly, the compiler will
+complain the new added type hasn't been handled.
+
+Example:
+
+enum animal_type {
+ ANIMAL_TYPE_FOUR_LEGS = 4,
+ ANIMAL_TYPE_EIGHT_LEGS = 8,
+ ANIMAL_TYPE_TWO_LEGS = 2,
+};
+
+enum animal_type t;
+
+switch (t) {
+case ANIMAL_TYPE_FOUR_LEGS:
+ ...
+ break;
+case ANIMAL_TYPE_EIGHT_LEGS:
+ ...
+ break;
+case ANIMAL_TYPE_TWO_LEGS:
+ ...
+ break;
+default: // wrong
+ break;
+}
+
+However if the enum comes from an external header file outside ConnMan
+we cannot make any assumption of how the enum is defined and this
+rule might not apply.
+
+M13: Check for pointer being NULL
+=================================
+
+When checking if a pointer or a return value is NULL, use the
+check with "!" operator.
+
+Example:
+1)
+array = g_try_new0(int, 20);
+if (!array) // Correct
+ return;
+
+2)
+if (!g_at_chat_get_slave(chat)) // Correct
+ return -EINVAL;
+
+3)
+array = g_try_new0(int, 20);
+if (array == NULL) // Wrong
+ return;
+
+
+M14: Always use parenthesis with sizeof
+=======================================
+The expression argument to the sizeof operator should always be in
+parenthesis, too.
+
+Example:
+1)
+memset(stuff, 0, sizeof(*stuff));
+
+2)
+memset(stuff, 0, sizeof *stuff); // Wrong
+
+
+M15: Use void if function has no parameters
+===========================================================
+A function with no parameters must use void in the parameter list.
+
+Example:
+1)
+void foo(void)
+{
+}
+
+2)
+void foo() // Wrong
+{
+}
+
+M16: Don't use hex value with shift operators
+==============================================
+The expression argument to the shift operators should not be in hex.
+
+Example:
+
+1)
+1 << y
+
+2)
+0x1 << y // Wrong
+
+O1: Shorten the name
+====================
+Better to use abbreviation, rather than full name, to name a variable,
+function, struct, etc.
+
+Example:
+supplementary_service // too long
+ss // better
+
+O2: Try to avoid complex if body
+================================
+It's better not to have a complicated statement for if. You may judge its
+contrary condition and return | break | continue | goto ASAP.
+
+Example:
+1)
+if (a) { // worse
+ struct voicecall *v;
+ call = synthesize_outgoing_call(vc, vc->pending);
+ v = voicecall_create(vc, call);
+ v->detect_time = time(NULL);
+ DBG("Registering new call: %d", call->id);
+ voicecall_dbus_register(v);
+} else
+ return;
+
+2)
+if (!a)
+ return;
+
+struct voicecall *v;
+call = synthesize_outgoing_call(vc, vc->pending);
+v = voicecall_create(vc, call);
+v->detect_time = time(NULL);
+DBG("Registering new call: %d", call->id);
+voicecall_dbus_register(v);
diff --git a/doc/config-format.txt b/doc/config-format.txt
new file mode 100644
index 0000000..b16f4e4
--- /dev/null
+++ b/doc/config-format.txt
@@ -0,0 +1,155 @@
+Connman configuration file format
+*********************************
+
+Connman uses configuration files to provision existing services. Connman will
+be looking for its configuration files at STORAGEDIR which by default points
+to /var/lib/connman/. Configuration file names must not include other
+characters than letters or numbers and must have a .config suffix.
+Those configuration files are text files with a simple key-value pair format,
+organized into sections. Values do not comprise leading or trailing whitespace.
+We typically have one file per provisioned network.
+
+If the config file is removed, then Connman tries to remove the
+provisioned services. If an individual service inside a config is removed,
+then the corresponding provisioned service is removed. If a service section
+is changed, then the corresponding service is removed and immediately
+re-provisioned.
+
+
+Global section [global]
+=======================
+
+These files can have an optional global section describing the actual file.
+The two allowed fields for this section are:
+- Name: Name of the network.
+- Description: Description of the network.
+
+
+Service sections [service_*]
+============================
+
+Each provisioned service must start with the [service_*] tag. Replace * with
+an identifier unique to the config file.
+
+Allowed fields:
+- Type: Service type. We currently only support wifi and ethernet.
+- IPv4: The IPv4 address, netmask and gateway. Format of the entry
+ is network/netmask/gateway. The mask length can be used instead
+ of netmask. The gateway can be omitted if necessary.
+ The IPv4 field can also contain the string "off" or "dhcp".
+ If the setting is "off", then no IPv4 address is set to the interface.
+ If the setting is "dhcp", then DHCPv4 address resolution is activated.
+ Example: 192.168.1.2/24/192.168.1.1
+ 192.168.200.100/255.255.255.0/192.168.200.1
+ 10.0.0.2/24
+- IPv6: The IPv6 address, prefix length and gateway. Format of the entry
+ is network/prefixlen/gateway. For IPv6 addresses only prefix length is
+ accepted. The gateway can be omitted if necessary.
+ The IPv6 field can also contain the string "off" or "auto".
+ If the setting is "off", then no IPv6 address is set to the interface.
+ If the setting is "auto", then SLAAC or DHCPv6 is used.
+ Example: 2001:db8::2/64/2001:db8::1
+ 2001:db8::1:2:3:4/64
+- IPv6.Privacy: IPv6 privacy option. Value can be either "disabled",
+ "enabled" or "preferred" (or the misspelled "prefered"). See use_tempaddr
+ variable description in Linux kernel Documentation/networking/ip-sysctl.txt
+ file.
+- MAC: MAC address of the interface where this setting should be applied.
+ The MAC address is optional and if it is missing, then the first found
+ interface is used. The byte values must have prefix 0 added,
+ the bytes must be separated by ":" char and its length must be
+ exactly 2 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 2 + 1 + 2 = 17 characters.
+- Nameservers: Comma separated list of nameservers
+- SearchDomains: Comma separated list of DNS search domains
+- Timeservers: Comma separated list of timeservers
+- Domain: Domain name to be used
+
+If IPv4 address is missing then DHCP is used. If IPv6 address is missing,
+then SLAAC or DHCPv6 is used.
+
+The following options are valid if Type is "wifi"
+- Name: A string representation of an 802.11 SSID. If the SSID field is
+ present, the Name field is ignored.
+- SSID: A hexadecimal representation of an 802.11 SSID. Use this format to
+ encode special characters including starting or ending spaces. If the SSID
+ field is omitted, the Name field is used instead.
+- EAP: EAP type. We currently only support tls, ttls or peap.
+- CACertFile: File path to CA certificate file (PEM/DER).
+- ClientCertFile: File path to client certificate file (PEM/DER).
+- PrivateKeyFile: File path to client private key file (PEM/DER/PFX).
+- PrivateKeyPassphrase: Password/passphrase for private key file.
+- PrivateKeyPassphraseType: We only support the fsid passphrase type for now.
+ This is for private keys generated by using their own filesystem UUID as the
+ passphrase. The PrivateKeyPassphrase field is ignored when this field is set
+ to fsid.
+- Identity: Identity string for EAP.
+- Phase2: Phase2 (inner authentication with TLS tunnel) authentication method.
+ Prefix the value with "EAP-" to indicate the usage of an EAP-based inner
+ authentication method (should only be used with EAP = TTLS).
+- Passphrase: RSN/WPA/WPA2 Passphrase
+- Security: The security type of the network. Possible values are 'psk'
+ (WPA/WPA2 PSK), 'ieee8021x' (WPA EAP), 'none' and 'wep'. When not set, the
+ default value is 'ieee8021x' if an EAP type is configured, 'psk' if a
+ passphrase is present and 'none' otherwise.
+- Hidden: If set to true, then this AP is hidden. If missing or set to false,
+ then AP is not hidden.
+
+
+Examples
+========
+
+This is a configuration file for a network providing EAP-TLS, EAP-TTLS and
+EAP-PEAP services. The respective SSIDs are tls_ssid, ttls_ssid and peap_ssid
+and the file name is example.config.
+
+Please note that the SSID entry is for hexadecimal encoded SSID (e.g. "SSID =
+746c735f73736964"). If your SSID does not contain any exotic character then
+you should use the Name entry instead (e.g. "Name = tls_ssid").
+
+example@example:[~]$ cat /var/lib/connman/example.config
+[global]
+Name = Example
+Description = Example network configuration
+
+[service_tls]
+Type = wifi
+SSID = 746c735f73736964
+EAP = tls
+CACertFile = /home/user/.certs/ca.pem
+ClientCertFile = /home/user/devlp/.certs/client.pem
+PrivateKeyFile = /home/user/.certs/client.fsid.pem
+PrivateKeyPassphraseType = fsid
+Identity = user
+
+[service_ttls]
+Type = wifi
+Name = ttls_ssid
+EAP = ttls
+CACertFile = /home/user/.cert/ca.pem
+Phase2 = MSCHAPV2
+Identity = user
+
+[service_peap]
+Type = wifi
+Name = peap_ssid
+EAP = peap
+CACertFile = /home/user/.cert/ca.pem
+Phase2 = MSCHAPV2
+Identity = user
+
+[service_home_ethernet]
+Type = ethernet
+IPv4 = 192.168.1.42/255.255.255.0/192.168.1.1
+IPv6 = 2001:db8::42/64/2001:db8::1
+MAC = 01:02:03:04:05:06
+Nameservers = 10.2.3.4,192.168.1.99
+SearchDomains = my.home,isp.net
+Timeservers = 10.172.2.1,ntp.my.isp.net
+Domain = my.home
+
+[service_home_wifi]
+Type = wifi
+Name = my_home_wifi
+Passphrase = secret
+IPv4 = 192.168.2.2/255.255.255.0/192.168.2.1
+MAC = 06:05:04:03:02:01
diff --git a/doc/connman.8 b/doc/connman.8
new file mode 100644
index 0000000..7297cf8
--- /dev/null
+++ b/doc/connman.8
@@ -0,0 +1,79 @@
+.\" connman(8) manual page
+.\"
+.\" Copyright (C) 2012 Intel Corporation
+.\"
+.TH CONNMAN "8" "21 August 2012"
+.SH NAME
+ConnMan \- network management daemon
+.SH SYNOPSIS
+.B connmand [\-\-version] | [\-\-help]
+.PP
+.B connmand [\-\-config=<filename>] [\-\-debug=<file1>:<file2>:...] [\-\-device=<interface1>,<interface2>,...] [\-\-nodevice=<interface1>,<interface2>,..] [\-\-wifi=<driver1>,<driver2>,...] [\-\-plugin=<plugin1>,<plugin2>,...] [\-\-noplugin=<plugin1>,<plugin2>,...] [\-\-nodaemon] [\-\-nodnsproxy]
+.SH DESCRIPTION
+The \fIConnMan\fP provides a daemon for managing internet connections
+within devices running the Linux operating system. The Connection Manager is
+designed to be slim and to use as few resources as possible.
+It is a fully modular system that can be extended, through plug-ins,
+to support all kinds of wired or wireless technologies.
+Also, configuration methods, like DHCP and domain name resolving,
+are implemented using plug-ins.
+The plug-in approach allows for easy adaption and modification for various
+use cases.
+.P
+.SH OPTIONS
+The following options are supported:
+.TP
+.I "\-\-version"
+Print the ConnMan software version and exit.
+.TP
+.I "\-\-help"
+Print ConnMan's available options and exit.
+.TP
+.I "\-\-config=<filename>"
+Specify configuration file to set up various settings for ConnMan. If not
+specified, the default value of '<SYSCONFDIR>/connman/main.conf'
+is used; where <SYSCONFDIR> is dependent on your distribution (usually
+it's /etc). See \fBconnman.conf\fP(5) for more information on configuration
+file. The use of config file is optional and sane default values
+are used if config file is missing.
+.TP
+.I "\-\-debug=<file1>:<file2>:..."
+Sets how much information ConnMan sends to the log destination (usually
+syslog's "daemon" facility). If the file options are omitted, then debugging
+information from all the source files are printed. If file options are
+present, then only debug prints from that source file are printed.
+Example: --debug=src/service.c:plugins/wifi.c
+.TP
+.I "\-\-device=<interface1>,<interface2>,..."
+Only manage these network interfaces. By default all network interfaces
+are managed.
+.TP
+.I "\-\-nodevice=<interface1>,<interface2>,..."
+Never manage these network interfaces.
+.TP
+.I "\-\-plugin=<plugin1>,<plugin2>,..."
+Load these plugins only. The option can be a pattern containing
+"*" and "?" characters.
+.TP
+.I "\-\-noplugin=<plugin1>,<plugin2>,..."
+Never load these plugins. The option can be a pattern containing
+"*" and "?" characters.
+.TP
+.I "\-\-wifi=<driver1>,<driver2>,..."
+Wifi driver that WiFi/Supplicant should use. If omitted, then the value
+of "nl80211,wext" is used by default.
+.TP
+.I "\-\-nodaemon"
+Do not daemonize. This is useful for debugging, and directs log output to
+the controlling terminal in addition to syslog.
+.TP
+.I "\-\-nodnsproxy"
+Do not act as a DNS proxy. By default ConnMan will direct all DNS traffic
+to itself by setting nameserver to 127.0.0.1 in \fBresolv.conf\fP(5) file.
+If this is not desired and you want that all programs call directly some
+DNS server, then you can use the --nodnsproxy option.
+If this option is used, then ConnMan is not able to cache the DNS queries
+because the DNS traffic is not going through ConnMan and that can cause
+some extra network traffic.
+.SH SEE ALSO
+.BR connman.conf (5).
diff --git a/doc/connman.conf.5 b/doc/connman.conf.5
new file mode 100644
index 0000000..c1ca75c
--- /dev/null
+++ b/doc/connman.conf.5
@@ -0,0 +1,135 @@
+.\" connman.conf(5) manual page
+.\"
+.\" Copyright (C) 2012 Intel Corporation
+.\"
+.TH "connman.conf" "5" "21 August 2012" ""
+.SH NAME
+main.conf \- ConnMan configuration file
+.SH SYNOPSIS
+/etc/connman/main.conf
+.br
+or
+.br
+\fI<SYSCONFDIR>\fP/connman/main.conf
+.br
+where <SYSCONFDIR> depends on your distribution or build.
+.SH DESCRIPTION
+.P
+.I main.conf
+is a configuration file for ConnMan. The configuration file is
+optional but it can be used to set up various aspects of ConnMan's
+behavior. The location of the file may be changed through use of
+the "\-\-config=" argument for \fBconnman\fP (8).
+.SH "FILE FORMAT"
+.P
+The configuration file format is key file format.
+It consists of sections (groups) of key-value pairs.
+Lines beginning with a '#' and blank lines are considered comments.
+Sections are started by a header line containing the section enclosed
+in '[' and ']', and ended implicitly by the start of the next section
+or the end of the file. Each key-value pair must be contained in a section.
+.P
+Description of sections and available keys follows:
+.SS [General]
+This section is the only mandatory section of the configuration file.
+.TP
+.B InputRequestTimeout=\fPsecs\fP
+Set input request timeout. Default is 120 seconds
+The request for inputs like passphrase will timeout
+after certain amount of time. Use this setting to
+increase the value in case of different user
+interface designs.
+.TP
+.B BrowserLaunchTimeout=\fPsecs\fP
+Set browser launch timeout. Default is 300 seconds
+The request for launching a browser for portal pages
+will timeout after certain amount of time. Use this
+setting to increase the value in case of different
+user interface designs.
+.TP
+.B BackgroundScanning=\fPtrue|false\fP
+Enable background scanning. Default is true.
+Background scanning will start every 5 minutes unless
+the scan list is empty. In that case, a simple backoff
+mechanism starting from 10s up to 5 minutes will run.
+.TP
+.B FallbackTimeservers=\fPserver1,server2,...\fP
+List of Fallback timeservers separated by ",".
+These timeservers are used for NTP sync when there are
+no timeserver set by the user or by the service.
+These can contain mixed combination of fully qualified
+domain names, IPv4 and IPv6 addresses.
+.TP
+.B FallbackNameservers=\fPserver1,server2,...\fP
+List of fallback nameservers separated by "," appended
+to the list of nameservers given by the service. The
+nameserver entries must be in numeric format, host
+names are ignored.
+.TP
+.B DefaultAutoConnectTechnologies=\fPtechnology1,technology2,...\fP
+List of technologies that are marked autoconnectable
+by default, separated by commas ",". The default value
+for this entry when empty is ethernet,wifi,cellular.
+Services that are automatically connected must have been
+set up and saved to storage beforehand.
+.TP
+.B PreferredTechnologies=\fPtechnology1,technology2,...\fP
+List of preferred technologies from the most preferred
+one to the least preferred one separated by commas ",".
+Services of the listed technology type will be tried one
+by one in the order given, until one of them gets connected
+or they are all tried. A service of a preferred technology
+type in state 'ready' will get the default route when
+compared to another preferred type further down the list
+with state 'ready' or with a non-preferred type; a service
+of a preferred technology type in state 'online' will get
+the default route when compared to either a non-preferred
+type or a preferred type further down in the list.
+.TP
+.B NetworkInterfaceBlacklist=\fPinterface1,interface2,...\fP
+List of blacklisted network interfaces separated by ",".
+Found interfaces will be compared to the list and will
+not be handled by connman, if their first characters
+match any of the list entries. Default value is
+vmnet,vboxnet,virbr,ifb.
+.TP
+.B AllowHostnameUpdates=\fPtrue|false\fP
+Allow connman to change the system hostname. This can
+happen for example if we receive DHCP hostname option.
+Default value is true.
+.TP
+.B SingleConnectedTechnology=\fPtrue|false\fP
+Keep only a single connected technology at any time. When a new
+service is connected by the user or a better one is found according
+to PreferredTechnologies, the new service is kept connected and all
+the other previously connected services are disconnected. With this
+setting it does not matter whether the previously connected services
+are in 'online' or 'ready' states, the newly connected service is
+the only one that will be kept connected. A service connected by the
+user will be used until going out of network coverage. With this
+setting enabled applications will notice more network breaks than
+normal. Default value is false.
+.TP
+.B TetheringTechnologies=\fPtechnology1,technology2,...\fP
+List of technologies that are allowed to enable tethering separated by ",".
+The default value is wifi,bluetooth,gadget. Only those technologies listed
+here are used for tethering. If one wants to tether ethernet,
+then add "ethernet" in the list.
+NOTE that if ethernet tethering is enabled, then a DHCP server is
+started on all ethernet interfaces. Tethered ethernet should
+never be connected to corporate or home network as it will disrupt
+normal operation of these networks. Due to this ethernet is not
+tethered by default. Do not activate ethernet tethering unless you
+really know what you are doing.
+.TP
+.B PersistentTetheringMode=\fPtrue|false\fP
+Restore earlier tethering status when returning from offline mode,
+re-enabling a technology, and after restarts and reboots.
+Default value is false.
+.TP
+.B Enable6to4=\fPtrue|false\fP
+Automatically enable Anycast 6to4 if possible. This is not recommended, as the
+use of 6to4 will generally lead to a severe degradation of connection quality.
+See RFC6343. Default value is false (as recommended by RFC6343 section 4.1).
+.SH "SEE ALSO"
+.BR Connman (8)
diff --git a/doc/connmanctl.1 b/doc/connmanctl.1
new file mode 100644
index 0000000..b71c6e6
--- /dev/null
+++ b/doc/connmanctl.1
@@ -0,0 +1,190 @@
+.TH connmanctl 1 07/31/2012 "" "User Commands for Connman CLI"
+.SH
+NAME
+connmanctl \- Connman CLI
+.SH
+SYNOPSIS
+.BR connmanctl " ["
+.BR enable " <technology> | "
+.BR offlinemode "] ["
+.BR disable " <technology> | "
+.BR offlinemode "] ["
+.BR technologies "] ["
+.BR state "] ["
+.BR services " [\-\-properties <service>]] ["
+.BR scan " <technology>] ["
+.BR connect " <service>] ["
+.BR config " <service> \-\-<option> ARGS...] ["
+.BR help " | \-\-help]"
+.PP
+.SH
+DESCRIPTION
+Connmanctl is a Connman command line interface which can be run in two modes:
+a plain synchronous command input, and an asynchronous interactive shell.
+To run a specific command the user may enter connmanctl <command> [options]
+[args], or enter connmanctl; in this case, the program will drop into the
+interactive shell.
+.PP
+Connmantl can handle most simple network connections. It is able to enable/
+disable any technology that exists on the system, display a list of
+services available, connect to/disconnect from any unsecured networks,
+show properties of the system, the technologies, and any individual
+service, and configure all of the properties. It is also able to monitor
+changes in the properties of the services, technologies, and the system.
+.PP
+In the interactive shell, all of the same commands can be used. It
+provides quicker usage when needing to use connmanctl more extensively.
+.SH
+COMMANDS AND OPTIONS
+.TP
+.BR "help | \-\-help | " "(no arguments)"
+Shows the abbreviated help menu in the terminal.
+.PP
+.TP
+.BR enable " <technology>"
+Enables the given technology type (e.g. ethernet, wifi, 3g, etc.)
+Turns power on to the technology, but doesn't connect unless
+there is a service with autoconnect set to True.
+.PP
+.TP
+.BR disable " <technology>"
+Disables the given technology type. Turns power off to the
+technology and disconnects if it is already connected.
+.PP
+.TP
+.B enable offlinemode
+Enables offline mode. Disconnects and powers down all
+technologies system-wide, however each technology can be powered
+back on individually.
+.PP
+.TP
+.B disable offlinemode
+Disables offline mode. Technologies are powered back on according
+to their individual policies.
+.PP
+.TP
+.B technologies
+Shows a list of all technology types existing on the system and
+their properties. See the properties section of the Technology
+API for explanations of each property.
+.PP
+.TP
+.B state
+Shows the system properties. Includes ths online state of the
+system, offline mode, and session mode.
+.PP
+.TP
+.BR scan " <technology>"
+Scans for new services on the given technology.
+.PP
+.TP
+.B services
+Shows a list of all available service names. This includes the
+names of wifi networks, the wired ethernet connection, names of
+bluetooth devices, etc. These are the names used when a
+<service> command is called for. The service name
+(e.g. Joes-wifi), the service path (e.g.
+wifi_6834534139723_managed_none), or the full service path (e.g.
+/net/connman/Service/wifi_5467631...) are all accepted as valid
+input. An asterisk in front of the service indicates that the
+service is favorited, and a "C" indicates a service that is
+already connected.
+.PP
+.TP
+.BR "services \-\-properties" " <service>"
+Shows a list of all properties for that service. See the
+properties section of the Service API for explanations of each
+property.
+.PP
+.TP
+.BR connect " <service>"
+Connects to the given service if it is unsecured.
+.PP
+.TP
+.BR disconnect " <service>"
+Disconnects from the given service.
+.PP
+.TP
+.BR config " <service> " \-\-<option>
+Configures a writable property of the given service to the
+value(s) entered after --<option>.
+.PP
+.TP
+.BR monitor " [\-\-<option>]"
+Listens for and displays DBus signals sent by Connman. The option indicates
+which signals you want to subscribe to. If no option is entered, it displays
+all signals from all interfaces.
+.PP
+.SS
+Config Options:
+.PP
+.TP
+.B \-\-autoconnect=y/n
+Sets the autoconnect property of the service.
+.PP
+.TP
+.B \-\-ipv4
+Configures the IPv4 settings for the service. Enter the settings
+in the order "Method", "Address", "Netmask", then "Gateway"
+after the argument. See the properties section of the Service
+API for more information on these settings and the values
+accepted for them. It also displays a list of changes to both the
+IPv4 settings, and incidental changes to other values related to
+it.
+.PP
+.TP
+.B \-\-ipv6
+Configures the IPv6 settings for the service. Enter the settings
+in the order "Method", "Address", "PrefixLength", "Gateway", then
+"Privacy". See the properties section of the Service API for more
+information on these settings and the values accepted for them.
+It also displays a list of entered changes to the IPv6 settings,
+and incidental changes to other values related to it.
+.PP
+.TP
+.B \-\-nameservers
+Adds to the list of manually configured domain name servers.
+Enter the name servers after the argument separated by spaces.
+.PP
+.TP
+.B \-\-timeservers
+Adds to the list of manually configured time servers. Enter the
+time servers after the argument separated by spaces.
+.PP
+.TP
+.B \-\-domains
+Adds to the list of manually configured search domains. Enter
+the domains after the argument, separated by spaces.
+.PP
+.TP
+.B \-\-proxy
+Configures the IPv6 settings for the service. Enter the settings in the
+order "Method", "URL". If the Method is set to "direct", no other arguments
+are taken. If the Method is set to "auto", the URL is optional. To set the
+Servers and Excludes manually, enter "manual" followed by "servers" with a
+list of servers separated by spaces. Then, optionally, the word "excludes"
+followed by a list of excludes separated by spaces. e.g. "./connmanctl config
+joes-wifi \-\-proxy manual servers serv1 serv2 serv3 excludes excl1 excl2"
+.PP
+.SS
+Monitor Options:
+.PP
+.TP
+.B \-\-services
+Listens for and displays the PropertyChanged signal from the Service interface.
+Also displays the service name (e.g. Joes-wifi) that the property is part of.
+More information, including a list of possible properties can be found in the
+Service API.
+.PP
+.TP
+.B \-\-tech
+Listens for and displays the PropertyChanged signal from the Technology
+interface. More information, including a list of possible properties can be
+found in the Technology API.
+.PP
+.TP
+.B \-\-manager
+Listens for and displays the PropertyChanged, ServicesChanged, TechnologyAdded,
+and TechnologyRemoved signals from the Manager interface. More information on
+these signals and a list of possible properties can be found in the Manager API.
+.PP
diff --git a/doc/counter-api.txt b/doc/counter-api.txt
new file mode 100644
index 0000000..32411d5
--- /dev/null
+++ b/doc/counter-api.txt
@@ -0,0 +1,70 @@
+Counter hierarchy
+=================
+
+Service unique name
+Interface net.connman.Counter
+Object path freely definable
+
+Methods void Release()
+
+ This method gets called when the service daemon
+ unregisters the counter. A counter can use it to do
+ cleanup tasks. There is no need to unregister the
+ counter, because when this method gets called it has
+ already been unregistered.
+
+ void Usage(object service, dict home, dict roaming)
+
+ This signal indicates a change in the counter values
+ for the service object. The counter is reset by calling
+ the service ResetCounters method.
+
+ When registering a new counter this method will be
+ called once with all details for "home" and "roaming"
+ counters filled in. Every further method call will
+ only include the changed values.
+
+ When "home" counter is active, then "roaming" counter
+ will contain an empty dictionary and vise-versa.
+
+ The dictionary argument contains the following entries:
+
+ RX.Packets
+
+ Total number of packets received.
+
+ TX.Bytes
+
+ Total number of packets sent.
+
+ RX.Bytes
+
+ Total number of bytes received.
+
+ TX.Bytes
+
+ Total number of bytes sent.
+
+ RX.Errors
+
+ Total number of erronous packets
+ received.
+
+ TX.Errors
+
+ Total number of erronous packets
+ sent.
+
+ RX.Dropped
+
+ Total number of dropped packets
+ while receiving.
+
+ TX.Dropped
+
+ Total number of dropped packets
+ while sending.
+
+ Time
+
+ Total number of seconds online.
diff --git a/doc/ipconfig-api.txt b/doc/ipconfig-api.txt
new file mode 100644
index 0000000..080fdac
--- /dev/null
+++ b/doc/ipconfig-api.txt
@@ -0,0 +1,41 @@
+IP configuration handling
+*************************
+
+
+IP basics
+=========
+
+The core IP handling is designed around network interfaces or more precisely
+what the Linux kernel handles as struct net_device. Via RTNL every interface
+is tracked and an IP device created for it.
+
+ +--------+ +---- eth0 -----+
+ | | | |
+ | RTNL +-----+---->| IP device |
+ | | | | |
+ +--------+ | +---------------+
+ |
+ | +---- wlan0 ----+
+ | | |
+ +---->| IP device |
+ | |
+ +---------------+
+
+The IP device tracks link configuration, IP address setting and routing
+information for that interface. Every IP device also contains a configuration
+element. That element contains an operation table for callbacks based on
+different events.
+
+ struct connman_ipconfig_ops {
+ void (*up) (struct connman_ipconfig *);
+ void (*down) (struct connman_ipconfig *);
+ void (*lower_up) (struct connman_ipconfig *);
+ void (*lower_down) (struct connman_ipconfig *);
+ void (*ip_bound) (struct connman_ipconfig *);
+ void (*ip_release) (struct connman_ipconfig *);
+ };
+
+All configuration objects created directly by RTNL are tightly bound to the
+IP device. They will trigger DHCP or other configuration helpers.
+
+
diff --git a/doc/manager-api.txt b/doc/manager-api.txt
new file mode 100644
index 0000000..31e137c
--- /dev/null
+++ b/doc/manager-api.txt
@@ -0,0 +1,307 @@
+Manager hierarchy
+=================
+
+Service net.connman
+Interface net.connman.Manager
+Object path /
+
+Methods dict GetProperties()
+
+ Returns all global system properties. See the
+ properties section for available properties.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void SetProperty(string name, variant value)
+
+ Changes the value of the specified property. Only
+ properties that are listed as read-write are
+ changeable. On success a PropertyChanged signal
+ will be emitted.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.InvalidProperty
+
+ array{object,dict} GetTechnologies()
+
+ Returns a list of tuples with technology object
+ path and dictionary of technology properties.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ array{object,dict} GetServices()
+
+ Returns a sorted list of tuples with service
+ object path and dictionary of service properties.
+
+ This list will not contain sensitive information
+ like passphrases etc.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ array{object,dict} GetPeers() [experimental]
+
+ Returns a sorted list of tuples with peer object path
+ and dictionary of peer properties
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ object ConnectProvider(dict provider) [deprecated]
+
+ Connect to a VPN specified by the given provider
+ properties.
+
+ When successful this method will return the object
+ path of the VPN service object.
+
+ This method can also be used to connect to an
+ already existing VPN.
+
+ This method call will only return in case of an
+ error or when the service is fully connected. So
+ setting a longer D-Bus timeout might be a really
+ good idea.
+
+ When 'SessionMode' property is enabled, this method
+ call is disallowed.
+
+ This API is deprecated and should not be used.
+ The VPN configuration API is provided by ConnMan
+ VPN daemon and user should use that one instead.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void RemoveProvider(object path) [deprecated]
+
+ Remove a VPN specified by the object path.
+
+ void RegisterAgent(object path)
+
+ Register new agent for handling user requests.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void UnregisterAgent(object path)
+
+ Unregister an existing agent.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void RegisterCounter(object path, uint32 accuracy, uint32 period) [experimental]
+
+ Register a new counter for user notifications.
+
+ The accuracy is specified in kilo-bytes and defines
+ a threshold for counter updates. Together with the
+ period value it defines how often user space needs
+ to be updated. The period value is in seconds.
+
+ This interface is not meant for time tracking. If
+ the time needs to be tracked down to the second, it
+ is better to have a real timer running inside the
+ application than using this interface.
+
+ Also getting notified for every kilo-byte is a bad
+ choice (even if the interface supports it). Something
+ like 10 kilo-byte units or better 1 mega-byte seems
+ to be a lot more reasonable and better for the user.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void UnregisterCounter(object path) [experimental]
+
+ Unregister an existing counter.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ object CreateSession(dict settings, object notifier) [experimental]
+
+ Create a new session for the application. Every
+ application can create multiple session with
+ different settings. The settings are described
+ as part of the session interface.
+
+ The notifier allows asynchronous notification about
+ session specific changes. These changes can be
+ for online/offline state or IP address changes or
+ similar things the application is required to
+ handle.
+
+ Every application should at least create one session
+ to inform about its requirements and it purpose.
+
+ void DestroySession(object session) [experimental]
+
+ Remove the previously created session.
+
+ If an application exits unexpectatly the session
+ will be automatically destroyed.
+
+ object path, dict, fd RequestPrivateNetwork(dict options)
+ [experimental]
+
+ Request a new Private Network, which includes the
+ creation of a tun/tap interface, and IP
+ configuration, NAT and IP forwarding on that
+ interface.
+ An object path, a dictionnary and a file descriptor
+ with IP settings are returned.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.NotSupported
+
+ void ReleasePrivateNetwork(object path) [experimental]
+
+ Releases a private network.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void RegisterPeerService(dict specification, boolean master)
+ [experimental]
+
+ Registers a local P2P Peer service
+
+ Even if p2p techonology is not available, it will be
+ possible to register peer services, since a p2p
+ enabled WiFi device might appear at anytime. The
+ registered peer services will automatically be enabled
+ for the p2p WiFi device; the application does not need
+ to do any re-registration.
+
+ A Peer service belongs to the process that registers
+ it, thus if that process dies, its Peer services will
+ be destroyed as well.
+
+ The specification dict follows the format described
+ in the Peer API document.
+
+ ConnMan will be able to determine in most cases
+ whether to be the P2P Group Owner or not. If the
+ service for some reason must belong to a group that
+ this device manages, the "master" property can be
+ set. Do not enable the "master" property unless it
+ is absolutely sure that this is needed for the
+ provided peer service.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.AlreadyExists
+ [service].Error.NotSupported
+
+ void UnregisterPeerService(dict specification) [experimental]
+
+ Unregisters an existing local P2P Peer service
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.NotRegistered
+
+Signals TechnologyAdded(object path, dict properties)
+
+ Signal that is sent when a new technology is added.
+
+ It contains the object path of the technology and
+ also its properties.
+
+ TechnologyRemoved(object path)
+
+ Signal that is sent when a technology has been removed.
+
+ The object path is no longer accessible after this
+ signal and only emitted for reference.
+
+ ServicesChanged(array{object, dict}, array{object})
+
+ Signals a list of services that have been changed
+ via the first array. And a list of service that
+ have been removed via the second array.
+
+ The list of added services is sorted. The dictionary
+ with the properties might be empty in case none of
+ the properties have changed. Or only contains the
+ properties that have changed.
+
+ For newly added services the whole set of properties
+ will be present.
+
+ The list of removed services can be empty.
+
+ This signal will only be triggered when the sort
+ order of the service list or the number of services
+ changes. It will not be emitted if only a property
+ of the service object changes. For that it is
+ required to watch the PropertyChanged signal of
+ the service object.
+
+ PeersChanged(array{object, dict}, array{object}) [experimental]
+
+ Signals a list of peers that have been changed via the
+ first array. And a list of peer that have been removed
+ via the second array.
+
+ The list of changed peers is sorted. The dictionary
+ with the properties might be empty in case none of the
+ properties have changed. Or only contains the
+ properties that have changed.
+
+ For newly added peers the whole set of properties will
+ be present.
+
+ The list of removed peers can be empty.
+
+ This signal will only be triggered when the sort order
+ of the peer list or the number of peers changes. It
+ will not be emitted if only a property of the peer
+ object changes. For that it is required to watch the
+ PropertyChanged signal of the peer object.
+
+ PropertyChanged(string name, variant value)
+
+ This signal indicates a changed value of the given
+ property.
+
+Properties string State [readonly]
+
+ The global connection state of a system. Possible
+ values are "offline", "idle", "ready" and "online".
+
+ If the device is in offline mode, the value "offline"
+ indicates this special global state. It can also be
+ retrieved via the OfflineMode property, but is kept
+ here for consistency and to differentiate from "idle".
+
+ However when OfflineMode property is true, the State
+ property can still be "idle", "ready" or "online"
+ since it is possible by the end user to re-enable
+ individual technologies like WiFi and Bluetooth while
+ in offline mode.
+
+ The states "idle", "ready" and "online" match to
+ states from the services. If no service is in
+ either "ready" or "online" state it will indicate
+ the "idle" state.
+
+ If at least one service is in "ready" state and no
+ service is in "online" state, then it will indicate
+ the "ready" state.
+
+ When at least one service is in "online" state,
+ this property will indicate "online" as well.
+
+ boolean OfflineMode [readwrite]
+
+ The offline mode indicates the global setting for
+ switching all radios on or off. Changing offline mode
+ to true results in powering down all devices. When
+ leaving offline mode the individual policy of each
+ device decides to switch the radio back on or not.
+
+ During offline mode, it is still possible to switch
+ certain technologies manually back on. For example
+ the limited usage of WiFi or Bluetooth devices might
+ be allowed in some situations.
+
+ boolean SessionMode [readwrite] [experminental][deprecated]
+
+ This property exists only for compatibility reasons
+ and does not affect ConnMan in any way.
+
+ The default value is false.
diff --git a/doc/overview-api.txt b/doc/overview-api.txt
new file mode 100644
index 0000000..f126887
--- /dev/null
+++ b/doc/overview-api.txt
@@ -0,0 +1,435 @@
+Application programming interface
+*********************************
+
+
+Service basics
+==============
+
+Inside Connection Manager there exists one advanced interface to allow the
+user interface an easy access to networking details and user chosen
+preferences. This is the service list and interface.
+
+The basic idea is that Connection Manager maintains a single flat and sorted
+list of all available, preferred or previously used services. A service here
+can be either a Ethernet device, a WiFi network or a remote Bluetooth device
+(for example a mobile phone).
+
+This list of service is sorted by Connection Manager and there is no need
+for the user interface to implement its own sorting. User decisions will
+need to be done via Connection Manager and it is then responsible to update
+the order of services in this list.
+
+ +---------------------------------------+
+ | Ethernet |
+ +---------------------------------------+
+ | Bluetooth phone |
+ +---------------------------------------+
+ | Guest (strength 90, none) |
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) |
+ +---------------------------------------+
+ | Other AP (strength 70, rsn) |
+ +---------------------------------------+
+ | Friends AP (strength 70, wep) |
+ +---------------------------------------+
+
+If none of the services has been used before the sorting order will be done
+with these priorities:
+
+ 1. Ethernet (lower index numbers first)
+ 2. Bluetooth (last used devices first)
+ 3. GSM/UTMS/3G (if SIM card is present, activated and not roaming)
+ 3. WiFi (signal strength first, then more secure network
+ first)
+
+The Ethernet devices are always sorted first since they are physically built
+into the system and will be always present. In cases they are switched off
+manually they will not be showing in this list.
+
+Since every Bluetooth device has to be configured/paired first, the user
+already made a choice here that these are important. Connection Manager will
+only show devices with PAN or DUN profile support. While Bluetooth devices
+do have a signal strength, it is mostly unknown since background scanning
+in Bluetooth is too expensive. The choice here is to sort the last used
+Bluetooth device before the others.
+
+WiFi networks closer in the proximity should be shown first since it is more
+likely they are selected. The signal strength value is normalized to 0-100
+(effectively a percentage) and allows an easy sorting.
+
+WiFi networks with the same signal strength are then sorted by their security
+setting. WPA2 encrypted networks should be preferred over WPA/WEP and also
+unencrypted ones. After that they will be sorted by the SSID in alphabetical
+order.
+
+In the case the WiFi network uses WPS for setup and it is clearly detectable
+that a network waits for Connection Manager to connect to it (for example via
+a push-to-connect button press on the AP), then this network should be shown
+first before any other WiFi networks. The reason here is that the user already
+made a choice via the access point. However this depends on technical details
+if it is possible to detect these situations.
+
+
+Service order
+=============
+
+All unused services will have the internal order number of 0 and then will
+be sorted according to the rules above. For Bluetooth the user already made
+the decision to setup their device and by that means select it. However
+until the first connection attempt it might have been setup for total
+different reason (like audio usage) and thus it still counts as unused from
+a networking point of view.
+
+Selecting the "My WiFi AP" and successfully connecting to it makes it a
+favorite device and it will become an order number bigger than 0. All
+order numbers are internally. They are given only to service that are marked
+as favorite. For WiFi and Bluetooth a successful connection attempt makes
+these services automatically a favorite. For Ethernet the plugging of a cable
+makes it a favorite. Disconnecting from a network doesn't remove the favorite
+setting. It is a manual operation and is equal to users pressing
+delete/remove button.
+
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) | order=1 - favorite=yes
+ +---------------------------------------+
+ | Ethernet | order=0
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+Ethernet is special here since the unplugging of the network cable will
+remove the service from the list
+
+ +---------------------------------------+
+ | Ethernet with cable | order=1 - favorite=yes
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+This means that all services with an order > 0 have favorite=yes and all
+others have favorite=no setting. The favorite setting is exposed via a
+property over the service interface. As mentioned above, the order number
+is only used internally.
+
+Within Connection Manager many services can be connected at the same time and
+also have an IP assignment. However only one can have the default route. The
+service with the default route will always be sorted at the top of the
+list.
+
+ +---------------------------------------+
+ | Ethernet | order=2 - connected=yes
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) | order=1 - connected=yes
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+To change the default connection to your access point, the user needs to
+manually drag the access point service to the top of the list. Connection
+Manager will not take down default routes if there is no reason to do so.
+A working connection is considered top priority.
+
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) | order=2 - connected=yes
+ +---------------------------------------+
+ | Ethernet | order=1 - connected=yes
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+Another possible user interaction would be to disconnect the Ethernet service
+and in this case the service falls back down in the list.
+
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) | order=1 - connected=yes
+ +---------------------------------------+
+ | Ethernet | order=1 - connected=no
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+If the service on the top of the list changes the default route will be
+automatically adjusted as needed. The user can trigger this by disconnecting
+from a network, if the network becomes unavailable (out of range) or if the
+cable gets unplugged.
+
+As described above, the pure case of disconnecting from a network will not
+remove the favorite setting. So previously selected networks are still present
+and are sorted above all others.
+
+ +---------------------------------------+
+ | Ethernet | order=2 - connected=yes
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) | order=1 - connected=no
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+Unplugging the Ethernet cable will remove the Ethernet service.
+
+ +---------------------------------------+
+ | My WiFi AP (strength 80, rsn) | order=1 - connected=no
+ +---------------------------------------+
+ | Guest (strength 90, none) | order=0
+ +---------------------------------------+
+ | |
+
+
+Service tweaks
+==============
+
+The interfaces of Connection Manager will always export all services that are
+currently known. The Ethernet devices with no cable plugged are actually not
+included in this list. They will only show up once a carrier is detected.
+
+The service interface is not meant for basic device configuration task. So
+switching a device on and off (via RFKILL for example) should be done via
+the technology interface. See "Technology interfaces" chapter in this document.
+
+Due to limited screen size of small devices and the big amount of WiFi
+access points that are deployed right now it might be sensible to not show
+certain WiFi networks in the user interface.
+
+The choice to hide a WiFi network from the user interface should be purely
+done by the signal strength. The optimal cut-off value here still has to be
+determined, but in the end that is a user interface policy.
+
+
+Service naming
+==============
+
+Every service will have a name property that allows the user interface to
+display them directly. All names will be already converted into UTF-8. It
+derives from the netork details.
+
+In case of WiFi this will be the SSID value. The SSID is a binary array and
+will be converted into printable form. Unprintable characters are replaced
+with spaces.
+
+In addition to WiFi naming, WiFi networks are subject to a grouping policy
+performed around SSID and security type. This means that one service will be
+seen for N WiFi networks providing the same SSID and the same security metod.
+For instance, if 5 APs are servicing an SSID called "TEST" with WPA2
+authentication and 3 APs are servicing the same SSID with open authentication
+method, the user will see only two services listed with the name "TEST"
+differentiated by their security type, which are "psk" and "none". Such
+policy is also applied to hidden networks, where hidden services will have an
+empty name and will be differentiated by the security type. The user has then
+to select the one with the right security and the Agent API will request any
+required information such as the SSID for the network (See "Application
+basics" below).
+
+For Bluetooth the device alias is used. The alias is different since it
+can be overwritten by the user via the Bluetooth service. The identification
+is still done based on its address, but the display name might change. In
+most cases the alias is equal to the Bluetooth remote friendly name.
+
+For Ethernet device no name will be provided. The type property will indicate
+that this service is Ethernet and then it is up to the user interface to
+provide a proper localized name for it.
+
+
+Service states
+==============
+
+Every service can have multiple states that indicate what is currently
+going on with it. The choice to have multiple states instead of a simple
+connected yes/no value comes from the fact that it is important to let the
+user interface name if a service is in process of connecting/disconnecting.
+
+The basic state of every service is "idle". This means that this service
+is not in use at all at the moment. It also is not attempting to connect
+or do anything else.
+
+The "association" state indicates that this service tries to establish a
+low-level connection to the network. For example associating/connecting
+with a WiFi access point.
+
+With the "configuration" state the service indicates that it is trying
+to retrieve/configure IP settings.
+
+The "ready" state signals a successful connected device. This doesn't mean
+it has the default route, but basic IP operations will succeed.
+
+With the "disconnect" state a service indicates that it is going to terminate
+the current connection and will return to the "idle" state.
+
+In addition a "failure" state indicates a wrong behavior. It is similar to
+the "idle" state since the service is not connected.
+
+ +---------------+
+ | idle |<-------------------------------+
+ +---------------+ |
+ | |
+ | +-------------+ |
+ +----------------------| failure | |
+ | service.Connect() +-------------+ |
+ V A |
+ +---------------+ | |
+ | association |-----------------+ |
+ +---------------+ error | |
+ | | |
+ | success | |
+ V | |
+ +---------------+ | |
+ | configuration |-----------------+ |
+ +---------------+ error |
+ | |
+ | success |
+ V |
+ +---------------+ |
+ | ready | |
+ +---------------+ |
+ | |
+ | success |
+ | |
+ V |
+ +---------------+ |
+ | online |<----------------+ |
+ +---------------+ | |
+ | | |
+ | service.Disconnect() | |
+ V | |
+ +---------------+ | |
+ | disconnect |-----------------+ |
+ +---------------+ error |
+ | |
+ +------------------------------------------+
+
+The different states should no be used by the user interface to trigger
+advanced actions. The state transitions are provided for the sole purpose
+to give the user feedback on what is currently going on. Especially in
+cases where networks are flaky or DHCP servers take a long time these
+information are helpful for the user.
+
+Some services might require special authentication procedure like a web
+based confirmation. The LoginRequired property should be used to check
+for this.
+
+
+Application basics
+==================
+
+All applications should use D-Bus to communicate with Connection Manager. The
+main entry point is the manager object. Currently the manager object is
+located at "/", but this might change to allow full namespacing of the API
+in the future. The manager interface is documented in manager-api.txt and
+contains a set of global properties and methods.
+
+A simple way to retrieve all global properties looks like this:
+
+ bus = dbus.SystemBus()
+
+ manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+ properties = manager.GetProperties()
+
+Changing a global property is also pretty simple. For example enabling the
+so called offline mode (aka flight mode) it is enough to just set that
+property:
+
+ manager.SetProperty("OfflineMode", dbus.Boolean(1))
+
+The manager object contains references to profiles, devices, services and
+connections. All these references represent other interfaces that allow
+detailed control of Connection Manager. The profiles and devices interfaces
+are more for advanced features and most applications don't need them at all.
+
+The services are represented as a list of object paths. Every of these object
+paths contains a service interface. A service is a global collection for
+Ethernet devices, WiFi networks, Bluetooth services etc. and all these
+different types are treated equally.
+
+Every local Ethernet card will show up as exactly one service. WiFi networks
+will be grouped by SSID, mode and security setting. Bluetooth PAN and DUN
+service will show up per remote device. This creates a simple list that can
+be directly displayed to the users since these are the exact details users
+should care about.
+
+ properties = manager.GetProperties()
+
+ for path in properties["Services"]:
+ service = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Service")
+
+ service_properties = service.GetProperties()
+
+The service interface is documented in service-api.txt and contains common
+properties valid for all services. It also contains method to connect or
+disconnect a specific service. This allows users to select a specific service.
+Connection Manager can also auto-connect services based on his policies or
+via external events (like plugging in an Ethernet cable).
+
+Connecting (or disconnecting) a specific service manually is as simple as
+just telling it to actually connect:
+
+ service.Connect() or service.Disconnect()
+
+It is possible to connect multiple services if the underlying technology
+allows it. For example it would be possible to connect to a WiFi network
+and a Bluetooth service at the same time. Trying to connect to a second WiFi
+network with the same WiFi hardware would result in an automatic disconnect
+of the currently connected network. Connection Manager handles all of this
+for the applications in the background. Trying to connect an Ethernet service
+will result in an error if no cable is plugged in. All connection attempts
+can fail for one reason or another. Application should be able to handle
+such errors and will also be notified of changes via signals.
+
+Connection Manager will interact with an agent via the Agent API to confirm
+certain transactions with the user. If Connection Manager needs extra
+information, it will ask the user for exactly the information it requires,
+i.e. passphrase, network's name (for hidden WiFi networks) and more depending
+on the use case (e.g. WPS, EAP). Therefore an application environment using
+Connection Manager should implement one dedicated Connection Manager agent
+according to the Agent API in order to interact with the user. Please see
+agent-api.txt for implementation details.
+
+To monitor the current status of a service the state property can be used. It
+gives detailed information about the current progress.
+
+ properties = service.GetProperties()
+
+ print properties["State"]
+
+All state changes are also sent via the PropertyChanged signal on the
+service interface. This allows asynchronous monitoring without having to poll
+Connection Manager for changes.
+
+
+Technology interfaces
+=====================
+
+When ConnMan is started first time, all technologies except ethernet are
+powered off by default. The reason is that the user needs to decide which
+technologies are relevant to him and what bearers the user wants to use.
+User can use the Technology Powered property to turn on or off a given
+technology. See doc/technology-api.txt document for details.
+
+User can activate offline (flight) mode via Manager OfflineMode property.
+While in offline mode, all the technologies including ethernet are
+powered off. During the offline mode, the user can temporarily activate
+individual technologies by using the Technology Powered property or by
+using the rfkill command or Fn-Fx key combination found in some laptops.
+
+If the host supports rfkill switch, then all the radios can be turned off
+by the kernel when the switch is activated. ConnMan will notice this and
+remove corresponding technologies from D-Bus. Technologies cannot be
+activated while rfkill switch is turned on. When rfkill switch is turned
+off (radios are activated), then ConnMan restores the original Powered
+status for each activated technology.
+
+User can use the rfkill command from command line or indirectly via
+some UI component to activate/deactivate individual radios found in
+the host. ConnMan will listen these rfkill events and set the Powered
+property accordingly. ConnMan will not save the rfkill status it has
+received. This means that after restarting ConnMan, the original and
+saved technology status is used when deciding which technologies should
+be powered. If the user uses the Technology D-Bus API to set the Powered
+property, then that information is saved and used when ConnMan is restarted.
diff --git a/doc/peer-api.txt b/doc/peer-api.txt
new file mode 100644
index 0000000..cc094ff
--- /dev/null
+++ b/doc/peer-api.txt
@@ -0,0 +1,102 @@
+Peer hierarchy [EXPERIMENTAL]
+=============================
+
+Service net.connman
+Interface net.connman.Peer
+Object path [variable prefix]/{peer0,peer1,...}
+
+Methods dict GetProperties() [deprecated]
+
+ Returns properties for the peer object. See the
+ properties sections for available properties.
+
+ Usage of this method is highly discouraged. Use
+ the Manager.GetPeers() method instead.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void Connect() [experimental]
+
+ Connect this peer.
+
+ This method call will only return in case of an error
+ or when the peer is fully connected. So setting a
+ longer D-Bus timeout might be a really good idea.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void Disconnect() [experimental]
+
+ Disconnect this peer. If the peer is not connected, an
+ error message will be generated.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+Signals PropertyChanged(string name, variant value) [experimental]
+
+ This signal indicates a changed value of the given
+ property.
+
+Properties string State [readonly] [experimental]
+
+ The peer state information.
+
+ Valid state are "idle", "failure", "association",
+ "configuration", "ready" and "disconnect".
+
+ string Name [readonly] [experimental]
+
+ Name of the peer.
+
+ dict IPv4 [readonly] [experimental]
+
+ string Local [readonly]
+
+ The current peer's local configured IPv4
+ address.
+
+ string Remote [readonly]
+
+ The current peer's remote configured IPv4
+ address.
+
+ array{dict} Services [readonly] [experimental]
+
+ Array of P2P service specifications consisting of
+ either UpnpService and UpnpVersion or BonjourQuery
+ and BonjourResponse, but not a mix of these. The
+ dict members have the following format:
+
+ String UpnpService [readonly]
+
+ The UPNP service URI.
+
+ int32 UpnpVersion [readonly]
+
+ The UPNP version in use.
+
+ array{byte} BonjourQuery [readonly]
+
+ The bonjour service query data, provided
+ through a byte array.
+
+ Note: a Peer object will never show this
+ information. When scanning, a device gets
+ only the bonjour response data. However,
+ this information is mandatory when a bonjour
+ service is given through Manager API
+ RegisterPeerService and
+ UnregisterPeerService.
+
+ array{byte} BonjourResponse [readonly]
+
+ The bonjour service response data, provided
+ through a byte array.
+
+ Note: this will be the only bonjour related
+ information a Peer object will show.
+
+ array{byte} WiFiDisplayIEs [readonly]
+
+ The TLV formated byte array representing the
+ WiFi Display Informations Elements.
diff --git a/doc/plugin-api.txt b/doc/plugin-api.txt
new file mode 100644
index 0000000..616938b
--- /dev/null
+++ b/doc/plugin-api.txt
@@ -0,0 +1,164 @@
+Plugin programming interface
+****************************
+
+
+Plugin basics
+=============
+
+The Connection Manager supports plugins for various actions. The basic plugin
+contains of plugin description via CONNMAN_PLUGIN_DEFINE and also init/exit
+callbacks defined through that description.
+
+#include <connman/plugin.h>
+
+static int example_init(void)
+{
+ return 0;
+}
+
+static void example_exit(void)
+{
+}
+
+CONNMAN_PLUGIN_DEFINE(example, "Example plugin", CONNMAN_VERSION,
+ example_init, example_exit)
+
+
+Infrastructure for plugins
+==========================
+
+The Connection Manager provides a very good infrastructure for plugins to
+interface with the core functionalities of ConnMan. The infrastructure is
+well divided into the concepts of Technology, Device and Network, among
+others.
+
+Technology infrastructure
+=========================
+
+A Technology in ConnMan is an abstract representation of the different
+kinds of technologies it supports such as WiFi, Ethernet, Bluetooth and
+Celullar. The technologies support are added to ConnMan through plugins, such
+as plugins/bluetooth.c for the Bluetooth Technology or plugins/wifi.c for the
+WiFi Technology. Each new technology plugin needs to register itself as a
+Technology with ConnMan. As an example we will take a look at the Bluetooth
+plugin registration. As a first step 'struct connman_technology_driver' needs
+to be defined:
+
+ static struct connman_technology_driver tech_driver = {
+ .name = "bluetooth",
+ .type = CONNMAN_SERVICE_TYPE_BLUETOOTH,
+ .probe = bluetooth_tech_probe,
+ .remove = bluetooth_tech_remove,
+ .set_tethering = bluetooth_tech_set_tethering,
+ };
+
+More functions can be defined depending on the purpose of the plugin. All
+vtable's supported functions can be seen in include/technology.h. If a
+completely new technology type is added 'enum connman_service_type' in
+include/service.h needs to be extended accordingly. This inclusion comes in
+the form of Service because ultimately a new technology introduces a new
+Service. New technologies can also reuse existing Services types.
+
+To make the Connection Manager aware of the new Technology plugin we need to
+register its driver by calling 'connman_technology_driver_register()' in the
+plugin initialization function, bluetooth_init() in this example:
+
+ connman_technology_driver_register(&tech_driver);
+
+In this document the error check is supressed for the sake of simplicity.
+All plugins should check return values in driver registration functions.
+
+After this call ConnMan becomes aware of the new Technology plugin and will
+call the probe() method when the new technology is recognized by the system. For
+the Bluetooth plugin for example probe() would be called when a Bluetooth
+adapter is recognized. A Technology is only probed if there exists at least
+one device of such technology plugged into the system.
+
+Complementary, the technology must be unregistered on the plugin exit function
+through 'connman_technology_driver_unregister()'.
+
+Device infrastructure
+=====================
+
+A Device represents a real device of a given Technology, there could be many
+devices per technology. To enable ConnMan to handle Devices a device driver
+needs to be registered. Using the Bluetooth plugin as example it would have to
+define a 'struct connman_device_driver':
+
+ static struct connman_device_driver device_driver = {
+ .name = "bluetooth",
+ .type = CONNMAN_DEVICE_TYPE_BLUETOOTH,
+ .probe = bluetooth_device_probe,
+ .remove = bluetooth_device_remove,
+ .enable = bluetooth_device_enable,
+ .disable = bluetooth_device_disable,
+ };
+
+And to register the driver:
+
+ connman_device_driver_register(&device_driver);
+
+'connman_device_driver_register()' is called during the plugin initialization
+process, not necessarily at the plugin init function.
+
+In this document the error check is supressed for the sake of simplicity.
+All plugins should check return values in driver registration functions.
+
+Additionally code to handle the detection of new devices needs to be written
+for each plugin, the bluetooth plugin does so by registering watchers for the
+BlueZ D-Bus interface. Once a new Bluetooth Device appears the plugin needs to
+notify ConnMan core by calling connman_device_create(), for the bluetooth
+plugin the call would be:
+
+ struct connman_device *device;
+
+ device = connman_device_create("bluetooth",
+ CONNMAN_DEVICE_TYPE_BLUETOOTH)
+
+ConnMan core will then register the bluetooth device as a Device entity and
+call the probe() function from the bluetooth plugin device driver. If a
+Technology entity for the Device type doesn't exist it will be created and
+Technology probe() function in the bluetooth technology driver is called.
+
+For the Bluetooth plugin a Device represents the local Bluetooth Adapter
+plugged in the system.
+
+To learn how to use the connman_device_*() functions such as
+connman_device_set_powered() and connman_device_ref() see src/device.c for
+its API documentation.
+
+Network infrastructure
+======================
+
+The Connection Manager provides a mean to plugins handle the specifics of
+establishing/handling a connection for each type of Technology. For the
+bluetooth plugin a connman_network_driver needs to be registered:
+
+ static struct connman_network_driver network_driver = {
+ .name = "bluetooth",
+ .type = CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN,
+ .probe = bluetooth_pan_probe,
+ .remove = bluetooth_pan_remove,
+ .connect = bluetooth_pan_connect,
+ .disconnect = bluetooth_pan_disconnect,
+ };
+
+And then call the register function:
+
+ connman_network_driver_register(&network_driver);
+
+In this document the error check is supressed for the sake of simplicity.
+All plugins should check return values in driver registration functions.
+
+The next step would be the probe of a Network entity, for the bluetooth
+plugin this would happen when a new device that supports the PAN NAP role is
+paired with the system. ConnMan then call connman_device_add_network() to
+associate the new Network with the existing Device entity (the local Bluetooth
+Adapter).
+
+Then in the vtable's connect method all the needed pieces to perform a
+connection shall be perfomed.
+
+To learn how to use the connman_network_*() functions such as
+connman_network_set_index() and connman_network_set_connected() see
+src/network.c for its API documentation.
diff --git a/doc/service-api.txt b/doc/service-api.txt
new file mode 100644
index 0000000..b4f1dca
--- /dev/null
+++ b/doc/service-api.txt
@@ -0,0 +1,496 @@
+Service hierarchy
+=================
+
+Service net.connman
+Interface net.connman.Service
+Object path [variable prefix]/{service0,service1,...}
+
+Methods dict GetProperties() [deprecated]
+
+ Returns properties for the service object. See
+ the properties section for available properties.
+
+ Usage of this method is highly discouraged. Use
+ the Manager.GetServices() method instead.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void SetProperty(string name, variant value)
+
+ Changes the value of the specified property. Only
+ properties that are listed as read-write are
+ changeable. On success a PropertyChanged signal
+ will be emitted.
+
+ Properties cannot be set for hidden WiFi service
+ entries or provisioned services.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.InvalidProperty
+
+ void ClearProperty(string name)
+
+ Clears the value of the specified property.
+
+ Properties cannot be cleared for hidden WiFi service
+ entries or provisioned services.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.InvalidProperty
+
+ void Connect()
+
+ Connect this service. It will attempt to connect
+ WiFi or Bluetooth services.
+
+ For Ethernet devices this method can only be used
+ if it has previously been disconnected. Otherwise
+ the plugging of a cable will trigger connecting
+ automatically. If no cable is plugged in this method
+ will fail.
+
+ This method call will only return in case of an
+ error or when the service is fully connected. So
+ setting a longer D-Bus timeout might be a really
+ good idea.
+
+ Calling Connect() on a hidden WiFi service entry will
+ query the missing SSID via the Agent API causing a
+ WiFi service with the given SSID to be scanned,
+ created and connected.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void Disconnect()
+
+ Disconnect this service. If the service is not
+ connected an error message will be generated.
+
+ On Ethernet devices this will disconnect the IP
+ details from the service. It will not magically
+ unplug the cable. When no cable is plugged in this
+ method will fail.
+
+ This method can also be used to abort a previous
+ connection attempt via the Connect method.
+
+ Hidden WiFi service entries cannot be disconnected
+ as they always stay in idle state.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void Remove()
+
+ A successfully connected service with Favorite=true
+ can be removed this way. If it is connected, it will
+ be automatically disconnected first.
+
+ If the service requires a passphrase it will be
+ cleared and forgotten when removing.
+
+ This is similar to setting the Favorite property
+ to false, but that is currently not supported.
+
+ In the case a connection attempt failed and the
+ service is in the State=failure, this method can
+ also be used to reset the service.
+
+ Calling this method on Ethernet devices, hidden WiFi
+ services or provisioned services will cause an error
+ message. It is not possible to remove these kind of
+ services.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void MoveBefore(object service)
+
+ If a service has been used before, this allows a
+ reorder of the favorite services.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void MoveAfter(object service)
+
+ If a service has been used before, this allows a
+ reorder of the favorite services.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void ResetCounters() [experimental]
+
+ Reset the counter statistics.
+
+ Possible Errors: None
+
+Signals PropertyChanged(string name, variant value)
+
+ This signal indicates a changed value of the given
+ property.
+
+Properties string State [readonly]
+
+ The service state information.
+
+ Valid states are "idle", "failure", "association",
+ "configuration", "ready", "disconnect" and "online".
+
+ The "ready" state signals a successfully
+ connected device. "online" signals that an
+ Internet connection is available and has been
+ verified.
+
+ See doc/overview-api.txt for more information about
+ state transitions.
+
+ string Error [readonly]
+
+ The service error status details.
+
+ When error occur during connection or disconnection
+ the detailed information is represented in this
+ property to help the user interface to present the
+ user with alternate options.
+
+ This property is only valid when the service is in
+ the "failure" state. Otherwise it might be empty or
+ not present at all.
+
+ Currently defined error codes are: "out-of-range",
+ "pin-missing", "dhcp-failed", "connect-failed",
+ "login-failed", "auth-failed" and "invalid-key".
+
+ string Name [readonly]
+
+ The service name (for example "Wireless" etc.)
+
+ This name can be used for directly displaying it in
+ the application. It has pure informational purpose
+ and no attempt should be made to translate it.
+
+ For Ethernet devices and hidden WiFi networks this
+ property is not present.
+
+ string Type [readonly]
+
+ The service type (for example "ethernet", "wifi" etc.)
+
+ This information should only be used to determine
+ advanced properties or showing the correct icon
+ to the user.
+
+ Together with a missing Name property, this can
+ be used to identify hidden WiFi networks.
+
+ array{string} Security [readonly]
+
+ If the service type is WiFi, then this property is
+ present and contains the list of security methods
+ or key management settings.
+
+ Possible values are "none", "wep", "psk", "ieee8021x"
+ and also "wps".
+
+ This property might be only present for WiFi
+ services.
+
+ uint8 Strength [readonly]
+
+ Indicates the signal strength of the service. This
+ is a normalized value between 0 and 100.
+
+ This property will not be present for Ethernet
+ devices.
+
+ boolean Favorite [readonly]
+
+ Will be true if a cable is plugged in or the user
+ selected and successfully connected to this service.
+
+ This value is automatically changed and to revert
+ it back to false the Remove() method needs to be
+ used.
+
+ boolean Immutable [readonly]
+
+ This value will be set to true if the service is
+ configured externally via a configuration file.
+
+ The only valid operation are Connect() and of
+ course Disconnect(). The Remove() method will
+ result in an error.
+
+ boolean AutoConnect [readwrite]
+
+ If set to true, this service will auto-connect
+ when no other connection is available.
+
+ The service won't auto-connect while roaming.
+
+ For favorite services it is possible to change
+ this value to prevent or permit automatic
+ connection attempts.
+
+ boolean Roaming [readonly]
+
+ This property indicates if this service is roaming.
+
+ In the case of Cellular services this normally
+ indicates connections to a foreign provider when
+ traveling abroad.
+
+ array{string} Nameservers [readonly]
+
+ The list of currently active nameservers for this
+ service. If the server is not in READY or ONLINE
+ state than this list will be empty.
+
+ Global nameservers are automatically added to this
+ list. The array represents a sorted list of the
+ current nameservers. The first one has the highest
+ priority and is used by default.
+
+ When using DHCP this array represents the nameservers
+ provided by the network. In case of manual settings,
+ the ones from Nameservers.Configuration are used.
+
+ array{string} Nameservers.Configuration [readwrite]
+
+ The list of manually configured domain name
+ servers. Some cellular networks don't provide
+ correct name servers and this allows for an
+ override.
+
+ This array is sorted by priority and the first
+ entry in the list represents the nameserver with
+ the highest priority.
+
+ When using manual configuration and no global
+ nameservers are configured, then it is useful
+ to configure this setting.
+
+ Changes to the domain name servers can be done
+ at any time. It will not cause a disconnect of
+ the service. However there might be small window
+ where name resolution might fail.
+
+ array{string} Timeservers [readonly]
+
+ The list of currently active timeservers for this
+ service. If the server is not in READY or ONLINE
+ state than this list will be empty.
+
+ array{string} Timeservers.Configuration [readwrite]
+
+ The list of manually configured time servers.
+
+ The first entry in the list represents the
+ timeserver with the highest priority.
+
+ When using manual configuration this setting
+ is useful to override all the other timeserver
+ settings. This is service specific, hence only
+ the values for the default service are used.
+
+ Changes to this property will result in restart
+ of NTP query.
+
+ array{string} Domains [readonly]
+
+ The list of currently used search domains taken
+ from Domains.Configurations if set, otherwise a
+ domain name if provided by DHCP or VPNs.
+
+ array{string} Domains.Configuration [readwrite]
+
+ The list of manually configured search domains.
+
+ dict IPv4 [readonly]
+
+ string Method [readonly]
+
+ Possible values are "dhcp", "manual"
+ and "off".
+
+ The value "fixed" indicates an IP address
+ that can not be modified. For example
+ cellular networks return fixed information.
+
+ string Address [readonly]
+
+ The current configured IPv4 address.
+
+ string Netmask [readonly]
+
+ The current configured IPv4 netmask.
+
+ string Gateway [readonly]
+
+ The current configured IPv4 gateway.
+
+ dict IPv4.Configuration [readwrite]
+
+ Same values as IPv4 property. The IPv4 represents
+ the actual system configuration while this allows
+ user configuration.
+
+ Changing these settings will cause a state change
+ of the service. The service will become unavailable
+ until the new configuration has been successfully
+ installed.
+
+ dict IPv6 [readonly]
+
+ string Method [readonly]
+
+ Possible values are "auto", "manual", "6to4"
+ and "off".
+
+ The value "fixed" indicates an IP address
+ that can not be modified. For example
+ cellular networks return fixed information.
+ The value "6to4" is returned if 6to4 tunnel
+ is created by connman. The tunnel can only be
+ created if method was set to "auto" by the
+ user. User cannot set the method to "6to4".
+
+ string Address [readonly]
+
+ The current configured IPv6 address.
+
+ uint8 PrefixLength [readonly]
+
+ The prefix length of the IPv6 address.
+
+ string Gateway [readonly]
+
+ The current configured IPv6 gateway.
+
+ string Privacy [readonly]
+
+ Enable or disable IPv6 privacy extension
+ that is described in RFC 4941. The value
+ has only meaning if Method is set to "auto".
+
+ Value "disabled" means that privacy extension
+ is disabled and normal autoconf addresses are
+ used.
+
+ Value "enabled" means that privacy extension is
+ enabled and system prefers to use public
+ addresses over temporary addresses.
+
+ Value "prefered" means that privacy extension is
+ enabled and system prefers temporary addresses
+ over public addresses.
+
+ Default value is "disabled".
+
+ dict IPv6.Configuration [readwrite]
+
+ Same values as IPv6 property. The IPv6 represents
+ the actual system configuration while this allows
+ user configuration.
+
+ Changing these settings will cause a state change
+ of the service. The service will become unavailable
+ until the new configuration has been successfully
+ installed.
+
+ dict Proxy [readonly]
+
+ string Method [readonly]
+
+ Possible values are "direct", "auto" and
+ "manual".
+
+ In case of "auto" method, the URL file can be
+ provided unless you want to let DHCP/WPAD
+ auto-discover to be tried. In such case if DHCP
+ and WPAD auto-discover methods fails then
+ method will be "direct".
+
+ In case of "direct" no additional information
+ are provided. For the "manual" method the
+ Servers have to be set, Excludes is optional.
+
+ string URL [readonly]
+
+ Automatic proxy configuration URL. Used by
+ "auto" method.
+
+ array{string} Servers [readonly]
+
+ Used when "manual" method is set.
+
+ List of proxy URIs. The URI without a protocol
+ will be interpreted as the generic proxy URI.
+ All others will target a specific protocol and
+ only once.
+
+ Example for generic proxy server entry would
+ be like this: "server.example.com:911".
+
+ array{string} Excludes [readonly]
+
+ Used when "manual" method is set.
+
+ List of hosts which can be accessed directly.
+
+ dict Proxy.Configuration [readwrite]
+
+ Same values as Proxy property. The Proxy represents
+ the actual system configuration while this allows
+ user configuration.
+
+ If "auto" method is set with an empty URL, then
+ DHCP/WPAD auto-discover will be tried. Otherwise the
+ specified URL will be used.
+
+ dict Provider [readonly]
+
+ string Host [readonly]
+
+ VPN host IP.
+
+ string Domain [readonly]
+
+ VPN Domain.
+
+ string Name [readonly]
+
+ VPN provider Name.
+
+ string Type [readonly]
+
+ VPN provider type.
+
+ dict Ethernet [readonly]
+
+ string Method [readonly]
+
+ Possible values are "auto" and "manual".
+
+ string Interface [readonly]
+
+ Interface name (for example eth0).
+
+ string Address [readonly]
+
+ Ethernet device address (MAC address).
+
+ uint16 MTU [readonly]
+
+ The Ethernet MTU (default is 1500).
+
+ uint16 Speed [readonly] [deprecated]
+
+ Selected speed of the line.
+
+ This information is not available.
+
+ string Duplex [readonly] [deprecated]
+
+ Selected duplex settings of the line.
+ Possible values are "half" and "full".
+
+ This information is not available.
diff --git a/doc/session-api.txt b/doc/session-api.txt
new file mode 100644
index 0000000..3aac535
--- /dev/null
+++ b/doc/session-api.txt
@@ -0,0 +1,184 @@
+Service unique name
+Interface net.connman.Notification
+Object path freely definable
+
+Methods void Release()
+
+ This method gets called when the service daemon
+ unregisters the session. A counter can use it to do
+ cleanup tasks. There is no need to unregister the
+ session, because when this method gets called it has
+ already been unregistered.
+
+ void Update(dict settings)
+
+ Sends an update of changed settings. Only settings
+ that are changed will be included.
+
+ Initially on every session creation this method is
+ called once to inform about the current settings.
+
+
+Service net.connman
+Interface net.connman.Session
+Object path variable
+
+Methods void Destroy()
+
+ Close the current session. This is similar to
+ DestroySession method on the manager interface. It
+ is just provided for convenience depending on how
+ the application wants to track the session.
+
+ void Connect()
+
+ If not connected, then attempt to connect this
+ session.
+
+ The usage of this method depends a little bit on
+ the model of the application. Some application
+ should not try to call Connect on any session at
+ all. They should just monitor if it becomes online
+ or gets back offline.
+
+ Others might require an active connection right now.
+ So for example email notification should only check
+ for new emails when a connection is available. However
+ if the user presses the button for get email or wants
+ to send an email it should request to get online with
+ this method.
+
+ Depending on the bearer settings the current service
+ is used or a new service will be connected.
+
+ This method returns immediately after it has been
+ called. The application is informed through the update
+ notification about the state of the session.
+
+ It is also not guaranteed that a session stays online
+ after this method call. It can be taken offline at any
+ time. This might happen because of idle timeouts or
+ other reasons.
+
+ It is safe to call this method multiple times. The
+ actual usage will be sorted out for the application.
+
+ void Disconnect()
+
+ This method indicates that the current session does
+ not need a connection anymore.
+
+ This method returns immediately. The application is
+ informed through the update notification about the
+ state of the session.
+
+ void Change(string name, variant value)
+
+ Change the value of certain settings. Not all
+ settings can be changed. Normally this should not
+ be needed or an extra session should be created.
+ However in some cases it makes sense to change
+ a value and trigger different behavior.
+
+ A change of a setting will cause an update notification
+ to be sent. Some changes might cause the session to
+ be moved to offline state.
+
+Settings string State [readonly]
+
+ This indicates if the connection is disconnected,
+ connected or online. It is updated according to the
+ selected ConnectionType. The session will not be
+ in a useful shape (i.e.: providing a network connection
+ to the owner) until its State gets updated to connected
+ and/or online.
+
+ This maps to the useful port of the service state.
+ And it is only valid for the selected bearer
+ configuration. Otherwise it will be reported as
+ disconnected even if connected services are present.
+
+ In addition the State settings notification might
+ not happen right away. Notifications of this state
+ can be delayed based on the speed of the bearer. It
+ is done to avoid congestion on bearers like cellular
+ etc.
+
+ string Name [readonly]
+
+ The Service name to which the system is connected.
+ It should only be used for displaying it in the UI
+ and not for getting hold on session object.
+
+ string Bearer [readonly]
+
+ This indicates the current bearer that is used
+ for this session. Or an empty string if no bearer
+ if available.
+
+ string Interface [readonly]
+
+ Interface name used by the service object to connect.
+ This name can be used for SO_BINDTODEVICE in the
+ application.
+
+ dict IPv4 [readonly]
+
+ Current IPv4 configuration.
+
+ dict IPv6 [readonly]
+
+ Current IPv6 configuration.
+
+ array{string} AllowedBearers [readwrite]
+
+ A list of bearers that can be used for this session.
+ In general this list should be empty to indicate that
+ any bearer is acceptable.
+
+ The order of the entries in AllowedBearers matters.
+ The services are sorted in the order of the bearer
+ entries in this list.
+
+ Also "*" matches any bearer. This is usefull to prefer
+ certain bearers such as 'wifi' with a fallback to any
+ other available bearer.
+
+ Invalid bearer names will be ignored and removed
+ from the list. And empty AllowedBearers will
+ not match to any bearer, therefore the session
+ will never go online.
+
+ When a session is created and the provided settings
+ dictionary does not contain AllowedBearers, a default
+ session with "*" will be created.
+
+ string ConnectionType [readwrite]
+
+ This is used to indicate which connection is requested
+ from the session. The state of the session will be
+ updated accordingly. Values can be 'local',
+ 'internet' or 'any'.
+
+ 'local' means the session requests to be connected,
+ but does not require specifically to be online.
+ Therefore State property will be set to 'connected' if
+ underlying service gets ready and/or online.
+
+ 'online' means the session requests to be connected,
+ and online. State property will never get 'connected'
+ but instead will switch to 'online' if underlying
+ service gets online.
+
+ 'any' means either 'local' or 'internet'.
+
+ Invalid values will be ignored and removed. An
+ empty ConnectionType is an invalid configuration.
+
+ When a session is created and the provided settings
+ dictionary does not contain ConnectionType, a default
+ session with 'any' will be created.
+
+ (This setting will be removed when the unique process
+ identification problem is solved.)
+
diff --git a/doc/session-overview.txt b/doc/session-overview.txt
new file mode 100644
index 0000000..2393167
--- /dev/null
+++ b/doc/session-overview.txt
@@ -0,0 +1,94 @@
+Session API
+***********
+
+
+Connection management algorithm basics
+======================================
+
+The Session core uses the normal auto-connect algorithm for selecting
+which services will be connected or disconnected. That means only
+Services with AutoConnect set to true will be used. The Session
+core will assign a connected Service to a Session if the Service
+is matching the AllowedBearer filter.
+
+By using the normal auto-connect algorithm, it is possible to
+use the Session API and the Service API at the same time.
+
+
+Session States and Transitions
+==============================
+
+There is only one state which is called Free Ride.
+
+The Free Ride state means that a session will go online if a matching
+service goes online without calling Service.Connect() itself. The idea
+behind this is that a session doesn't request a connection for itself
+instead waits until another session actively requires to go online.
+This is comparable to piggy-backing.
+
+Connnect()
+ +------+
+ | v
++------------+
+| Free Ride |
++------------+
+ | ^
+ +-----+
+ Disconnect()
+
+
+If an application wants to stay offline it can set an empty
+AllowedBearers list.
+
+
+Session application identification
+==================================
+
+Application using session can be identified through different means.
+
+ - SELinux
+ - UID
+ - GID
+
+ConnMan will try to identify the application in the given order above.
+If SELinux is not supported by the system or not configured, ConnMan
+will ignore it and fallback asking the D-Bus daemon about the UID of
+the application.
+
+The identification is only useful in combination with the policy plugin.
+
+
+Policy Plugin
+=============
+
+The policy plugin allows the administrator to provision/configure
+sessions. Each policy needs an application identification in order to
+match the policy to a session.
+
+See session-policy-format.txt for more details.
+
+
+Per application routing
+=======================
+
+For each session a policy routing table is maintained. Each policy
+routing table contains a default route to the selected service.
+
+Per session iptables rules:
+
+iptables -t mangle -A OUTPUT -m owner [--uid-owner|--gid-owner] $OWNER \
+ -j MARK --set-mark $MARK
+
+Global rules for all sessions:
+
+iptables -t mangle -A INPUT -j CONNMARK --restore-mark
+iptables -t mangle -A POSTROUTING -j CONNMARK --save-mark
+
+Per application routing is only available when policy files are
+used. Without the policy plugin or a valid configuration, the default
+session configuration is applied.
+
+The default session configuration does not enable the per application
+routing. Sessions are still useful in this setup, because the
+notification of sessions is still available, e.g. the online/offline
+notification.
diff --git a/doc/session-policy-format.txt b/doc/session-policy-format.txt
new file mode 100644
index 0000000..babc2c1
--- /dev/null
+++ b/doc/session-policy-format.txt
@@ -0,0 +1,83 @@
+ConnMan policy file format
+**************************
+
+The session policy plugin allows to configure/provision a session.
+ConnMan will be looking for policy files in STORAGEDIR/session_policy_local
+which by default points to /var/lib/connman. Policy file names must
+not include other characters than letters or numbers and must have
+a .policy suffix. Policy files are text files.
+
+It is possible to add, remove or update a policy file during run-time.
+The corresponding sessions will be updated accordingly.
+
+Policy group [policy_*]
+=======================
+
+Each policy group must start with as [policy_*] tag. '*' has no
+semantic meaning but should consist just out of characters.
+
+Required fields:
+
+Exactly one and only one of the required fields need to be present
+per policy group.
+
+- uid: This policy group will be applied to any session
+ with given user ID.
+
+- gid: This policy group will be applied to any session
+ with given group ID.
+
+- selinux: This policy group will be applied to any session
+ with given SELinux context.
+
+Allowed fields:
+
+- AllowedBearers: see session-api.txt
+ The policy AllowedBearers overrules the settings done via
+ D-Bus. For example the policy AllowedBearers is 'ethernet' then
+ the D-Bus API will only accept an empty string or 'ethernet'.
+
+- ConnectionType: see session-api.txt
+ The policy ConnectionType overrules the settings done via
+ D-Bus.
+
+- Priority: A boolean which tells ConnMan to prefer the session
+ over other Sessions. This priority value is more for applications
+ that want to push themselves up in the asychronization notification
+ queue once a bearer becomes online.
+
+ This actual priority order also depends on the allowed bearers and
+ other factors. This setting is just a little indicator for one
+ application being notified before another one.
+
+- RoamingPolicy: The allowed roaming behavior.
+
+ Valid policies are "national", "international", "default", "always"
+ and "forbidden".
+
+ "national" allows roaming within a country. "international" allows
+ roaming in a country and between countries.
+
+ "default" is used to tell the session to use the global roaming
+ setting.
+
+ "always" will overwrite the default "forbidden" value which is
+ useful for emergency application.
+
+ Default value is "forbidden".
+
+- EmergencyCall: A boolean which tells ConnMan whenever the
+ Connect() method is called for this session, all other
+ session are disconnected.
+
+ Note only services matching the AllowedBearers rule will be
+ considered.
+
+Example
+=======
+
+example@example:[~]$ cat /var/lib/connman/session_policy_local/auser.policy
+[policy_auser]
+uid = auser
+AllowedBearers = wifi cellular
+RoamingPolicy = forbidden
diff --git a/doc/technology-api.txt b/doc/technology-api.txt
new file mode 100644
index 0000000..f97eac0
--- /dev/null
+++ b/doc/technology-api.txt
@@ -0,0 +1,99 @@
+Technology hierarchy
+====================
+
+Service net.connman
+Interface net.connman.Technology
+Object path [variable prefix]/{technology0,technology1,...}
+
+Methods dict GetProperties() [deprecated]
+
+ Returns properties for the technology object. See
+ the properties section for available properties.
+
+ Usage of this method is highly discouraged. Use
+ the Manager.GetTechnologies() method instead.
+
+ Possible Errors: [service].Error.InvalidArguments
+
+ void SetProperty(string name, variant value)
+
+ Changes the value of the specified property. Only
+ properties that are listed as read-write are
+ changeable. On success a PropertyChanged signal
+ will be emitted.
+
+ Possible Errors: [service].Error.InvalidArguments
+ [service].Error.InvalidProperty
+
+ void Scan()
+
+ Trigger a scan for this specific technology. The
+ method call will return when a scan has been
+ finished and results are available. So setting
+ a longer D-Bus timeout might be a really good
+ idea.
+
+ Results will be signaled via the ServicesChanged
+ signal from the manager interface.
+
+ In case of P2P technology, results will be signaled
+ via the PeersChanged signal from the manager
+ interface.
+
+Signals PropertyChanged(string name, variant value)
+
+ This signal indicates a changed value of the given
+ property.
+
+Properties boolean Powered [readwrite]
+
+ Boolean representing the power state of the
+ technology. False means that the technology is
+ off (and is available RF-Killed) while True means
+ that the technology is enabled.
+
+ boolean Connected [readonly]
+
+ Boolean representing if a technology is connected.
+
+ This is just a convience property for allowing the
+ UI to easily show if this technology has an active
+ connection or not.
+
+ If this property is True it means that at least one
+ service of this technology is in ready state.
+
+ string Name [readonly]
+
+ Name of this technology.
+
+ string Type [readonly]
+
+ The technology type (for example "ethernet" etc.)
+
+ This information should only be used to determine
+ advanced properties or showing the correct icon
+ to the user.
+
+ boolean Tethering [readwrite]
+
+ This option allows to enable or disable the support
+ for tethering. When tethering is enabled then the
+ default service is bridged to all clients connected
+ through the technology.
+
+ string TetheringIdentifier [readwrite]
+
+ The tethering broadcasted identifier.
+
+ This property is only valid for the WiFi technology,
+ and is then mapped to the WiFi AP SSID clients will
+ have to join in order to gain internet connectivity.
+
+ string TetheringPassphrase [readwrite]
+
+ The tethering connection passphrase.
+
+ This property is only valid for the WiFi technology,
+ and is then mapped to the WPA pre-shared key clients
+ will have to use in order to establish a connection.
diff --git a/doc/valgrind.suppressions b/doc/valgrind.suppressions
new file mode 100644
index 0000000..c1c7bca
--- /dev/null
+++ b/doc/valgrind.suppressions
@@ -0,0 +1,235 @@
+{
+ <syslog error>
+ Memcheck:Cond
+ obj:/lib/libc-*.so
+ ...
+ fun:localtime_r
+ fun:__vsyslog_chk
+ fun:__syslog_chk
+ fun:__connman_log_init
+ ...
+}
+{
+ <iconv open>
+ Memcheck:Addr4
+ obj:/lib/libc-*.so
+ obj:/lib/libglib-2.0.so*
+ fun:g_iconv_open
+ ...
+ fun:g_convert
+ fun:g_locale_to_utf8
+ fun:g_strerror
+ fun:g_key_file_load_from_file
+ ...
+}
+{
+ <ioctl ADDRT/DELRT>
+ Memcheck:Param
+ ioctl(SIOCADDRT/DELRT)
+ obj:/lib/ld-*.so
+ ...
+}
+{
+ <g_main_loop>
+ Memcheck:Leak
+ fun:memalign
+ ...
+ fun:g_slice_alloc
+ ...
+ fun:g_main_loop_new
+ ...
+}
+{
+ <g_option_context_parse>
+ Memcheck:Leak
+ ...
+ fun:g_slice_alloc
+ ...
+ fun:g_option_context_parse
+ ...
+}
+{
+ <g_key_file_load_from_data>
+ Memcheck:Leak
+ ...
+ fun:g_slice_alloc
+ ...
+ fun:g_key_file_load_from_data
+ ...
+}
+{
+ <g_key_file_new 1>
+ Memcheck:Leak
+ ...
+ fun:g_slice_alloc
+ ...
+ fun:g_key_file_new
+ ...
+}
+{
+ <g_key_file_new 2>
+ Memcheck:Leak
+ fun:*alloc
+ ...
+ fun:g_key_file_new
+ fun:main
+}
+{
+ <connman plugin cleanup>
+ Memcheck:Leak
+ ...
+ fun:__connman_plugin_cleanup
+ ...
+}
+{
+ <cmd line option parsing>
+ Memcheck:Leak
+ fun:malloc
+ fun:g_malloc
+ fun:g_strdup
+ fun:g_set_prgname
+ fun:g_option_context_parse
+ fun:main
+}
+{
+ <dbus system bus setup 1>
+ Memcheck:Leak
+ ...
+ fun:dbus_malloc*
+ ...
+ fun:g_dbus_setup_bus
+ fun:main
+}
+{
+ <dbus system bus setup 2>
+ Memcheck:Leak
+ ...
+ fun:g_malloc*
+ ...
+ fun:dbus_connection_set_watch_functions
+ fun:setup_bus
+ ...
+}
+{
+ <key file get charset>
+ Memcheck:Leak
+ ...
+ fun:g_*alloc*
+ ...
+ fun:g_strerror
+ fun:g_key_file_load_from_file
+ fun:main
+}
+{
+ <dbus disconnect func set>
+ Memcheck:Leak
+ ...
+ fun:filter_data_get
+ fun:g_dbus_add_signal_watch
+ fun:g_dbus_set_disconnect_function
+ fun:main
+}
+{
+ <plugin dlopen>
+ Memcheck:Leak
+ ...
+ fun:dlopen
+ fun:__connman_plugin_init
+ fun:main
+}
+{
+ <dbus system bus setup 3>
+ Memcheck:Leak
+ ...
+ fun:dbus_malloc0
+ ...
+ fun:dbus_parse_address
+ ...
+ fun:g_dbus_setup_bus
+ fun:main
+}
+{
+ <libdbus internals 1>
+ Memcheck:Leak
+ fun:*malloc
+ ...
+ obj:/lib/libdbus-1.so.3.5.3
+}
+{
+ <dbus system bus setup 4>
+ Memcheck:Leak
+ fun:*alloc
+ ...
+ fun:dbus_*alloc*
+ ...
+ fun:g_dbus_setup_bus
+ fun:main
+}
+{
+ <dbus system bus setup 5>
+ Memcheck:Leak
+ fun:calloc
+ fun:g_malloc0
+ ...
+ fun:g_dbus_set_disconnect_function
+ fun:main
+}
+{
+ <dbus bus remove match>
+ Memcheck:Leak
+ fun:malloc
+ fun:g_malloc
+ fun:g_source_set_callback
+ fun:g_timeout_add_full
+ fun:g_timeout_add
+ ...
+ fun:dbus_pending_call_block
+ fun:dbus_connection_send_with_reply_and_block
+ ...
+ fun:dbus_bus_remove_match
+}
+{
+ <g_main_loop_run/new>
+ Memcheck:Leak
+ fun:*alloc
+ ...
+ fun:g_main_loop_*
+ fun:main
+}
+{
+ <g_main_context_dispatch>
+ Memcheck:Leak
+ fun:*alloc
+ ...
+ fun:g_main_context_dispatch
+}
+{
+ <libdbus internals 2>
+ Memcheck:Leak
+ fun:realloc
+ fun:dbus_realloc
+ ...
+ fun:dbus_message_set_reply_serial
+ fun:dbus_message_new_error
+ ...
+}
+{
+ <libdbus internals 3>
+ Memcheck:Leak
+ fun:realloc
+ fun:dbus_realloc
+ ...
+ fun:dbus_message_new_signal
+ ...
+}
+{
+ <dbus_bus_register>
+ Memcheck:Leak
+ fun:malloc
+ fun:realloc
+ fun:dbus_realloc
+ ...
+ fun:dbus_pending_call_block
+ fun:dbus_connection_send_with_reply_and_block
+ fun:dbus_bus_register
+}
diff --git a/doc/vpn-agent-api.txt b/doc/vpn-agent-api.txt
new file mode 100644
index 0000000..72bee9d
--- /dev/null
+++ b/doc/vpn-agent-api.txt
@@ -0,0 +1,158 @@
+Agent hierarchy
+===============
+
+Service unique name
+Interface net.connman.vpn.Agent
+Object path freely definable
+
+Methods void Release()
+
+ This method gets called when the service daemon
+ unregisters the agent. An agent can use it to do
+ cleanup tasks. There is no need to unregister the
+ agent, because when this method gets called it has
+ already been unregistered.
+
+ void ReportError(object service, string error)
+
+ This method gets called when an error has to be
+ reported to the user.
+
+ A special return value can be used to trigger a
+ retry of the failed transaction.
+
+ Possible Errors: net.connman.vpn.Agent.Error.Retry
+
+ dict RequestInput(object service, dict fields)
+
+ This method gets called when trying to connect to
+ a service and some extra input is required. For
+ example a password or username.
+
+ The return value should be a dictionary where the
+ keys are the field names and the values are the
+ actual fields. Alternatively an error indicating that
+ the request got canceled can be returned.
+
+ Most common return field names are "Username" and of
+ course "Password".
+
+ The dictionary arguments contains field names with
+ their input parameters.
+
+ Possible Errors: net.connman.vpn.Agent.Error.Canceled
+
+ void Cancel()
+
+ This method gets called to indicate that the agent
+ request failed before a reply was returned.
+
+Fields string Username
+
+ Username for authentication. This field will be
+ requested when connecting to L2TP and PPTP.
+
+ string Password
+
+ Password for authentication.
+
+ boolean SaveCredentials
+
+ Tells if the user wants the user credentials
+ be saved by connman-vpnd.
+
+ string Host
+
+ End point of this VPN link i.e., the VPN gateway
+ we are trying to connect to.
+
+ string Name
+
+ Name of the VPN connection we are trying to connect to.
+
+ string OpenConnect.CACert
+
+ Informational field containing a path name for an
+ additional Certificate Authority file.
+
+ string OpenConnect.ClientCert
+
+ Informational field containing a pkcs11 URL or a path
+ name for the client certificate.
+
+ string OpenConnect.Cookie
+
+ Return the OpenConnect cookie value that is used for
+ authenticating the VPN session.
+
+ string OpenConnect.ServerCert
+
+ Return the OpenConnect server hash used to identify
+ the final server after possible web authentication
+ logins, selections and redirections.
+
+ string OpenConnect.VPNHost
+
+ Return the final VPN server to use after possible
+ web authentication logins, selections and redirections.
+
+Arguments string Type
+
+ Contains the type of a field. For example "password",
+ "response", "boolean" or plain "string".
+
+ string Requirement
+
+ Contains the requirement option. Valid values are
+ "mandatory", "optional", "alternate" or
+ "informational".
+
+ The "alternate" value specifies that this field can be
+ returned as an alternative to another one.
+
+ All "mandatory" fields must be returned, while the
+ "optional" can be returned if available.
+
+ Nothing needs to be returned for "informational", as it
+ is here only to provide an information so a value is
+ attached to it.
+
+ array{string} Alternates
+
+ Contains the list of alternate field names this
+ field can be represented by.
+
+ string Value
+
+ Contains data as a string, relatively to an
+ "informational" argument.
+
+Examples Requesting a username and password for L2TP network
+
+ RequestInput("/vpn1",
+ { "Username" : { "Type" : "string",
+ "Requirement" : "mandatory"
+ } }
+ { "Password" : { "Type" : "password",
+ "Requirement" : "mandatory"
+ } }
+ { "SaveCredentials" : { "Type" : "boolean",
+ "Requirement" : "optional"
+ }
+ }
+ ==> { "Username" : "foo", "Password" : "secret123",
+ "SaveCredentials" : true }
+
+ Requesting a OpenConnect cookie
+
+ RequestInput("/vpn2",
+ { "OpenConnect.Cookie" : { "Type" : "string",
+ "Requirement" : "mandatory"
+ } }
+ { "Host" : { "Type" : "string",
+ "Requirement" : "informational"
+ } }
+ { "Name" : { "Type" : "string",
+ "Requirement" : "informational"
+ } }
+ ==> { "OpenConnect.Cookie" : "0123456@adfsf@asasdf" }
diff --git a/doc/vpn-config-format.txt b/doc/vpn-config-format.txt
new file mode 100644
index 0000000..23c9c14
--- /dev/null
+++ b/doc/vpn-config-format.txt
@@ -0,0 +1,235 @@
+Connman configuration file format for VPN
+*****************************************
+
+Connman VPN uses configuration files to provision existing providers.
+vpnd will be looking for its configuration files at VPN_STORAGEDIR
+which by default points to /var/lib/connman-vpn. Configuration file names
+must not include other characters than letters or numbers and must have
+a .config suffix. Those configuration files are text files with a simple
+key-value pair format organized into sections. Values do not comprise leading
+trailing whitespace. We typically have one file per provisioned network.
+
+If the config file is removed, then vpnd tries to remove the
+provisioned service. If an individual service entry inside a config is removed,
+then the corresponding provisioned service is removed. If a service
+section is changed, then the corresponding service is removed and immediately
+re-provisioned.
+
+
+Global section [global]
+=======================
+
+These files can have an optional global section describing the actual file.
+The two allowed fields for this section are:
+- Name: Name of the network.
+- Description: Description of the network.
+
+
+Provider section [provider_*]
+=============================
+
+Each provisioned provider must start with the [provider_*] tag.
+Replace * with an identifier unique to the config file.
+
+Allowed fields:
+- Type: Provider type. Value of OpenConnect, OpenVPN, VPNC, L2TP or PPTP
+
+VPN related parameters (M = mandatory, O = optional):
+- Name: A user defined name for the VPN (M)
+- Host: VPN server IP address (M)
+- Domain: Domain name for the VPN service (M)
+- Networks: The networks behind the VPN link can be defined here. This can
+ be missing if all traffic should go via VPN tunnel. If there are more
+ than one network, then separate them by comma. Format of the entry
+ is network/netmask/gateway. The gateway can be left out. (O)
+ Example: 192.168.100.0/24/10.1.0.1,192.168.200.0/255.255.255.0/10.1.0.2
+ For IPv6 addresses only prefix length is accepted like this 2001:db8::1/64
+
+OpenConnect VPN supports following options (see openconnect(8) for details):
+ Option name OpenConnect option Description
+ OpenConnect.ServerCert --servercert SHA1 certificate fingerprint of the
+ final VPN server after possible web
+ authentication login, selection and
+ redirection (O)
+ OpenConnect.CACert --cafile File containing other Certificate
+ Authorities in addition to the ones
+ in the system trust database (O)
+ OpenConnect.ClientCert --certificate Client certificate file, if needed
+ by web authentication (O)
+ VPN.MTU --mtu Request MTU from server as the MTU
+ of the tunnel (O)
+ OpenConnect.Cookie --cookie-on-stdin Cookie received as a result of the
+ web authentication. As the cookie
+ lifetime can be very limited, it
+ does not usually make sense to add
+ it into the configuration file (O)
+ OpenConnect.VPNHost The final VPN server to use after
+ completing the web authentication.
+ Only usable for extremely simple VPN
+ configurations and should normally
+ be set only via the VPN Agent API.
+If OpenConnect.Cookie or OpenConnect.ServerCert are missing, the VPN Agent will
+be contacted to supply the information.
+
+OpenVPN VPN supports following options (see openvpn(8) for details):
+ Option name OpenVPN option Description
+ OpenVPN.CACert --ca Certificate authority file (M)
+ OpenVPN.Cert --cert Local peer's signed certificate (M)
+ OpenVPN.Key --key Local peer's private key (M)
+ OpenVPN.MTU --mtu MTU of the tunnel (O)
+ OpenVPN.NSCertType --ns-cert-type Peer certificate type, value of
+ either server or client (O)
+ OpenVPN.Proto --proto Use protocol (O)
+ OpenVPN.Port --port TCP/UDP port number (O)
+ OpenVPN.AuthUserPass --auth-user-pass Authenticate with server using
+ username/password (O)
+ OpenVPN.AskPass --askpass Get certificate password from file (O)
+ OpenVPN.AuthNoCache --auth-nocache Don't cache --askpass or
+ --auth-user-pass value (O)
+ OpenVPN.TLSRemote --tls-remote Accept connections only from a host
+ with X509 name or common name equal
+ to name parameter (O)
+ OpenVPN.TLSAuth sub-option of --tls-remote (O)
+ OpenVPN.TLSAuthDir sub-option of --tls-remote (O)
+ OpenVPN.Cipher --cipher Encrypt packets with cipher algorithm
+ given as parameter (O)
+ OpenVPN.Auth --auth Authenticate packets with HMAC using
+ message digest algorithm alg (O)
+ OpenVPN.CompLZO --comp-lzo Use fast LZO compression. Value can
+ be "yes", "no", or "adaptive". Default
+ is adaptive (O)
+ OpenVPN.RemoteCertTls --remote-cert-tls Require that peer certificate was
+ signed based on RFC3280 TLS rules.
+ Value is "client" or "server" (O)
+ OpenVPN.ConfigFile --config OpenVPN config file that can contain
+ extra options not supported by OpenVPN
+ plugin (O)
+
+VPNC VPN supports following options (see vpnc(8) for details):
+ Option name VPNC config value Description
+ VPNC.IPSec.ID IPSec ID your group username (M)
+ VPNC.IPSec.Secret IPSec secret your group password (cleartext) (O)
+ VPNC.Xauth.Username Xauth username your username (O)
+ VPNC.Xauth.Password Xauth password your password (cleartext) (O)
+ VPNC.IKE.Authmode IKE Authmode IKE Authentication mode (O)
+ VPNC.IKE.DHGroup IKE DH Group name of the IKE DH Group (O)
+ VPNC.PFS Perfect Forward Secrecy Diffie-Hellman group to use for PFS (O)
+ VPNC.Domain Domain Domain name for authentication (O)
+ VPNC.Vendor Vendor vendor of your IPSec gateway (O)
+ VPNC.LocalPort Local Port local ISAKMP port number to use
+ VPNC.CiscoPort Cisco UDP Encapsulation Port Local UDP port number to use (O)
+ VPNC.AppVersion Application Version Application Version to report (O)
+ VPNC.NATTMode NAT Traversal Mode Which NAT-Traversal Method to use (O)
+ VPNC.DPDTimeout DPD idle timeout (our side) Send DPD packet after timeout (O)
+ VPNC.SingleDES Enable Single DES enables single DES encryption (O)
+ VPNC.NoEncryption Enable no encryption enables using no encryption for data traffic (O)
+
+L2TP VPN supports following options (see xl2tpd.conf(5) and pppd(8) for details)
+ Option name xl2tpd config value Description
+ L2TP.User - L2TP user name, asked from the user
+ if not set here (O)
+ L2TP.Password - L2TP password, asked from the user
+ if not set here (O)
+ L2TP.BPS bps Max bandwith to use (O)
+ L2TP.TXBPS tx bps Max transmit bandwith to use (O)
+ L2TP.RXBPS rx bps Max receive bandwith to use (O)
+ L2TP.LengthBit length bit Use length bit (O)
+ L2TP.Challenge challenge Use challenge authentication (O)
+ L2TP.DefaultRoute defaultroute Default route (O)
+ L2TP.FlowBit flow bit Use seq numbers (O)
+ L2TP.TunnelRWS tunnel rws Window size (O)
+ L2TP.Exclusive exclusive Use only one control channel (O)
+ L2TP.Redial redial Redial if disconnected (O)
+ L2TP.RedialTimeout redial timeout Redial timeout (O)
+ L2TP.MaxRedials max redials How many times to try redial (O)
+ L2TP.RequirePAP require pap Need pap (O)
+ L2TP.RequireCHAP require chap Need chap (O)
+ L2TP.ReqAuth require authentication Need auth (O)
+ L2TP.AccessControl access control Accept only these peers (O)
+ L2TP.AuthFile auth file Authentication file location (O)
+ L2TP.ListenAddr listen-addr Listen address (O)
+ L2TP.IPsecSaref ipsec saref Use IPSec SA (O)
+ L2TP.Port port What UDP port is used (O)
+
+ Option name pppd config value Description
+ PPPD.EchoFailure lcp-echo-failure Dead peer check count (O)
+ PPPD.EchoInterval lcp-echo-interval Dead peer check interval (O)
+ PPPD.Debug debug Debug level (O)
+ PPPD.RefuseEAP refuse-eap Deny eap auth (O)
+ PPPD.RefusePAP refuse-pap Deny pap auth (O)
+ PPPD.RefuseCHAP refuse-chap Deny chap auth (O)
+ PPPD.RefuseMSCHAP refuse-mschap Deny mschap auth (O)
+ PPPD.RefuseMSCHAP2 refuse-mschapv2 Deny mschapv2 auth (O)
+ PPPD.NoBSDComp nobsdcomp Disables BSD compression (O)
+ PPPD.NoPcomp nopcomp Disable protocol compression (O)
+ PPPD.UseAccomp accomp Disable address/control compression (O)
+ PPPD.NoDeflate nodeflate Disable deflate compression (O)
+ PPPD.ReqMPPE require-mppe Require the use of MPPE (O)
+ PPPD.ReqMPPE40 require-mppe-40 Require the use of MPPE 40 bit (O)
+ PPPD.ReqMPPE128 require-mppe-128 Require the use of MPPE 128 bit (O)
+ PPPD.ReqMPPEStateful mppe-stateful Allow MPPE to use stateful mode (O)
+ PPPD.NoVJ no-vj-comp No Van Jacobson compression (O)
+
+
+PPTP VPN supports following options (see pptp(8) and pppd(8) for details)
+ Option name pptp config value Description
+ PPTP.User - PPTP user name, asked from the user
+ if not set here (O)
+ PPTP.Password - PPTP password, asked from the user
+ if not set here (O)
+
+ Option name pppd config value Description
+ PPPD.EchoFailure lcp-echo-failure Dead peer check count (O)
+ PPPD.EchoInterval lcp-echo-interval Dead peer check interval (O)
+ PPPD.Debug debug Debug level (O)
+ PPPD.RefuseEAP refuse-eap Deny eap auth (O)
+ PPPD.RefusePAP refuse-pap Deny pap auth (O)
+ PPPD.RefuseCHAP refuse-chap Deny chap auth (O)
+ PPPD.RefuseMSCHAP refuse-mschap Deny mschap auth (O)
+ PPPD.RefuseMSCHAP2 refuse-mschapv2 Deny mschapv2 auth (O)
+ PPPD.NoBSDComp nobsdcomp Disables BSD compression (O)
+ PPPD.NoDeflate nodeflate Disable deflate compression (O)
+ PPPD.RequirMPPE require-mppe Require the use of MPPE (O)
+ PPPD.RequirMPPE40 require-mppe-40 Require the use of MPPE 40 bit (O)
+ PPPD.RequirMPPE128 require-mppe-128 Require the use of MPPE 128 bit (O)
+ PPPD.RequirMPPEStateful mppe-stateful Allow MPPE to use stateful mode (O)
+ PPPD.NoVJ no-vj-comp No Van Jacobson compression (O)
+
+
+Example
+=======
+
+This is a configuration file for a VPN providing L2TP, OpenVPN and
+OpenConnect services.
+
+
+example@example:[~]$ cat /var/lib/connman/vpn/example.config
+[global]
+Name = Example
+Description = Example VPN configuration
+
+[provider_l2tp]
+Type = L2TP
+Name = Connection to corporate network
+Host = 1.2.3.4
+Domain = corporate.com
+Networks = 10.10.30.0/24
+L2TP.User = username
+
+[provider_openconnect]
+Type = OpenConnect
+Name = Connection to corporate network using Cisco VPN
+Host = 7.6.5.4
+Domain = corporate.com
+Networks = 10.10.20.0/255.255.255.0/10.20.1.5,192.168.99.1/24,2001:db8::1/64
+OpenConnect.ServerCert = 263AFAB4CB2E6621D12E90182008AEF44AEFA031
+OpenConnect.CACert = /etc/certs/certificate.p12
+
+[provider_openvpn]
+Type = OpenVPN
+Name = Connection to corporate network using OpenVPN
+Host = 3.2.5.6
+Domain = my.home.network
+OpenVPN.CACert = /etc/certs/cacert.pem
+OpenVPN.Cert = /etc/certs/cert.pem
+OpenVPN.Key = /etc/certs/cert.key
diff --git a/doc/vpn-connection-api.txt b/doc/vpn-connection-api.txt
new file mode 100644
index 0000000..4367699
--- /dev/null
+++ b/doc/vpn-connection-api.txt
@@ -0,0 +1,181 @@
+vpn connection
+==============
+
+Service net.connman.vpn
+Interface net.connman.vpn.Connection
+Object path [variable prefix]/{connection0,connection1,...}
+
+Methods dict GetProperties() [experimental]
+
+ Returns properties for the connection object. See
+ the properties section for available properties.
+
+ Possible Errors: [connection].Error.InvalidArguments
+
+ void SetProperty(string name, variant value) [experimental]
+
+ Changes the value of the specified property. Only
+ properties that are listed as read-write are
+ changeable. On success a PropertyChanged signal
+ will be emitted.
+
+ Possible Errors: [connection].Error.InvalidArguments
+ [connection].Error.InvalidProperty
+
+ void ClearProperty(string name) [experimental]
+
+ Clears the value of the specified property.
+
+ Possible Errors: [connection].Error.InvalidArguments
+ [connection].Error.InvalidProperty
+
+ void Connect() [experimental]
+
+ Connect this VPN connection. It will attempt to connect
+ to the VPN connection. The Connect() will wait until
+ the connection is created or there is an error. The
+ error description is returned in dbus error.
+
+ Possible Errors: [connection].Error.InvalidArguments
+ [connection].Error.InProgress
+
+ void Disconnect() [experimental]
+
+ Disconnect this VPN connection. If the connection is
+ not connected an error message will be generated.
+
+ Possible Errors: [connection].Error.InvalidArguments
+
+Signals PropertyChanged(string name, variant value) [experimental]
+
+ This signal indicates a changed value of the given
+ property.
+
+Properties string State [readonly]
+
+ The connection state information.
+
+ Valid states are "idle", "failure", "configuration",
+ "ready", "disconnect".
+
+ string Type [readonly]
+
+ The VPN type (for example "openvpn", "vpnc" etc.)
+
+ string Name [readonly]
+
+ The VPN name.
+
+ string Domain [readonly]
+
+ The domain name used behind the VPN connection.
+ This is optional for most VPN technologies.
+
+ string Host [readonly]
+
+ The VPN host (server) address.
+
+ boolean Immutable [readonly]
+
+ This value will be set to true if the connection is
+ configured externally via a configuration file.
+
+ The only valid operation are Connect(), Disconnect()
+ and GetProperties()
+
+ int Index [readonly]
+
+ The index of the VPN network tunneling interface.
+ If there is no tunneling device, then this value
+ is not returned.
+
+ dict IPv4 [readonly]
+
+ string Address
+
+ The current configured IPv4 address.
+
+ string Netmask
+
+ The current configured IPv4 netmask.
+
+ string Gateway
+
+ The current configured IPv4 gateway.
+
+ string Peer
+
+ The current configured VPN tunnel endpoint
+ IPv4 address.
+
+ dict IPv6 [readonly]
+
+ string Address
+
+ The current configured IPv6 address.
+
+ string PrefixLength
+
+ The prefix length of the IPv6 address.
+
+ string Gateway
+
+ The current configured IPv6 gateway.
+
+ string Peer
+
+ The current configured VPN tunnel endpoint
+ IPv6 address.
+
+ array{string} Nameservers [readonly]
+
+ The list of nameservers set by VPN.
+
+ array{dict} UserRoutes [readwrite]
+
+ int ProtocolFamily
+
+ Protocol family of the route. Set to 4
+ if IPv4 and 6 if IPv6 route.
+
+ string Network
+
+ The network part of the route.
+
+ string Netmask
+
+ The netmask of the route.
+
+ string Gateway
+
+ Gateway address of the route.
+
+ The list of currently active user activated
+ routes.
+
+ array{dict} ServerRoutes [readonly]
+
+ int ProtocolFamily
+
+ Protocol family of the route. Set to 4
+ if IPv4 and 6 if IPv6 route.
+
+ string Network
+
+ The network part of the route.
+
+ string Netmask
+
+ The netmask of the route.
+
+ string Gateway
+
+ Gateway address of the route.
+
+ The VPN server activated route. These routes
+ are pushed to connman by VPN server.
+
+ There can be other properties also but as the VPN
+ technologies are so different, they have different
+ kind of options that they need, so not all options
+ are mentioned in this document.
diff --git a/doc/vpn-manager-api.txt b/doc/vpn-manager-api.txt
new file mode 100644
index 0000000..66c5bee
--- /dev/null
+++ b/doc/vpn-manager-api.txt
@@ -0,0 +1,50 @@
+vpn manager
+===========
+
+Service net.connman.vpn
+Interface net.connman.vpn.Manager
+Object path /
+
+Method object Create(dict settings) [experimental]
+
+ Create a new VPN connection and configuration using
+ the supplied settings.
+
+ void Remove(object vpn) [experimental]
+
+ Remove the previously created VPN configuration.
+
+ array{object,dict} GetConnections() [experimental]
+
+ Returns a list of tuples with VPN connection object
+ path and dictionary of their properties.
+
+ Possible Errors: [manager].Error.InvalidArguments
+
+ void RegisterAgent(object path) [experimental]
+
+ Register new agent for handling user requests.
+
+ Possible Errors: [manager].Error.InvalidArguments
+
+ void UnregisterAgent(object path) [experimental]
+
+ Unregister an existing agent.
+
+ Possible Errors: [manager].Error.InvalidArguments
+
+Signals ConnectionAdded(object path, dict properties) [experimental]
+
+ Signal that is sent when a new VPN connection
+ is added.
+
+ It contains the object path of the VPN connection
+ and also its properties.
+
+ ConnectionRemoved(object path) [experimental]
+
+ Signal that is sent when a VPN connection
+ has been removed.
+
+ The object path is no longer accessible after this
+ signal and only emitted for reference.
diff --git a/doc/vpn-overview.txt b/doc/vpn-overview.txt
new file mode 100644
index 0000000..42b6e94
--- /dev/null
+++ b/doc/vpn-overview.txt
@@ -0,0 +1,60 @@
+VPN daemon overview
+*******************
+
+
+Manager interface
+=================
+
+Manager interface described in vpn-manager-api.txt is to be used
+by both the connectivity UI and by ConnMan. The Create(),
+Remove(), RegisterAgent() and UnregisterAgent() functions are for
+UI usage. The GetConnections() method and ConnectionAdded() and
+ConnectionRemoved() signals are for ConnMan VPN plugin to use.
+
+The UI should use the methods like this:
+- Ask VPN properties (like certs, usernames etc) from the user.
+- Call Manager.Create() to create a VPN connection (note that
+ the system does not yet try to connect to VPN at this point)
+- Register an agent to vpnd so that vpnd can ask any extra
+ parameters etc from the user if needed.
+- If the user wants to connect to VPN gateway, then the
+ connection attempt should be done in ConnMan side as
+ there will be a service created there.
+- If the user wishes to remove the VPN configuration, the UI
+ can call the Manager.Remove() which removes the VPN connection.
+ If the VPN was in use, the VPN connection is also disconnected.
+- When UI is terminated, the UI should call the UnregisterAgent()
+
+The ConnMan calls VPN daemon like this:
+- There is a VPN plugin which at startup starts to listen the
+ ConnectionAdded() and ConnectionRemoved() signals.
+- The VPN plugin will call GetConnections() in order to get
+ available VPN connections. It will then create a provider service
+ for each VPN connection that is returned.
+- User can then connect to the VPN by calling the service Connect()
+ method
+- The existing ConnMan Manager.ConnectProvider() interface can still
+ work by calling vpn.Manager.Create() and then call vpn.Connection.Connect()
+ but this ConnectProvider() interface will be deprecated at some
+ point.
+
+
+
+Connection interface
+====================
+
+The Manager.Create() will return the object path of the created
+vpn.Connection object and place it in idle state. Note that
+vpn.Connection.PropertyChanged signal is not called when Connection
+object is created because the same parameters are returned via
+vpn.Manager.ConnectionAdded() signal.
+The vpn.Connection object can be connected using the Connect() method
+and disconnected by calling Disconnect() method. When the connection
+is established (meaning VPN client has managed to create a connection
+to VPN server), then State property is set to "ready" and PropertyChanged
+signal is sent. If the connection cannot be established, then
+State property is set to "failure".
+After successfull connection, the relevant connection properties are sent
+by PropertyChanged signal; like IPv[4|6] information, the index of the
+VPN tunneling interface (if there is any), nameserver information,
+server specified routes etc.
diff --git a/doc/wifi-p2p-overview.txt b/doc/wifi-p2p-overview.txt
new file mode 100644
index 0000000..73b677c
--- /dev/null
+++ b/doc/wifi-p2p-overview.txt
@@ -0,0 +1,54 @@
+WiFi P2P Functionality [experimental]
+*************************************
+
+Note: Nothing about WiFi P2P Services is exposed, this is yet to be specified.
+
+Summary
+=======
+
+WiFi P2P is supported as follows:
+- if hardware and wpa_supplicant supports it, a "p2p" technology will appear
+ in the technology list
+- "p2p" technology, as for "wifi" technology, supports a Scan() method. Such
+ method will trigger a P2P find process. The results will be available
+ through the Manager interface, comparable to services being available
+ through this same interface after a Scan() on "wifi" technology.
+- the result of a "p2p" Scan() consists into a list of "peer" objects
+- it is then possible to access peer information, connecting and disconnecting
+ it via the Peer API.
+
+
+API Usage
+=========
+
+The UI willing to access to WiFi P2P technology should proceed this way:
+- Request Manager.GetTechnologies() and figure out from the result if "p2p"
+ technology is provided. What comes next implies this successful case.
+- Add a listener to signal Manager.PeersChanged(): this signal will provide
+ the results of a "p2p" technology Scan().
+- From the "p2p" technology object, request a Technology.Scan() method. This
+ will run for a while a P2P find process.
+- If P2P peers are found, it will be signaled through Manager.PeersChanged().
+ Objects are "Peer" objects. UI might use Manager.GetPeers() instead, if
+ listening to a signal is not the preferred way.
+- Once selected the proper Peer object, request a Peer.Connect() method on it
+ so it will connect to it. Peer.Disconnect() will disconnect.
+
+Internals
+=========
+
+Through such API, everything is made to hide irrelevant informations for the
+applications, which are:
+
+- Everything related to the P2P group and the Group Owner (GO)
+- All low level peer settings
+- All Service Request Discovery mechanism
+
+Hiding this mean ConnMan will handle it properly behind.
+
+For instance, if you connect to a Peer which happens to be a persistent GO
+ConnMan will notice it and store the Group information for a later connection
+to speed up such connection.
+
+For Service Discovery (SD), this will be handled the same way: silently
+behind, by ConnMan.
diff --git a/gdbus/client.c b/gdbus/client.c
new file mode 100644
index 0000000..48711ae
--- /dev/null
+++ b/gdbus/client.c
@@ -0,0 +1,1398 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <glib.h>
+#include <dbus/dbus.h>
+
+#include "gdbus.h"
+
+#define METHOD_CALL_TIMEOUT (300 * 1000)
+
+#ifndef DBUS_INTERFACE_OBJECT_MANAGER
+#define DBUS_INTERFACE_OBJECT_MANAGER DBUS_INTERFACE_DBUS ".ObjectManager"
+#endif
+
+struct GDBusClient {
+ int ref_count;
+ DBusConnection *dbus_conn;
+ char *service_name;
+ char *base_path;
+ char *root_path;
+ guint watch;
+ guint added_watch;
+ guint removed_watch;
+ GPtrArray *match_rules;
+ DBusPendingCall *pending_call;
+ DBusPendingCall *get_objects_call;
+ GDBusWatchFunction connect_func;
+ void *connect_data;
+ GDBusWatchFunction disconn_func;
+ gboolean connected;
+ void *disconn_data;
+ GDBusMessageFunction signal_func;
+ void *signal_data;
+ GDBusProxyFunction proxy_added;
+ GDBusProxyFunction proxy_removed;
+ GDBusClientFunction ready;
+ void *ready_data;
+ GDBusPropertyFunction property_changed;
+ void *user_data;
+ GList *proxy_list;
+};
+
+struct GDBusProxy {
+ int ref_count;
+ GDBusClient *client;
+ char *obj_path;
+ char *interface;
+ GHashTable *prop_list;
+ guint watch;
+ GDBusPropertyFunction prop_func;
+ void *prop_data;
+ GDBusProxyFunction removed_func;
+ void *removed_data;
+};
+
+struct prop_entry {
+ char *name;
+ int type;
+ DBusMessage *msg;
+};
+
+static void modify_match_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ DBusError error;
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply) == TRUE)
+ dbus_error_free(&error);
+
+ dbus_message_unref(reply);
+}
+
+static gboolean modify_match(DBusConnection *conn, const char *member,
+ const char *rule)
+{
+ DBusMessage *msg;
+ DBusPendingCall *call;
+
+ msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS, member);
+ if (msg == NULL)
+ return FALSE;
+
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &rule,
+ DBUS_TYPE_INVALID);
+
+ if (g_dbus_send_message_with_reply(conn, msg, &call, -1) == FALSE) {
+ dbus_message_unref(msg);
+ return FALSE;
+ }
+
+ dbus_pending_call_set_notify(call, modify_match_reply, NULL, NULL);
+ dbus_pending_call_unref(call);
+
+ dbus_message_unref(msg);
+
+ return TRUE;
+}
+
+static void iter_append_iter(DBusMessageIter *base, DBusMessageIter *iter)
+{
+ int type;
+
+ type = dbus_message_iter_get_arg_type(iter);
+
+ if (dbus_type_is_basic(type)) {
+ const void *value;
+
+ dbus_message_iter_get_basic(iter, &value);
+ dbus_message_iter_append_basic(base, type, &value);
+ } else if (dbus_type_is_container(type)) {
+ DBusMessageIter iter_sub, base_sub;
+ char *sig;
+
+ dbus_message_iter_recurse(iter, &iter_sub);
+
+ switch (type) {
+ case DBUS_TYPE_ARRAY:
+ case DBUS_TYPE_VARIANT:
+ sig = dbus_message_iter_get_signature(&iter_sub);
+ break;
+ default:
+ sig = NULL;
+ break;
+ }
+
+ dbus_message_iter_open_container(base, type, sig, &base_sub);
+
+ if (sig != NULL)
+ dbus_free(sig);
+
+ while (dbus_message_iter_get_arg_type(&iter_sub) !=
+ DBUS_TYPE_INVALID) {
+ iter_append_iter(&base_sub, &iter_sub);
+ dbus_message_iter_next(&iter_sub);
+ }
+
+ dbus_message_iter_close_container(base, &base_sub);
+ }
+}
+
+static void prop_entry_update(struct prop_entry *prop, DBusMessageIter *iter)
+{
+ DBusMessage *msg;
+ DBusMessageIter base;
+
+ msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_RETURN);
+ if (msg == NULL)
+ return;
+
+ dbus_message_iter_init_append(msg, &base);
+ iter_append_iter(&base, iter);
+
+ if (prop->msg != NULL)
+ dbus_message_unref(prop->msg);
+
+ prop->msg = dbus_message_copy(msg);
+ dbus_message_unref(msg);
+}
+
+static struct prop_entry *prop_entry_new(const char *name,
+ DBusMessageIter *iter)
+{
+ struct prop_entry *prop;
+
+ prop = g_try_new0(struct prop_entry, 1);
+ if (prop == NULL)
+ return NULL;
+
+ prop->name = g_strdup(name);
+ prop->type = dbus_message_iter_get_arg_type(iter);
+
+ prop_entry_update(prop, iter);
+
+ return prop;
+}
+
+static void prop_entry_free(gpointer data)
+{
+ struct prop_entry *prop = data;
+
+ if (prop->msg != NULL)
+ dbus_message_unref(prop->msg);
+
+ g_free(prop->name);
+
+ g_free(prop);
+}
+
+static void add_property(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, gboolean send_changed)
+{
+ GDBusClient *client = proxy->client;
+ DBusMessageIter value;
+ struct prop_entry *prop;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_VARIANT)
+ return;
+
+ dbus_message_iter_recurse(iter, &value);
+
+ prop = g_hash_table_lookup(proxy->prop_list, name);
+ if (prop != NULL) {
+ prop_entry_update(prop, &value);
+ goto done;
+ }
+
+ prop = prop_entry_new(name, &value);
+ if (prop == NULL)
+ return;
+
+ g_hash_table_replace(proxy->prop_list, prop->name, prop);
+
+done:
+ if (proxy->prop_func)
+ proxy->prop_func(proxy, name, &value, proxy->prop_data);
+
+ if (client == NULL || send_changed == FALSE)
+ return;
+
+ if (client->property_changed)
+ client->property_changed(proxy, name, &value,
+ client->user_data);
+}
+
+static void update_properties(GDBusProxy *proxy, DBusMessageIter *iter,
+ gboolean send_changed)
+{
+ DBusMessageIter dict;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+ const char *name;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &name);
+ dbus_message_iter_next(&entry);
+
+ add_property(proxy, name, &entry, send_changed);
+
+ dbus_message_iter_next(&dict);
+ }
+}
+
+static void get_all_properties_reply(DBusPendingCall *call, void *user_data)
+{
+ GDBusProxy *proxy = user_data;
+ GDBusClient *client = proxy->client;
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ DBusMessageIter iter;
+ DBusError error;
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply) == TRUE) {
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ dbus_message_iter_init(reply, &iter);
+
+ update_properties(proxy, &iter, FALSE);
+
+done:
+ if (g_list_find(client->proxy_list, proxy) == NULL) {
+ if (client->proxy_added)
+ client->proxy_added(proxy, client->user_data);
+
+ client->proxy_list = g_list_append(client->proxy_list, proxy);
+ }
+
+ dbus_message_unref(reply);
+
+ g_dbus_client_unref(client);
+}
+
+static void get_all_properties(GDBusProxy *proxy)
+{
+ GDBusClient *client = proxy->client;
+ const char *service_name = client->service_name;
+ DBusMessage *msg;
+ DBusPendingCall *call;
+
+ msg = dbus_message_new_method_call(service_name, proxy->obj_path,
+ DBUS_INTERFACE_PROPERTIES, "GetAll");
+ if (msg == NULL)
+ return;
+
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &proxy->interface,
+ DBUS_TYPE_INVALID);
+
+ if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+ &call, -1) == FALSE) {
+ dbus_message_unref(msg);
+ return;
+ }
+
+ g_dbus_client_ref(client);
+
+ dbus_pending_call_set_notify(call, get_all_properties_reply,
+ proxy, NULL);
+ dbus_pending_call_unref(call);
+
+ dbus_message_unref(msg);
+}
+
+static GDBusProxy *proxy_lookup(GDBusClient *client, const char *path,
+ const char *interface)
+{
+ GList *list;
+
+ for (list = g_list_first(client->proxy_list); list;
+ list = g_list_next(list)) {
+ GDBusProxy *proxy = list->data;
+
+ if (g_str_equal(proxy->interface, interface) == TRUE &&
+ g_str_equal(proxy->obj_path, path) == TRUE)
+ return proxy;
+ }
+
+ return NULL;
+}
+
+static gboolean properties_changed(DBusConnection *conn, DBusMessage *msg,
+ void *user_data)
+{
+ GDBusProxy *proxy = user_data;
+ GDBusClient *client = proxy->client;
+ DBusMessageIter iter, entry;
+ const char *interface;
+
+ if (dbus_message_iter_init(msg, &iter) == FALSE)
+ return TRUE;
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &interface);
+ dbus_message_iter_next(&iter);
+
+ update_properties(proxy, &iter, TRUE);
+
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+ return TRUE;
+
+ dbus_message_iter_recurse(&iter, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *name;
+
+ dbus_message_iter_get_basic(&entry, &name);
+
+ g_hash_table_remove(proxy->prop_list, name);
+
+ if (proxy->prop_func)
+ proxy->prop_func(proxy, name, NULL, proxy->prop_data);
+
+ if (client->property_changed)
+ client->property_changed(proxy, name, NULL,
+ client->user_data);
+
+ dbus_message_iter_next(&entry);
+ }
+
+ return TRUE;
+}
+
+static GDBusProxy *proxy_new(GDBusClient *client, const char *path,
+ const char *interface)
+{
+ GDBusProxy *proxy;
+
+ proxy = g_try_new0(GDBusProxy, 1);
+ if (proxy == NULL)
+ return NULL;
+
+ proxy->client = client;
+ proxy->obj_path = g_strdup(path);
+ proxy->interface = g_strdup(interface);
+
+ proxy->prop_list = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, prop_entry_free);
+ proxy->watch = g_dbus_add_properties_watch(client->dbus_conn,
+ client->service_name,
+ proxy->obj_path,
+ proxy->interface,
+ properties_changed,
+ proxy, NULL);
+
+ return g_dbus_proxy_ref(proxy);
+}
+
+static void proxy_free(gpointer data)
+{
+ GDBusProxy *proxy = data;
+
+ if (proxy->client) {
+ GDBusClient *client = proxy->client;
+
+ if (client->proxy_removed)
+ client->proxy_removed(proxy, client->user_data);
+
+ g_dbus_remove_watch(client->dbus_conn, proxy->watch);
+
+ g_hash_table_remove_all(proxy->prop_list);
+
+ proxy->client = NULL;
+ }
+
+ if (proxy->removed_func)
+ proxy->removed_func(proxy, proxy->removed_data);
+
+ g_dbus_proxy_unref(proxy);
+}
+
+static void proxy_remove(GDBusClient *client, const char *path,
+ const char *interface)
+{
+ GList *list;
+
+ for (list = g_list_first(client->proxy_list); list;
+ list = g_list_next(list)) {
+ GDBusProxy *proxy = list->data;
+
+ if (g_str_equal(proxy->interface, interface) == TRUE &&
+ g_str_equal(proxy->obj_path, path) == TRUE) {
+ client->proxy_list =
+ g_list_delete_link(client->proxy_list, list);
+ proxy_free(proxy);
+ break;
+ }
+ }
+}
+
+GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path,
+ const char *interface)
+{
+ GDBusProxy *proxy;
+
+ if (client == NULL)
+ return NULL;
+
+ proxy = proxy_lookup(client, path, interface);
+ if (proxy)
+ return g_dbus_proxy_ref(proxy);
+
+ proxy = proxy_new(client, path, interface);
+ if (proxy == NULL)
+ return NULL;
+
+ get_all_properties(proxy);
+
+ return g_dbus_proxy_ref(proxy);
+}
+
+GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy)
+{
+ if (proxy == NULL)
+ return NULL;
+
+ __sync_fetch_and_add(&proxy->ref_count, 1);
+
+ return proxy;
+}
+
+void g_dbus_proxy_unref(GDBusProxy *proxy)
+{
+ if (proxy == NULL)
+ return;
+
+ if (__sync_sub_and_fetch(&proxy->ref_count, 1) > 0)
+ return;
+
+ g_hash_table_destroy(proxy->prop_list);
+
+ g_free(proxy->obj_path);
+ g_free(proxy->interface);
+
+ g_free(proxy);
+}
+
+const char *g_dbus_proxy_get_path(GDBusProxy *proxy)
+{
+ if (proxy == NULL)
+ return NULL;
+
+ return proxy->obj_path;
+}
+
+const char *g_dbus_proxy_get_interface(GDBusProxy *proxy)
+{
+ if (proxy == NULL)
+ return NULL;
+
+ return proxy->interface;
+}
+
+gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter)
+{
+ struct prop_entry *prop;
+
+ if (proxy == NULL || name == NULL)
+ return FALSE;
+
+ prop = g_hash_table_lookup(proxy->prop_list, name);
+ if (prop == NULL)
+ return FALSE;
+
+ if (prop->msg == NULL)
+ return FALSE;
+
+ if (dbus_message_iter_init(prop->msg, iter) == FALSE)
+ return FALSE;
+
+ return TRUE;
+}
+
+struct refresh_property_data {
+ GDBusProxy *proxy;
+ char *name;
+};
+
+static void refresh_property_free(gpointer user_data)
+{
+ struct refresh_property_data *data = user_data;
+
+ g_free(data->name);
+ g_free(data);
+}
+
+static void refresh_property_reply(DBusPendingCall *call, void *user_data)
+{
+ struct refresh_property_data *data = user_data;
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ DBusError error;
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply) == FALSE) {
+ DBusMessageIter iter;
+
+ dbus_message_iter_init(reply, &iter);
+
+ add_property(data->proxy, data->name, &iter, TRUE);
+ } else
+ dbus_error_free(&error);
+
+ dbus_message_unref(reply);
+}
+
+gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name)
+{
+ struct refresh_property_data *data;
+ GDBusClient *client;
+ DBusMessage *msg;
+ DBusMessageIter iter;
+ DBusPendingCall *call;
+
+ if (proxy == NULL || name == NULL)
+ return FALSE;
+
+ client = proxy->client;
+ if (client == NULL)
+ return FALSE;
+
+ data = g_try_new0(struct refresh_property_data, 1);
+ if (data == NULL)
+ return FALSE;
+
+ data->proxy = proxy;
+ data->name = g_strdup(name);
+
+ msg = dbus_message_new_method_call(client->service_name,
+ proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Get");
+ if (msg == NULL) {
+ refresh_property_free(data);
+ return FALSE;
+ }
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
+ &proxy->interface);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+ if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+ &call, -1) == FALSE) {
+ dbus_message_unref(msg);
+ refresh_property_free(data);
+ return FALSE;
+ }
+
+ dbus_pending_call_set_notify(call, refresh_property_reply,
+ data, refresh_property_free);
+ dbus_pending_call_unref(call);
+
+ dbus_message_unref(msg);
+
+ return TRUE;
+}
+
+struct set_property_data {
+ GDBusResultFunction function;
+ void *user_data;
+ GDBusDestroyFunction destroy;
+};
+
+static void set_property_reply(DBusPendingCall *call, void *user_data)
+{
+ struct set_property_data *data = user_data;
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ DBusError error;
+
+ dbus_error_init(&error);
+
+ dbus_set_error_from_message(&error, reply);
+
+ if (data->function)
+ data->function(&error, data->user_data);
+
+ if (data->destroy)
+ data->destroy(data->user_data);
+
+ dbus_error_free(&error);
+
+ dbus_message_unref(reply);
+}
+
+gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
+ const char *name, int type, const void *value,
+ GDBusResultFunction function, void *user_data,
+ GDBusDestroyFunction destroy)
+{
+ struct set_property_data *data;
+ GDBusClient *client;
+ DBusMessage *msg;
+ DBusMessageIter iter, variant;
+ DBusPendingCall *call;
+ char type_as_str[2];
+
+ if (proxy == NULL || name == NULL || value == NULL)
+ return FALSE;
+
+ if (dbus_type_is_basic(type) == FALSE)
+ return FALSE;
+
+ client = proxy->client;
+ if (client == NULL)
+ return FALSE;
+
+ data = g_try_new0(struct set_property_data, 1);
+ if (data == NULL)
+ return FALSE;
+
+ data->function = function;
+ data->user_data = user_data;
+ data->destroy = destroy;
+
+ msg = dbus_message_new_method_call(client->service_name,
+ proxy->obj_path, DBUS_INTERFACE_PROPERTIES, "Set");
+ if (msg == NULL) {
+ g_free(data);
+ return FALSE;
+ }
+
+ type_as_str[0] = (char) type;
+ type_as_str[1] = '\0';
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
+ &proxy->interface);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ type_as_str, &variant);
+ dbus_message_iter_append_basic(&variant, type, value);
+ dbus_message_iter_close_container(&iter, &variant);
+
+ if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+ &call, -1) == FALSE) {
+ dbus_message_unref(msg);
+ g_free(data);
+ return FALSE;
+ }
+
+ dbus_pending_call_set_notify(call, set_property_reply, data, g_free);
+ dbus_pending_call_unref(call);
+
+ dbus_message_unref(msg);
+
+ return TRUE;
+}
+
+gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
+ const char *name, int type, const void *value,
+ size_t size, GDBusResultFunction function,
+ void *user_data, GDBusDestroyFunction destroy)
+{
+ struct set_property_data *data;
+ GDBusClient *client;
+ DBusMessage *msg;
+ DBusMessageIter iter, variant, array;
+ DBusPendingCall *call;
+ char array_sig[3];
+ char type_sig[2];
+
+ if (!proxy || !name || !value)
+ return FALSE;
+
+ if (!dbus_type_is_basic(type))
+ return FALSE;
+
+ client = proxy->client;
+ if (!client)
+ return FALSE;
+
+ data = g_try_new0(struct set_property_data, 1);
+ if (!data)
+ return FALSE;
+
+ data->function = function;
+ data->user_data = user_data;
+ data->destroy = destroy;
+
+ msg = dbus_message_new_method_call(client->service_name,
+ proxy->obj_path,
+ DBUS_INTERFACE_PROPERTIES,
+ "Set");
+ if (!msg) {
+ g_free(data);
+ return FALSE;
+ }
+
+ array_sig[0] = DBUS_TYPE_ARRAY;
+ array_sig[1] = (char) type;
+ array_sig[2] = '\0';
+
+ type_sig[0] = (char) type;
+ type_sig[1] = '\0';
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING,
+ &proxy->interface);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &name);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ array_sig, &variant);
+
+ dbus_message_iter_open_container(&variant, DBUS_TYPE_ARRAY,
+ type_sig, &array);
+
+ if (dbus_type_is_fixed(type))
+ dbus_message_iter_append_fixed_array(&array, type, &value,
+ size);
+ else if (type == DBUS_TYPE_STRING || type == DBUS_TYPE_OBJECT_PATH) {
+ const char **str = (const char **) value;
+ size_t i;
+
+ for (i = 0; i < size; i++)
+ dbus_message_iter_append_basic(&array, type, &str[i]);
+ }
+
+ dbus_message_iter_close_container(&variant, &array);
+ dbus_message_iter_close_container(&iter, &variant);
+
+ if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+ &call, -1) == FALSE) {
+ dbus_message_unref(msg);
+ g_free(data);
+ return FALSE;
+ }
+
+ dbus_pending_call_set_notify(call, set_property_reply, data, g_free);
+ dbus_pending_call_unref(call);
+
+ dbus_message_unref(msg);
+
+ return TRUE;
+}
+
+struct method_call_data {
+ GDBusReturnFunction function;
+ void *user_data;
+ GDBusDestroyFunction destroy;
+};
+
+static void method_call_reply(DBusPendingCall *call, void *user_data)
+{
+ struct method_call_data *data = user_data;
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+
+ if (data->function)
+ data->function(reply, data->user_data);
+
+ if (data->destroy)
+ data->destroy(data->user_data);
+
+ dbus_message_unref(reply);
+}
+
+gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method,
+ GDBusSetupFunction setup,
+ GDBusReturnFunction function, void *user_data,
+ GDBusDestroyFunction destroy)
+{
+ struct method_call_data *data;
+ GDBusClient *client;
+ DBusMessage *msg;
+ DBusPendingCall *call;
+
+ if (proxy == NULL || method == NULL)
+ return FALSE;
+
+ client = proxy->client;
+ if (client == NULL)
+ return FALSE;
+
+ data = g_try_new0(struct method_call_data, 1);
+ if (data == NULL)
+ return FALSE;
+
+ data->function = function;
+ data->user_data = user_data;
+ data->destroy = destroy;
+
+ msg = dbus_message_new_method_call(client->service_name,
+ proxy->obj_path, proxy->interface, method);
+ if (msg == NULL) {
+ g_free(data);
+ return FALSE;
+ }
+
+ if (setup) {
+ DBusMessageIter iter;
+
+ dbus_message_iter_init_append(msg, &iter);
+ setup(&iter, data->user_data);
+ }
+
+ if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+ &call, METHOD_CALL_TIMEOUT) == FALSE) {
+ dbus_message_unref(msg);
+ g_free(data);
+ return FALSE;
+ }
+
+ dbus_pending_call_set_notify(call, method_call_reply, data, g_free);
+ dbus_pending_call_unref(call);
+
+ dbus_message_unref(msg);
+
+ return TRUE;
+}
+
+gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy,
+ GDBusPropertyFunction function, void *user_data)
+{
+ if (proxy == NULL)
+ return FALSE;
+
+ proxy->prop_func = function;
+ proxy->prop_data = user_data;
+
+ return TRUE;
+}
+
+gboolean g_dbus_proxy_set_removed_watch(GDBusProxy *proxy,
+ GDBusProxyFunction function, void *user_data)
+{
+ if (proxy == NULL)
+ return FALSE;
+
+ proxy->removed_func = function;
+ proxy->removed_data = user_data;
+
+ return TRUE;
+}
+
+static void refresh_properties(GDBusClient *client)
+{
+ GList *list;
+
+ for (list = g_list_first(client->proxy_list); list;
+ list = g_list_next(list)) {
+ GDBusProxy *proxy = list->data;
+
+ get_all_properties(proxy);
+ }
+}
+
+static void parse_properties(GDBusClient *client, const char *path,
+ const char *interface, DBusMessageIter *iter)
+{
+ GDBusProxy *proxy;
+
+ if (g_str_equal(interface, DBUS_INTERFACE_INTROSPECTABLE) == TRUE)
+ return;
+
+ if (g_str_equal(interface, DBUS_INTERFACE_PROPERTIES) == TRUE)
+ return;
+
+ proxy = proxy_lookup(client, path, interface);
+ if (proxy) {
+ update_properties(proxy, iter, FALSE);
+ return;
+ }
+
+ proxy = proxy_new(client, path, interface);
+ if (proxy == NULL)
+ return;
+
+ update_properties(proxy, iter, FALSE);
+
+ if (client->proxy_added)
+ client->proxy_added(proxy, client->user_data);
+
+ client->proxy_list = g_list_append(client->proxy_list, proxy);
+}
+
+static void parse_interfaces(GDBusClient *client, const char *path,
+ DBusMessageIter *iter)
+{
+ DBusMessageIter dict;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+ const char *interface;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &interface);
+ dbus_message_iter_next(&entry);
+
+ parse_properties(client, path, interface, &entry);
+
+ dbus_message_iter_next(&dict);
+ }
+}
+
+static gboolean interfaces_added(DBusConnection *conn, DBusMessage *msg,
+ void *user_data)
+{
+ GDBusClient *client = user_data;
+ DBusMessageIter iter;
+ const char *path;
+
+ if (dbus_message_iter_init(msg, &iter) == FALSE)
+ return TRUE;
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &path);
+ dbus_message_iter_next(&iter);
+
+ g_dbus_client_ref(client);
+
+ parse_interfaces(client, path, &iter);
+
+ g_dbus_client_unref(client);
+
+ return TRUE;
+}
+
+static gboolean interfaces_removed(DBusConnection *conn, DBusMessage *msg,
+ void *user_data)
+{
+ GDBusClient *client = user_data;
+ DBusMessageIter iter, entry;
+ const char *path;
+
+ if (dbus_message_iter_init(msg, &iter) == FALSE)
+ return TRUE;
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_OBJECT_PATH)
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &path);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+ return TRUE;
+
+ dbus_message_iter_recurse(&iter, &entry);
+
+ g_dbus_client_ref(client);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *interface;
+
+ dbus_message_iter_get_basic(&entry, &interface);
+ proxy_remove(client, path, interface);
+ dbus_message_iter_next(&entry);
+ }
+
+ g_dbus_client_unref(client);
+
+ return TRUE;
+}
+
+static void parse_managed_objects(GDBusClient *client, DBusMessage *msg)
+{
+ DBusMessageIter iter, dict;
+
+ if (dbus_message_iter_init(msg, &iter) == FALSE)
+ return;
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+ const char *path;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) !=
+ DBUS_TYPE_OBJECT_PATH)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &path);
+ dbus_message_iter_next(&entry);
+
+ parse_interfaces(client, path, &entry);
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (client->ready)
+ client->ready(client, client->ready_data);
+}
+
+static void get_managed_objects_reply(DBusPendingCall *call, void *user_data)
+{
+ GDBusClient *client = user_data;
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ DBusError error;
+
+ g_dbus_client_ref(client);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply) == TRUE) {
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ parse_managed_objects(client, reply);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(client->get_objects_call);
+ client->get_objects_call = NULL;
+
+ g_dbus_client_unref(client);
+}
+
+static void get_managed_objects(GDBusClient *client)
+{
+ DBusMessage *msg;
+
+ if (!client->connected)
+ return;
+
+ if ((!client->proxy_added && !client->proxy_removed) ||
+ !client->root_path) {
+ refresh_properties(client);
+ return;
+ }
+
+ if (client->get_objects_call != NULL)
+ return;
+
+ msg = dbus_message_new_method_call(client->service_name,
+ client->root_path,
+ DBUS_INTERFACE_OBJECT_MANAGER,
+ "GetManagedObjects");
+ if (msg == NULL)
+ return;
+
+ dbus_message_append_args(msg, DBUS_TYPE_INVALID);
+
+ if (g_dbus_send_message_with_reply(client->dbus_conn, msg,
+ &client->get_objects_call, -1) == FALSE) {
+ dbus_message_unref(msg);
+ return;
+ }
+
+ dbus_pending_call_set_notify(client->get_objects_call,
+ get_managed_objects_reply,
+ client, NULL);
+
+ dbus_message_unref(msg);
+}
+
+static void service_connect(DBusConnection *conn, void *user_data)
+{
+ GDBusClient *client = user_data;
+
+ g_dbus_client_ref(client);
+
+ client->connected = TRUE;
+
+ if (client->connect_func)
+ client->connect_func(conn, client->connect_data);
+
+ get_managed_objects(client);
+
+ g_dbus_client_unref(client);
+}
+
+static void service_disconnect(DBusConnection *conn, void *user_data)
+{
+ GDBusClient *client = user_data;
+
+ client->connected = FALSE;
+
+ g_list_free_full(client->proxy_list, proxy_free);
+ client->proxy_list = NULL;
+
+ if (client->disconn_func)
+ client->disconn_func(conn, client->disconn_data);
+}
+
+static DBusHandlerResult message_filter(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ GDBusClient *client = user_data;
+ const char *sender, *path, *interface;
+
+ if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ sender = dbus_message_get_sender(message);
+ if (sender == NULL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ path = dbus_message_get_path(message);
+ interface = dbus_message_get_interface(message);
+
+ if (g_str_has_prefix(path, client->base_path) == FALSE)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (g_str_equal(interface, DBUS_INTERFACE_PROPERTIES) == TRUE)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (client->signal_func)
+ client->signal_func(connection, message, client->signal_data);
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+GDBusClient *g_dbus_client_new(DBusConnection *connection,
+ const char *service, const char *path)
+{
+ return g_dbus_client_new_full(connection, service, path, "/");
+}
+
+GDBusClient *g_dbus_client_new_full(DBusConnection *connection,
+ const char *service,
+ const char *path,
+ const char *root_path)
+{
+ GDBusClient *client;
+ unsigned int i;
+
+ if (!connection || !service)
+ return NULL;
+
+ client = g_try_new0(GDBusClient, 1);
+ if (client == NULL)
+ return NULL;
+
+ if (dbus_connection_add_filter(connection, message_filter,
+ client, NULL) == FALSE) {
+ g_free(client);
+ return NULL;
+ }
+
+ client->dbus_conn = dbus_connection_ref(connection);
+ client->service_name = g_strdup(service);
+ client->base_path = g_strdup(path);
+ client->root_path = g_strdup(root_path);
+ client->connected = FALSE;
+
+ client->match_rules = g_ptr_array_sized_new(1);
+ g_ptr_array_set_free_func(client->match_rules, g_free);
+
+ client->watch = g_dbus_add_service_watch(connection, service,
+ service_connect,
+ service_disconnect,
+ client, NULL);
+
+ if (!root_path)
+ return g_dbus_client_ref(client);
+
+ client->added_watch = g_dbus_add_signal_watch(connection, service,
+ client->root_path,
+ DBUS_INTERFACE_OBJECT_MANAGER,
+ "InterfacesAdded",
+ interfaces_added,
+ client, NULL);
+ client->removed_watch = g_dbus_add_signal_watch(connection, service,
+ client->root_path,
+ DBUS_INTERFACE_OBJECT_MANAGER,
+ "InterfacesRemoved",
+ interfaces_removed,
+ client, NULL);
+ g_ptr_array_add(client->match_rules, g_strdup_printf("type='signal',"
+ "sender='%s',path_namespace='%s'",
+ client->service_name, client->base_path));
+
+ for (i = 0; i < client->match_rules->len; i++) {
+ modify_match(client->dbus_conn, "AddMatch",
+ g_ptr_array_index(client->match_rules, i));
+ }
+
+ return g_dbus_client_ref(client);
+}
+
+GDBusClient *g_dbus_client_ref(GDBusClient *client)
+{
+ if (client == NULL)
+ return NULL;
+
+ __sync_fetch_and_add(&client->ref_count, 1);
+
+ return client;
+}
+
+void g_dbus_client_unref(GDBusClient *client)
+{
+ unsigned int i;
+
+ if (client == NULL)
+ return;
+
+ if (__sync_sub_and_fetch(&client->ref_count, 1) > 0)
+ return;
+
+ if (client->pending_call != NULL) {
+ dbus_pending_call_cancel(client->pending_call);
+ dbus_pending_call_unref(client->pending_call);
+ }
+
+ if (client->get_objects_call != NULL) {
+ dbus_pending_call_cancel(client->get_objects_call);
+ dbus_pending_call_unref(client->get_objects_call);
+ }
+
+ for (i = 0; i < client->match_rules->len; i++) {
+ modify_match(client->dbus_conn, "RemoveMatch",
+ g_ptr_array_index(client->match_rules, i));
+ }
+
+ g_ptr_array_free(client->match_rules, TRUE);
+
+ dbus_connection_remove_filter(client->dbus_conn,
+ message_filter, client);
+
+ g_list_free_full(client->proxy_list, proxy_free);
+
+ /*
+ * Don't call disconn_func twice if disconnection
+ * was previously reported.
+ */
+ if (client->disconn_func && client->connected)
+ client->disconn_func(client->dbus_conn, client->disconn_data);
+
+ g_dbus_remove_watch(client->dbus_conn, client->watch);
+ g_dbus_remove_watch(client->dbus_conn, client->added_watch);
+ g_dbus_remove_watch(client->dbus_conn, client->removed_watch);
+
+ dbus_connection_unref(client->dbus_conn);
+
+ g_free(client->service_name);
+ g_free(client->base_path);
+ g_free(client->root_path);
+
+ g_free(client);
+}
+
+gboolean g_dbus_client_set_connect_watch(GDBusClient *client,
+ GDBusWatchFunction function, void *user_data)
+{
+ if (client == NULL)
+ return FALSE;
+
+ client->connect_func = function;
+ client->connect_data = user_data;
+
+ return TRUE;
+}
+
+gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client,
+ GDBusWatchFunction function, void *user_data)
+{
+ if (client == NULL)
+ return FALSE;
+
+ client->disconn_func = function;
+ client->disconn_data = user_data;
+
+ return TRUE;
+}
+
+gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
+ GDBusMessageFunction function, void *user_data)
+{
+ if (client == NULL)
+ return FALSE;
+
+ client->signal_func = function;
+ client->signal_data = user_data;
+
+ return TRUE;
+}
+
+gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
+ GDBusClientFunction ready, void *user_data)
+{
+ if (client == NULL)
+ return FALSE;
+
+ client->ready = ready;
+ client->ready_data = user_data;
+
+ return TRUE;
+}
+
+gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
+ GDBusProxyFunction proxy_added,
+ GDBusProxyFunction proxy_removed,
+ GDBusPropertyFunction property_changed,
+ void *user_data)
+{
+ if (client == NULL)
+ return FALSE;
+
+ client->proxy_added = proxy_added;
+ client->proxy_removed = proxy_removed;
+ client->property_changed = property_changed;
+ client->user_data = user_data;
+
+ if (proxy_added || proxy_removed || property_changed)
+ get_managed_objects(client);
+
+ return TRUE;
+}
diff --git a/gdbus/gdbus.h b/gdbus/gdbus.h
new file mode 100644
index 0000000..36b12f4
--- /dev/null
+++ b/gdbus/gdbus.h
@@ -0,0 +1,386 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __GDBUS_H
+#define __GDBUS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <dbus/dbus.h>
+#include <glib.h>
+
+
+typedef struct GDBusArgInfo GDBusArgInfo;
+typedef struct GDBusMethodTable GDBusMethodTable;
+typedef struct GDBusSignalTable GDBusSignalTable;
+typedef struct GDBusPropertyTable GDBusPropertyTable;
+typedef struct GDBusSecurityTable GDBusSecurityTable;
+
+typedef void (* GDBusWatchFunction) (DBusConnection *connection,
+ void *user_data);
+
+typedef void (* GDBusMessageFunction) (DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+typedef gboolean (* GDBusSignalFunction) (DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name,
+ DBusError *error);
+
+DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name,
+ DBusError *error);
+
+gboolean g_dbus_request_name(DBusConnection *connection, const char *name,
+ DBusError *error);
+
+gboolean g_dbus_set_disconnect_function(DBusConnection *connection,
+ GDBusWatchFunction function,
+ void *user_data, DBusFreeFunction destroy);
+
+typedef void (* GDBusDestroyFunction) (void *user_data);
+
+typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+typedef gboolean (*GDBusPropertyGetter)(const GDBusPropertyTable *property,
+ DBusMessageIter *iter, void *data);
+
+typedef guint32 GDBusPendingPropertySet;
+
+typedef void (*GDBusPropertySetter)(const GDBusPropertyTable *property,
+ DBusMessageIter *value, GDBusPendingPropertySet id,
+ void *data);
+
+typedef gboolean (*GDBusPropertyExists)(const GDBusPropertyTable *property,
+ void *data);
+
+typedef guint32 GDBusPendingReply;
+
+typedef void (* GDBusSecurityFunction) (DBusConnection *connection,
+ const char *action,
+ gboolean interaction,
+ GDBusPendingReply pending);
+
+enum GDBusFlags {
+ G_DBUS_FLAG_ENABLE_EXPERIMENTAL = (1 << 0),
+};
+
+enum GDBusMethodFlags {
+ G_DBUS_METHOD_FLAG_NONE = 0,
+ G_DBUS_METHOD_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_METHOD_FLAG_NOREPLY = (1 << 1),
+ G_DBUS_METHOD_FLAG_ASYNC = (1 << 2),
+ G_DBUS_METHOD_FLAG_EXPERIMENTAL = (1 << 3),
+};
+
+enum GDBusSignalFlags {
+ G_DBUS_SIGNAL_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_SIGNAL_FLAG_EXPERIMENTAL = (1 << 1),
+};
+
+enum GDBusPropertyFlags {
+ G_DBUS_PROPERTY_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_PROPERTY_FLAG_EXPERIMENTAL = (1 << 1),
+};
+
+enum GDBusSecurityFlags {
+ G_DBUS_SECURITY_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_SECURITY_FLAG_BUILTIN = (1 << 1),
+ G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION = (1 << 2),
+};
+typedef enum GDBusMethodFlags GDBusMethodFlags;
+typedef enum GDBusSignalFlags GDBusSignalFlags;
+typedef enum GDBusPropertyFlags GDBusPropertyFlags;
+typedef enum GDBusSecurityFlags GDBusSecurityFlags;
+
+struct GDBusArgInfo {
+ const char *name;
+ const char *signature;
+};
+
+struct GDBusMethodTable {
+ const char *name;
+ GDBusMethodFunction function;
+ GDBusMethodFlags flags;
+ unsigned int privilege;
+ const GDBusArgInfo *in_args;
+ const GDBusArgInfo *out_args;
+};
+
+struct GDBusSignalTable {
+ const char *name;
+ GDBusSignalFlags flags;
+ const GDBusArgInfo *args;
+};
+
+struct GDBusPropertyTable {
+ const char *name;
+ const char *type;
+ GDBusPropertyGetter get;
+ GDBusPropertySetter set;
+ GDBusPropertyExists exists;
+ GDBusPropertyFlags flags;
+};
+
+struct GDBusSecurityTable {
+ unsigned int privilege;
+ const char *action;
+ GDBusSecurityFlags flags;
+ GDBusSecurityFunction function;
+};
+
+#define GDBUS_ARGS(args...) (const GDBusArgInfo[]) { args, { } }
+
+#define GDBUS_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function
+
+#define GDBUS_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_ASYNC
+
+#define GDBUS_DEPRECATED_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_DEPRECATED
+
+#define GDBUS_DEPRECATED_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_DEPRECATED
+
+#define GDBUS_EXPERIMENTAL_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_EXPERIMENTAL
+
+#define GDBUS_EXPERIMENTAL_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_EXPERIMENTAL
+
+#define GDBUS_NOREPLY_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_NOREPLY
+
+#define GDBUS_SIGNAL(_name, _args) \
+ .name = _name, \
+ .args = _args
+
+#define GDBUS_DEPRECATED_SIGNAL(_name, _args) \
+ .name = _name, \
+ .args = _args, \
+ .flags = G_DBUS_SIGNAL_FLAG_DEPRECATED
+
+#define GDBUS_EXPERIMENTAL_SIGNAL(_name, _args) \
+ .name = _name, \
+ .args = _args, \
+ .flags = G_DBUS_SIGNAL_FLAG_EXPERIMENTAL
+
+void g_dbus_set_flags(int flags);
+int g_dbus_get_flags(void);
+
+gboolean g_dbus_register_interface(DBusConnection *connection,
+ const char *path, const char *name,
+ const GDBusMethodTable *methods,
+ const GDBusSignalTable *signals,
+ const GDBusPropertyTable *properties,
+ void *user_data,
+ GDBusDestroyFunction destroy);
+gboolean g_dbus_unregister_interface(DBusConnection *connection,
+ const char *path, const char *name);
+
+gboolean g_dbus_register_security(const GDBusSecurityTable *security);
+gboolean g_dbus_unregister_security(const GDBusSecurityTable *security);
+
+void g_dbus_pending_success(DBusConnection *connection,
+ GDBusPendingReply pending);
+void g_dbus_pending_error(DBusConnection *connection,
+ GDBusPendingReply pending,
+ const char *name, const char *format, ...)
+ __attribute__((format(printf, 4, 5)));
+void g_dbus_pending_error_valist(DBusConnection *connection,
+ GDBusPendingReply pending, const char *name,
+ const char *format, va_list args);
+
+DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name,
+ const char *format, ...)
+ __attribute__((format(printf, 3, 4)));
+DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name,
+ const char *format, va_list args);
+DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...);
+DBusMessage *g_dbus_create_reply_valist(DBusMessage *message,
+ int type, va_list args);
+
+gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message);
+gboolean g_dbus_send_message_with_reply(DBusConnection *connection,
+ DBusMessage *message,
+ DBusPendingCall **call, int timeout);
+gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message,
+ const char *name, const char *format, ...)
+ __attribute__((format(printf, 4, 5)));
+gboolean g_dbus_send_error_valist(DBusConnection *connection,
+ DBusMessage *message, const char *name,
+ const char *format, va_list args);
+gboolean g_dbus_send_reply(DBusConnection *connection,
+ DBusMessage *message, int type, ...);
+gboolean g_dbus_send_reply_valist(DBusConnection *connection,
+ DBusMessage *message, int type, va_list args);
+
+gboolean g_dbus_emit_signal(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name, int type, ...);
+gboolean g_dbus_emit_signal_valist(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name, int type, va_list args);
+
+guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
+ GDBusWatchFunction connect,
+ GDBusWatchFunction disconnect,
+ void *user_data, GDBusDestroyFunction destroy);
+guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
+ GDBusWatchFunction function,
+ void *user_data, GDBusDestroyFunction destroy);
+guint g_dbus_add_signal_watch(DBusConnection *connection,
+ const char *sender, const char *path,
+ const char *interface, const char *member,
+ GDBusSignalFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+guint g_dbus_add_properties_watch(DBusConnection *connection,
+ const char *sender, const char *path,
+ const char *interface,
+ GDBusSignalFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+gboolean g_dbus_remove_watch(DBusConnection *connection, guint tag);
+void g_dbus_remove_all_watches(DBusConnection *connection);
+
+void g_dbus_pending_property_success(GDBusPendingPropertySet id);
+void g_dbus_pending_property_error_valist(GDBusPendingReply id,
+ const char *name, const char *format, va_list args);
+void g_dbus_pending_property_error(GDBusPendingReply id, const char *name,
+ const char *format, ...);
+void g_dbus_emit_property_changed(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name);
+gboolean g_dbus_get_properties(DBusConnection *connection, const char *path,
+ const char *interface, DBusMessageIter *iter);
+
+gboolean g_dbus_attach_object_manager(DBusConnection *connection);
+gboolean g_dbus_detach_object_manager(DBusConnection *connection);
+
+typedef struct GDBusClient GDBusClient;
+typedef struct GDBusProxy GDBusProxy;
+
+GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path,
+ const char *interface);
+
+GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy);
+void g_dbus_proxy_unref(GDBusProxy *proxy);
+
+const char *g_dbus_proxy_get_path(GDBusProxy *proxy);
+const char *g_dbus_proxy_get_interface(GDBusProxy *proxy);
+
+gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter);
+
+gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name);
+
+typedef void (* GDBusResultFunction) (const DBusError *error, void *user_data);
+
+gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
+ const char *name, int type, const void *value,
+ GDBusResultFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+
+gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
+ const char *name, int type, const void *value,
+ size_t size, GDBusResultFunction function,
+ void *user_data, GDBusDestroyFunction destroy);
+
+typedef void (* GDBusSetupFunction) (DBusMessageIter *iter, void *user_data);
+typedef void (* GDBusReturnFunction) (DBusMessage *message, void *user_data);
+
+gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method,
+ GDBusSetupFunction setup,
+ GDBusReturnFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+
+typedef void (* GDBusClientFunction) (GDBusClient *client, void *user_data);
+typedef void (* GDBusProxyFunction) (GDBusProxy *proxy, void *user_data);
+typedef void (* GDBusPropertyFunction) (GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data);
+
+gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy,
+ GDBusPropertyFunction function, void *user_data);
+
+gboolean g_dbus_proxy_set_removed_watch(GDBusProxy *proxy,
+ GDBusProxyFunction destroy, void *user_data);
+
+GDBusClient *g_dbus_client_new(DBusConnection *connection,
+ const char *service, const char *path);
+GDBusClient *g_dbus_client_new_full(DBusConnection *connection,
+ const char *service,
+ const char *path,
+ const char *root_path);
+
+GDBusClient *g_dbus_client_ref(GDBusClient *client);
+void g_dbus_client_unref(GDBusClient *client);
+
+gboolean g_dbus_client_set_connect_watch(GDBusClient *client,
+ GDBusWatchFunction function, void *user_data);
+gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client,
+ GDBusWatchFunction function, void *user_data);
+gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
+ GDBusMessageFunction function, void *user_data);
+gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
+ GDBusClientFunction ready, void *user_data);
+gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
+ GDBusProxyFunction proxy_added,
+ GDBusProxyFunction proxy_removed,
+ GDBusPropertyFunction property_changed,
+ void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GDBUS_H */
diff --git a/gdbus/mainloop.c b/gdbus/mainloop.c
new file mode 100644
index 0000000..b90a844
--- /dev/null
+++ b/gdbus/mainloop.c
@@ -0,0 +1,378 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+#include <dbus/dbus.h>
+
+#include "gdbus.h"
+
+#define info(fmt...)
+#define error(fmt...)
+#define debug(fmt...)
+
+struct timeout_handler {
+ guint id;
+ DBusTimeout *timeout;
+};
+
+struct watch_info {
+ guint id;
+ DBusWatch *watch;
+ DBusConnection *conn;
+};
+
+struct disconnect_data {
+ GDBusWatchFunction function;
+ void *user_data;
+};
+
+static gboolean disconnected_signal(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct disconnect_data *dc_data = data;
+
+ error("Got disconnected from the system message bus");
+
+ dc_data->function(conn, dc_data->user_data);
+
+ dbus_connection_unref(conn);
+
+ return TRUE;
+}
+
+static gboolean message_dispatch(void *data)
+{
+ DBusConnection *conn = data;
+
+ /* Dispatch messages */
+ while (dbus_connection_dispatch(conn) == DBUS_DISPATCH_DATA_REMAINS);
+
+ dbus_connection_unref(conn);
+
+ return FALSE;
+}
+
+static inline void queue_dispatch(DBusConnection *conn,
+ DBusDispatchStatus status)
+{
+ if (status == DBUS_DISPATCH_DATA_REMAINS)
+ g_idle_add(message_dispatch, dbus_connection_ref(conn));
+}
+
+static gboolean watch_func(GIOChannel *chan, GIOCondition cond, gpointer data)
+{
+ struct watch_info *info = data;
+ unsigned int flags = 0;
+ DBusDispatchStatus status;
+ DBusConnection *conn;
+
+ if (cond & G_IO_IN) flags |= DBUS_WATCH_READABLE;
+ if (cond & G_IO_OUT) flags |= DBUS_WATCH_WRITABLE;
+ if (cond & G_IO_HUP) flags |= DBUS_WATCH_HANGUP;
+ if (cond & G_IO_ERR) flags |= DBUS_WATCH_ERROR;
+
+ /* Protect connection from being destroyed by dbus_watch_handle */
+ conn = dbus_connection_ref(info->conn);
+
+ dbus_watch_handle(info->watch, flags);
+
+ status = dbus_connection_get_dispatch_status(conn);
+ queue_dispatch(conn, status);
+
+ dbus_connection_unref(conn);
+
+ return TRUE;
+}
+
+static void watch_info_free(void *data)
+{
+ struct watch_info *info = data;
+
+ if (info->id > 0) {
+ g_source_remove(info->id);
+ info->id = 0;
+ }
+
+ dbus_connection_unref(info->conn);
+
+ g_free(info);
+}
+
+static dbus_bool_t add_watch(DBusWatch *watch, void *data)
+{
+ DBusConnection *conn = data;
+ GIOCondition cond = G_IO_HUP | G_IO_ERR;
+ GIOChannel *chan;
+ struct watch_info *info;
+ unsigned int flags;
+ int fd;
+
+ if (!dbus_watch_get_enabled(watch))
+ return TRUE;
+
+ info = g_new0(struct watch_info, 1);
+
+ fd = dbus_watch_get_unix_fd(watch);
+ chan = g_io_channel_unix_new(fd);
+
+ info->watch = watch;
+ info->conn = dbus_connection_ref(conn);
+
+ dbus_watch_set_data(watch, info, watch_info_free);
+
+ flags = dbus_watch_get_flags(watch);
+
+ if (flags & DBUS_WATCH_READABLE) cond |= G_IO_IN;
+ if (flags & DBUS_WATCH_WRITABLE) cond |= G_IO_OUT;
+
+ info->id = g_io_add_watch(chan, cond, watch_func, info);
+
+ g_io_channel_unref(chan);
+
+ return TRUE;
+}
+
+static void remove_watch(DBusWatch *watch, void *data)
+{
+ if (dbus_watch_get_enabled(watch))
+ return;
+
+ /* will trigger watch_info_free() */
+ dbus_watch_set_data(watch, NULL, NULL);
+}
+
+static void watch_toggled(DBusWatch *watch, void *data)
+{
+ /* Because we just exit on OOM, enable/disable is
+ * no different from add/remove */
+ if (dbus_watch_get_enabled(watch))
+ add_watch(watch, data);
+ else
+ remove_watch(watch, data);
+}
+
+static gboolean timeout_handler_dispatch(gpointer data)
+{
+ struct timeout_handler *handler = data;
+
+ handler->id = 0;
+
+ /* if not enabled should not be polled by the main loop */
+ if (!dbus_timeout_get_enabled(handler->timeout))
+ return FALSE;
+
+ dbus_timeout_handle(handler->timeout);
+
+ return FALSE;
+}
+
+static void timeout_handler_free(void *data)
+{
+ struct timeout_handler *handler = data;
+
+ if (handler->id > 0) {
+ g_source_remove(handler->id);
+ handler->id = 0;
+ }
+
+ g_free(handler);
+}
+
+static dbus_bool_t add_timeout(DBusTimeout *timeout, void *data)
+{
+ int interval = dbus_timeout_get_interval(timeout);
+ struct timeout_handler *handler;
+
+ if (!dbus_timeout_get_enabled(timeout))
+ return TRUE;
+
+ handler = g_new0(struct timeout_handler, 1);
+
+ handler->timeout = timeout;
+
+ dbus_timeout_set_data(timeout, handler, timeout_handler_free);
+
+ handler->id = g_timeout_add(interval, timeout_handler_dispatch,
+ handler);
+
+ return TRUE;
+}
+
+static void remove_timeout(DBusTimeout *timeout, void *data)
+{
+ /* will trigger timeout_handler_free() */
+ dbus_timeout_set_data(timeout, NULL, NULL);
+}
+
+static void timeout_toggled(DBusTimeout *timeout, void *data)
+{
+ if (dbus_timeout_get_enabled(timeout))
+ add_timeout(timeout, data);
+ else
+ remove_timeout(timeout, data);
+}
+
+static void dispatch_status(DBusConnection *conn,
+ DBusDispatchStatus status, void *data)
+{
+ if (!dbus_connection_get_is_connected(conn))
+ return;
+
+ queue_dispatch(conn, status);
+}
+
+static inline void setup_dbus_with_main_loop(DBusConnection *conn)
+{
+ dbus_connection_set_watch_functions(conn, add_watch, remove_watch,
+ watch_toggled, conn, NULL);
+
+ dbus_connection_set_timeout_functions(conn, add_timeout, remove_timeout,
+ timeout_toggled, NULL, NULL);
+
+ dbus_connection_set_dispatch_status_function(conn, dispatch_status,
+ NULL, NULL);
+}
+
+static gboolean setup_bus(DBusConnection *conn, const char *name,
+ DBusError *error)
+{
+ gboolean result;
+ DBusDispatchStatus status;
+
+ if (name != NULL) {
+ result = g_dbus_request_name(conn, name, error);
+
+ if (error != NULL) {
+ if (dbus_error_is_set(error) == TRUE)
+ return FALSE;
+ }
+
+ if (result == FALSE)
+ return FALSE;
+ }
+
+ setup_dbus_with_main_loop(conn);
+
+ status = dbus_connection_get_dispatch_status(conn);
+ queue_dispatch(conn, status);
+
+ return TRUE;
+}
+
+DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name,
+ DBusError *error)
+{
+ DBusConnection *conn;
+
+ conn = dbus_bus_get(type, error);
+
+ if (error != NULL) {
+ if (dbus_error_is_set(error) == TRUE)
+ return NULL;
+ }
+
+ if (conn == NULL)
+ return NULL;
+
+ if (setup_bus(conn, name, error) == FALSE) {
+ dbus_connection_unref(conn);
+ return NULL;
+ }
+
+ return conn;
+}
+
+DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name,
+ DBusError *error)
+{
+ DBusConnection *conn;
+
+ conn = dbus_bus_get_private(type, error);
+
+ if (error != NULL) {
+ if (dbus_error_is_set(error) == TRUE)
+ return NULL;
+ }
+
+ if (conn == NULL)
+ return NULL;
+
+ if (setup_bus(conn, name, error) == FALSE) {
+ dbus_connection_close(conn);
+ dbus_connection_unref(conn);
+ return NULL;
+ }
+
+ return conn;
+}
+
+gboolean g_dbus_request_name(DBusConnection *connection, const char *name,
+ DBusError *error)
+{
+ int result;
+
+ result = dbus_bus_request_name(connection, name,
+ DBUS_NAME_FLAG_DO_NOT_QUEUE, error);
+
+ if (error != NULL) {
+ if (dbus_error_is_set(error) == TRUE)
+ return FALSE;
+ }
+
+ if (result != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
+ if (error != NULL)
+ dbus_set_error(error, name, "Name already in use");
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean g_dbus_set_disconnect_function(DBusConnection *connection,
+ GDBusWatchFunction function,
+ void *user_data, DBusFreeFunction destroy)
+{
+ struct disconnect_data *dc_data;
+
+ dc_data = g_new0(struct disconnect_data, 1);
+
+ dc_data->function = function;
+ dc_data->user_data = user_data;
+
+ dbus_connection_set_exit_on_disconnect(connection, FALSE);
+
+ if (g_dbus_add_signal_watch(connection, NULL, NULL,
+ DBUS_INTERFACE_LOCAL, "Disconnected",
+ disconnected_signal, dc_data, g_free) == 0) {
+ error("Failed to add watch for D-Bus Disconnected signal");
+ g_free(dc_data);
+ return FALSE;
+ }
+
+ return TRUE;
+}
diff --git a/gdbus/object.c b/gdbus/object.c
new file mode 100644
index 0000000..96db516
--- /dev/null
+++ b/gdbus/object.c
@@ -0,0 +1,1823 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+#include <dbus/dbus.h>
+
+#include "gdbus.h"
+
+#define info(fmt...)
+#define error(fmt...)
+#define debug(fmt...)
+
+#define DBUS_INTERFACE_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager"
+
+#ifndef DBUS_ERROR_UNKNOWN_PROPERTY
+#define DBUS_ERROR_UNKNOWN_PROPERTY "org.freedesktop.DBus.Error.UnknownProperty"
+#endif
+
+#ifndef DBUS_ERROR_PROPERTY_READ_ONLY
+#define DBUS_ERROR_PROPERTY_READ_ONLY "org.freedesktop.DBus.Error.PropertyReadOnly"
+#endif
+
+struct generic_data {
+ unsigned int refcount;
+ DBusConnection *conn;
+ char *path;
+ GSList *interfaces;
+ GSList *objects;
+ GSList *added;
+ GSList *removed;
+ guint process_id;
+ gboolean pending_prop;
+ char *introspect;
+ struct generic_data *parent;
+};
+
+struct interface_data {
+ char *name;
+ const GDBusMethodTable *methods;
+ const GDBusSignalTable *signals;
+ const GDBusPropertyTable *properties;
+ GSList *pending_prop;
+ void *user_data;
+ GDBusDestroyFunction destroy;
+};
+
+struct security_data {
+ GDBusPendingReply pending;
+ DBusMessage *message;
+ const GDBusMethodTable *method;
+ void *iface_user_data;
+};
+
+struct property_data {
+ DBusConnection *conn;
+ GDBusPendingPropertySet id;
+ DBusMessage *message;
+};
+
+static int global_flags = 0;
+static struct generic_data *root;
+static GSList *pending = NULL;
+
+static gboolean process_changes(gpointer user_data);
+static void process_properties_from_interface(struct generic_data *data,
+ struct interface_data *iface);
+static void process_property_changes(struct generic_data *data);
+
+static void print_arguments(GString *gstr, const GDBusArgInfo *args,
+ const char *direction)
+{
+ for (; args && args->name; args++) {
+ g_string_append_printf(gstr,
+ "<arg name=\"%s\" type=\"%s\"",
+ args->name, args->signature);
+
+ if (direction)
+ g_string_append_printf(gstr,
+ " direction=\"%s\"/>\n", direction);
+ else
+ g_string_append_printf(gstr, "/>\n");
+
+ }
+}
+
+#define G_DBUS_ANNOTATE(name_, value_) \
+ "<annotation name=\"org.freedesktop.DBus." name_ "\" " \
+ "value=\"" value_ "\"/>"
+
+#define G_DBUS_ANNOTATE_DEPRECATED \
+ G_DBUS_ANNOTATE("Deprecated", "true")
+
+#define G_DBUS_ANNOTATE_NOREPLY \
+ G_DBUS_ANNOTATE("Method.NoReply", "true")
+
+static gboolean check_experimental(int flags, int flag)
+{
+ if (!(flags & flag))
+ return FALSE;
+
+ return !(global_flags & G_DBUS_FLAG_ENABLE_EXPERIMENTAL);
+}
+
+static void generate_interface_xml(GString *gstr, struct interface_data *iface)
+{
+ const GDBusMethodTable *method;
+ const GDBusSignalTable *signal;
+ const GDBusPropertyTable *property;
+
+ for (method = iface->methods; method && method->name; method++) {
+ if (check_experimental(method->flags,
+ G_DBUS_METHOD_FLAG_EXPERIMENTAL))
+ continue;
+
+ g_string_append_printf(gstr, "<method name=\"%s\">",
+ method->name);
+ print_arguments(gstr, method->in_args, "in");
+ print_arguments(gstr, method->out_args, "out");
+
+ if (method->flags & G_DBUS_METHOD_FLAG_DEPRECATED)
+ g_string_append_printf(gstr,
+ G_DBUS_ANNOTATE_DEPRECATED);
+
+ if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY)
+ g_string_append_printf(gstr, G_DBUS_ANNOTATE_NOREPLY);
+
+ g_string_append_printf(gstr, "</method>");
+ }
+
+ for (signal = iface->signals; signal && signal->name; signal++) {
+ if (check_experimental(signal->flags,
+ G_DBUS_SIGNAL_FLAG_EXPERIMENTAL))
+ continue;
+
+ g_string_append_printf(gstr, "<signal name=\"%s\">",
+ signal->name);
+ print_arguments(gstr, signal->args, NULL);
+
+ if (signal->flags & G_DBUS_SIGNAL_FLAG_DEPRECATED)
+ g_string_append_printf(gstr,
+ G_DBUS_ANNOTATE_DEPRECATED);
+
+ g_string_append_printf(gstr, "</signal>\n");
+ }
+
+ for (property = iface->properties; property && property->name;
+ property++) {
+ if (check_experimental(property->flags,
+ G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
+ continue;
+
+ g_string_append_printf(gstr, "<property name=\"%s\""
+ " type=\"%s\" access=\"%s%s\">",
+ property->name, property->type,
+ property->get ? "read" : "",
+ property->set ? "write" : "");
+
+ if (property->flags & G_DBUS_PROPERTY_FLAG_DEPRECATED)
+ g_string_append_printf(gstr,
+ G_DBUS_ANNOTATE_DEPRECATED);
+
+ g_string_append_printf(gstr, "</property>");
+ }
+}
+
+static void generate_introspection_xml(DBusConnection *conn,
+ struct generic_data *data, const char *path)
+{
+ GSList *list;
+ GString *gstr;
+ char **children;
+ int i;
+
+ g_free(data->introspect);
+
+ gstr = g_string_new(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE);
+
+ g_string_append_printf(gstr, "<node>");
+
+ for (list = data->interfaces; list; list = list->next) {
+ struct interface_data *iface = list->data;
+
+ g_string_append_printf(gstr, "<interface name=\"%s\">",
+ iface->name);
+
+ generate_interface_xml(gstr, iface);
+
+ g_string_append_printf(gstr, "</interface>");
+ }
+
+ if (!dbus_connection_list_registered(conn, path, &children))
+ goto done;
+
+ for (i = 0; children[i]; i++)
+ g_string_append_printf(gstr, "<node name=\"%s\"/>",
+ children[i]);
+
+ dbus_free_string_array(children);
+
+done:
+ g_string_append_printf(gstr, "</node>");
+
+ data->introspect = g_string_free(gstr, FALSE);
+}
+
+static DBusMessage *introspect(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct generic_data *data = user_data;
+ DBusMessage *reply;
+
+ if (data->introspect == NULL)
+ generate_introspection_xml(connection, data,
+ dbus_message_get_path(message));
+
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return NULL;
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &data->introspect,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusHandlerResult process_message(DBusConnection *connection,
+ DBusMessage *message, const GDBusMethodTable *method,
+ void *iface_user_data)
+{
+ DBusMessage *reply;
+
+ reply = method->function(connection, message, iface_user_data);
+
+ if (method->flags & G_DBUS_METHOD_FLAG_NOREPLY) {
+ if (reply != NULL)
+ dbus_message_unref(reply);
+ return DBUS_HANDLER_RESULT_HANDLED;
+ }
+
+ if (method->flags & G_DBUS_METHOD_FLAG_ASYNC) {
+ if (reply == NULL)
+ return DBUS_HANDLER_RESULT_HANDLED;
+ }
+
+ if (reply == NULL)
+ return DBUS_HANDLER_RESULT_NEED_MEMORY;
+
+ g_dbus_send_message(connection, reply);
+
+ return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static GDBusPendingReply next_pending = 1;
+static GSList *pending_security = NULL;
+
+static const GDBusSecurityTable *security_table = NULL;
+
+void g_dbus_pending_success(DBusConnection *connection,
+ GDBusPendingReply pending)
+{
+ GSList *list;
+
+ for (list = pending_security; list; list = list->next) {
+ struct security_data *secdata = list->data;
+
+ if (secdata->pending != pending)
+ continue;
+
+ pending_security = g_slist_remove(pending_security, secdata);
+
+ process_message(connection, secdata->message,
+ secdata->method, secdata->iface_user_data);
+
+ dbus_message_unref(secdata->message);
+ g_free(secdata);
+ return;
+ }
+}
+
+void g_dbus_pending_error_valist(DBusConnection *connection,
+ GDBusPendingReply pending, const char *name,
+ const char *format, va_list args)
+{
+ GSList *list;
+
+ for (list = pending_security; list; list = list->next) {
+ struct security_data *secdata = list->data;
+
+ if (secdata->pending != pending)
+ continue;
+
+ pending_security = g_slist_remove(pending_security, secdata);
+
+ g_dbus_send_error_valist(connection, secdata->message,
+ name, format, args);
+
+ dbus_message_unref(secdata->message);
+ g_free(secdata);
+ return;
+ }
+}
+
+void g_dbus_pending_error(DBusConnection *connection,
+ GDBusPendingReply pending,
+ const char *name, const char *format, ...)
+{
+ va_list args;
+
+ va_start(args, format);
+
+ g_dbus_pending_error_valist(connection, pending, name, format, args);
+
+ va_end(args);
+}
+
+int polkit_check_authorization(DBusConnection *conn,
+ const char *action, gboolean interaction,
+ void (*function) (dbus_bool_t authorized,
+ void *user_data),
+ void *user_data, int timeout);
+
+struct builtin_security_data {
+ DBusConnection *conn;
+ GDBusPendingReply pending;
+};
+
+static void builtin_security_result(dbus_bool_t authorized, void *user_data)
+{
+ struct builtin_security_data *data = user_data;
+
+ if (authorized == TRUE)
+ g_dbus_pending_success(data->conn, data->pending);
+ else
+ g_dbus_pending_error(data->conn, data->pending,
+ DBUS_ERROR_AUTH_FAILED, NULL);
+
+ g_free(data);
+}
+
+static void builtin_security_function(DBusConnection *conn,
+ const char *action,
+ gboolean interaction,
+ GDBusPendingReply pending)
+{
+ struct builtin_security_data *data;
+
+ data = g_new0(struct builtin_security_data, 1);
+ data->conn = conn;
+ data->pending = pending;
+
+ if (polkit_check_authorization(conn, action, interaction,
+ builtin_security_result, data, 30000) < 0)
+ g_dbus_pending_error(conn, pending, NULL, NULL);
+}
+
+static gboolean check_privilege(DBusConnection *conn, DBusMessage *msg,
+ const GDBusMethodTable *method, void *iface_user_data)
+{
+ const GDBusSecurityTable *security;
+
+ for (security = security_table; security && security->privilege;
+ security++) {
+ struct security_data *secdata;
+ gboolean interaction;
+
+ if (security->privilege != method->privilege)
+ continue;
+
+ secdata = g_new(struct security_data, 1);
+ secdata->pending = next_pending++;
+ secdata->message = dbus_message_ref(msg);
+ secdata->method = method;
+ secdata->iface_user_data = iface_user_data;
+
+ pending_security = g_slist_prepend(pending_security, secdata);
+
+ if (security->flags & G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION)
+ interaction = TRUE;
+ else
+ interaction = FALSE;
+
+ if (!(security->flags & G_DBUS_SECURITY_FLAG_BUILTIN) &&
+ security->function)
+ security->function(conn, security->action,
+ interaction, secdata->pending);
+ else
+ builtin_security_function(conn, security->action,
+ interaction, secdata->pending);
+
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static GDBusPendingPropertySet next_pending_property = 1;
+static GSList *pending_property_set;
+
+static struct property_data *remove_pending_property_data(
+ GDBusPendingPropertySet id)
+{
+ struct property_data *propdata;
+ GSList *l;
+
+ for (l = pending_property_set; l != NULL; l = l->next) {
+ propdata = l->data;
+ if (propdata->id != id)
+ continue;
+
+ break;
+ }
+
+ if (l == NULL)
+ return NULL;
+
+ pending_property_set = g_slist_delete_link(pending_property_set, l);
+
+ return propdata;
+}
+
+void g_dbus_pending_property_success(GDBusPendingPropertySet id)
+{
+ struct property_data *propdata;
+
+ propdata = remove_pending_property_data(id);
+ if (propdata == NULL)
+ return;
+
+ g_dbus_send_reply(propdata->conn, propdata->message,
+ DBUS_TYPE_INVALID);
+ dbus_message_unref(propdata->message);
+ g_free(propdata);
+}
+
+void g_dbus_pending_property_error_valist(GDBusPendingReply id,
+ const char *name, const char *format,
+ va_list args)
+{
+ struct property_data *propdata;
+
+ propdata = remove_pending_property_data(id);
+ if (propdata == NULL)
+ return;
+
+ g_dbus_send_error_valist(propdata->conn, propdata->message, name,
+ format, args);
+
+ dbus_message_unref(propdata->message);
+ g_free(propdata);
+}
+
+void g_dbus_pending_property_error(GDBusPendingReply id, const char *name,
+ const char *format, ...)
+{
+ va_list args;
+
+ va_start(args, format);
+
+ g_dbus_pending_property_error_valist(id, name, format, args);
+
+ va_end(args);
+}
+
+static void reset_parent(gpointer data, gpointer user_data)
+{
+ struct generic_data *child = data;
+ struct generic_data *parent = user_data;
+
+ child->parent = parent;
+}
+
+static void append_property(struct interface_data *iface,
+ const GDBusPropertyTable *p, DBusMessageIter *dict)
+{
+ DBusMessageIter entry, value;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY, NULL,
+ &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &p->name);
+ dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, p->type,
+ &value);
+
+ p->get(p, &value, iface->user_data);
+
+ dbus_message_iter_close_container(&entry, &value);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+static void append_properties(struct interface_data *data,
+ DBusMessageIter *iter)
+{
+ DBusMessageIter dict;
+ const GDBusPropertyTable *p;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ for (p = data->properties; p && p->name; p++) {
+ if (check_experimental(p->flags,
+ G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
+ continue;
+
+ if (p->get == NULL)
+ continue;
+
+ if (p->exists != NULL && !p->exists(p, data->user_data))
+ continue;
+
+ append_property(data, p, &dict);
+ }
+
+ dbus_message_iter_close_container(iter, &dict);
+}
+
+static void append_interface(gpointer data, gpointer user_data)
+{
+ struct interface_data *iface = data;
+ DBusMessageIter *array = user_data;
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(array, DBUS_TYPE_DICT_ENTRY, NULL,
+ &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &iface->name);
+ append_properties(data, &entry);
+ dbus_message_iter_close_container(array, &entry);
+}
+
+static void emit_interfaces_added(struct generic_data *data)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter, array;
+
+ if (root == NULL || data == root)
+ return;
+
+ signal = dbus_message_new_signal(root->path,
+ DBUS_INTERFACE_OBJECT_MANAGER,
+ "InterfacesAdded");
+ if (signal == NULL)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
+ &data->path);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array);
+
+ g_slist_foreach(data->added, append_interface, &array);
+ g_slist_free(data->added);
+ data->added = NULL;
+
+ dbus_message_iter_close_container(&iter, &array);
+
+ /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
+ dbus_connection_send(data->conn, signal, NULL);
+ dbus_message_unref(signal);
+}
+
+static struct interface_data *find_interface(GSList *interfaces,
+ const char *name)
+{
+ GSList *list;
+
+ if (name == NULL)
+ return NULL;
+
+ for (list = interfaces; list; list = list->next) {
+ struct interface_data *iface = list->data;
+ if (!strcmp(name, iface->name))
+ return iface;
+ }
+
+ return NULL;
+}
+
+static gboolean g_dbus_args_have_signature(const GDBusArgInfo *args,
+ DBusMessage *message)
+{
+ const char *sig = dbus_message_get_signature(message);
+ const char *p = NULL;
+
+ for (; args && args->signature && *sig; args++) {
+ p = args->signature;
+
+ for (; *sig && *p; sig++, p++) {
+ if (*p != *sig)
+ return FALSE;
+ }
+ }
+
+ if (*sig || (p && *p) || (args && args->signature))
+ return FALSE;
+
+ return TRUE;
+}
+
+static void add_pending(struct generic_data *data)
+{
+ if (data->process_id > 0)
+ return;
+
+ data->process_id = g_idle_add(process_changes, data);
+
+ pending = g_slist_append(pending, data);
+}
+
+static gboolean remove_interface(struct generic_data *data, const char *name)
+{
+ struct interface_data *iface;
+
+ iface = find_interface(data->interfaces, name);
+ if (iface == NULL)
+ return FALSE;
+
+ process_properties_from_interface(data, iface);
+
+ data->interfaces = g_slist_remove(data->interfaces, iface);
+
+ if (iface->destroy) {
+ iface->destroy(iface->user_data);
+ iface->user_data = NULL;
+ }
+
+ /*
+ * Interface being removed was just added, on the same mainloop
+ * iteration? Don't send any signal
+ */
+ if (g_slist_find(data->added, iface)) {
+ data->added = g_slist_remove(data->added, iface);
+ g_free(iface->name);
+ g_free(iface);
+ return TRUE;
+ }
+
+ if (data->parent == NULL) {
+ g_free(iface->name);
+ g_free(iface);
+ return TRUE;
+ }
+
+ data->removed = g_slist_prepend(data->removed, iface->name);
+ g_free(iface);
+
+ add_pending(data);
+
+ return TRUE;
+}
+
+static struct generic_data *invalidate_parent_data(DBusConnection *conn,
+ const char *child_path)
+{
+ struct generic_data *data = NULL, *child = NULL, *parent = NULL;
+ char *parent_path, *slash;
+
+ parent_path = g_strdup(child_path);
+ slash = strrchr(parent_path, '/');
+ if (slash == NULL)
+ goto done;
+
+ if (slash == parent_path && parent_path[1] != '\0')
+ parent_path[1] = '\0';
+ else
+ *slash = '\0';
+
+ if (!strlen(parent_path))
+ goto done;
+
+ if (dbus_connection_get_object_path_data(conn, parent_path,
+ (void *) &data) == FALSE) {
+ goto done;
+ }
+
+ parent = invalidate_parent_data(conn, parent_path);
+
+ if (data == NULL) {
+ data = parent;
+ if (data == NULL)
+ goto done;
+ }
+
+ g_free(data->introspect);
+ data->introspect = NULL;
+
+ if (!dbus_connection_get_object_path_data(conn, child_path,
+ (void *) &child))
+ goto done;
+
+ if (child == NULL || g_slist_find(data->objects, child) != NULL)
+ goto done;
+
+ data->objects = g_slist_prepend(data->objects, child);
+ child->parent = data;
+
+done:
+ g_free(parent_path);
+ return data;
+}
+
+static inline const GDBusPropertyTable *find_property(const GDBusPropertyTable *properties,
+ const char *name)
+{
+ const GDBusPropertyTable *p;
+
+ for (p = properties; p && p->name; p++) {
+ if (strcmp(name, p->name) != 0)
+ continue;
+
+ if (check_experimental(p->flags,
+ G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
+ break;
+
+ return p;
+ }
+
+ return NULL;
+}
+
+static DBusMessage *properties_get(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct generic_data *data = user_data;
+ struct interface_data *iface;
+ const GDBusPropertyTable *property;
+ const char *interface, *name;
+ DBusMessageIter iter, value;
+ DBusMessage *reply;
+
+ if (!dbus_message_get_args(message, NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "No such interface '%s'", interface);
+
+ property = find_property(iface->properties, name);
+ if (property == NULL)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "No such property '%s'", name);
+
+ if (property->exists != NULL &&
+ !property->exists(property, iface->user_data))
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "No such property '%s'", name);
+
+ if (property->get == NULL)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "Property '%s' is not readable", name);
+
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ property->type, &value);
+
+ if (!property->get(property, &value, iface->user_data)) {
+ dbus_message_unref(reply);
+ return NULL;
+ }
+
+ dbus_message_iter_close_container(&iter, &value);
+
+ return reply;
+}
+
+static DBusMessage *properties_get_all(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct generic_data *data = user_data;
+ struct interface_data *iface;
+ const char *interface;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+
+ if (!dbus_message_get_args(message, NULL,
+ DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_INVALID))
+ return NULL;
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "No such interface '%s'", interface);
+
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ append_properties(iface, &iter);
+
+ return reply;
+}
+
+static DBusMessage *properties_set(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct generic_data *data = user_data;
+ DBusMessageIter iter, sub;
+ struct interface_data *iface;
+ const GDBusPropertyTable *property;
+ const char *name, *interface;
+ struct property_data *propdata;
+ gboolean valid_signature;
+ char *signature;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "No arguments given");
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "Invalid argument type: '%c'",
+ dbus_message_iter_get_arg_type(&iter));
+
+ dbus_message_iter_get_basic(&iter, &interface);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "Invalid argument type: '%c'",
+ dbus_message_iter_get_arg_type(&iter));
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "Invalid argument type: '%c'",
+ dbus_message_iter_get_arg_type(&iter));
+
+ dbus_message_iter_recurse(&iter, &sub);
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL)
+ return g_dbus_create_error(message, DBUS_ERROR_INVALID_ARGS,
+ "No such interface '%s'", interface);
+
+ property = find_property(iface->properties, name);
+ if (property == NULL)
+ return g_dbus_create_error(message,
+ DBUS_ERROR_UNKNOWN_PROPERTY,
+ "No such property '%s'", name);
+
+ if (property->set == NULL)
+ return g_dbus_create_error(message,
+ DBUS_ERROR_PROPERTY_READ_ONLY,
+ "Property '%s' is not writable", name);
+
+ if (property->exists != NULL &&
+ !property->exists(property, iface->user_data))
+ return g_dbus_create_error(message,
+ DBUS_ERROR_UNKNOWN_PROPERTY,
+ "No such property '%s'", name);
+
+ signature = dbus_message_iter_get_signature(&sub);
+ valid_signature = strcmp(signature, property->type) ? FALSE : TRUE;
+ dbus_free(signature);
+ if (!valid_signature)
+ return g_dbus_create_error(message,
+ DBUS_ERROR_INVALID_SIGNATURE,
+ "Invalid signature for '%s'", name);
+
+ propdata = g_new(struct property_data, 1);
+ propdata->id = next_pending_property++;
+ propdata->message = dbus_message_ref(message);
+ propdata->conn = connection;
+ pending_property_set = g_slist_prepend(pending_property_set, propdata);
+
+ property->set(property, &sub, propdata->id, iface->user_data);
+
+ return NULL;
+}
+
+static const GDBusMethodTable properties_methods[] = {
+ { GDBUS_METHOD("Get",
+ GDBUS_ARGS({ "interface", "s" }, { "name", "s" }),
+ GDBUS_ARGS({ "value", "v" }),
+ properties_get) },
+ { GDBUS_ASYNC_METHOD("Set",
+ GDBUS_ARGS({ "interface", "s" }, { "name", "s" },
+ { "value", "v" }),
+ NULL,
+ properties_set) },
+ { GDBUS_METHOD("GetAll",
+ GDBUS_ARGS({ "interface", "s" }),
+ GDBUS_ARGS({ "properties", "a{sv}" }),
+ properties_get_all) },
+ { }
+};
+
+static const GDBusSignalTable properties_signals[] = {
+ { GDBUS_SIGNAL("PropertiesChanged",
+ GDBUS_ARGS({ "interface", "s" },
+ { "changed_properties", "a{sv}" },
+ { "invalidated_properties", "as"})) },
+ { }
+};
+
+static void append_name(gpointer data, gpointer user_data)
+{
+ char *name = data;
+ DBusMessageIter *iter = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &name);
+}
+
+static void emit_interfaces_removed(struct generic_data *data)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter, array;
+
+ if (root == NULL || data == root)
+ return;
+
+ signal = dbus_message_new_signal(root->path,
+ DBUS_INTERFACE_OBJECT_MANAGER,
+ "InterfacesRemoved");
+ if (signal == NULL)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
+ &data->path);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &array);
+
+ g_slist_foreach(data->removed, append_name, &array);
+ g_slist_free_full(data->removed, g_free);
+ data->removed = NULL;
+
+ dbus_message_iter_close_container(&iter, &array);
+
+ /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
+ dbus_connection_send(data->conn, signal, NULL);
+ dbus_message_unref(signal);
+}
+
+static void remove_pending(struct generic_data *data)
+{
+ if (data->process_id > 0) {
+ g_source_remove(data->process_id);
+ data->process_id = 0;
+ }
+
+ pending = g_slist_remove(pending, data);
+}
+
+static gboolean process_changes(gpointer user_data)
+{
+ struct generic_data *data = user_data;
+
+ remove_pending(data);
+
+ if (data->added != NULL)
+ emit_interfaces_added(data);
+
+ /* Flush pending properties */
+ if (data->pending_prop == TRUE)
+ process_property_changes(data);
+
+ if (data->removed != NULL)
+ emit_interfaces_removed(data);
+
+ data->process_id = 0;
+
+ return FALSE;
+}
+
+static void generic_unregister(DBusConnection *connection, void *user_data)
+{
+ struct generic_data *data = user_data;
+ struct generic_data *parent = data->parent;
+
+ if (parent != NULL)
+ parent->objects = g_slist_remove(parent->objects, data);
+
+ if (data->process_id > 0) {
+ g_source_remove(data->process_id);
+ data->process_id = 0;
+ process_changes(data);
+ }
+
+ g_slist_foreach(data->objects, reset_parent, data->parent);
+ g_slist_free(data->objects);
+
+ dbus_connection_unref(data->conn);
+ g_free(data->introspect);
+ g_free(data->path);
+ g_free(data);
+}
+
+static DBusHandlerResult generic_message(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct generic_data *data = user_data;
+ struct interface_data *iface;
+ const GDBusMethodTable *method;
+ const char *interface;
+
+ interface = dbus_message_get_interface(message);
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ for (method = iface->methods; method &&
+ method->name && method->function; method++) {
+
+ if (dbus_message_is_method_call(message, iface->name,
+ method->name) == FALSE)
+ continue;
+
+ if (check_experimental(method->flags,
+ G_DBUS_METHOD_FLAG_EXPERIMENTAL))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (g_dbus_args_have_signature(method->in_args,
+ message) == FALSE)
+ continue;
+
+ if (check_privilege(connection, message, method,
+ iface->user_data) == TRUE)
+ return DBUS_HANDLER_RESULT_HANDLED;
+
+ return process_message(connection, message, method,
+ iface->user_data);
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static DBusObjectPathVTable generic_table = {
+ .unregister_function = generic_unregister,
+ .message_function = generic_message,
+};
+
+static const GDBusMethodTable introspect_methods[] = {
+ { GDBUS_METHOD("Introspect", NULL,
+ GDBUS_ARGS({ "xml", "s" }), introspect) },
+ { }
+};
+
+static void append_interfaces(struct generic_data *data, DBusMessageIter *iter)
+{
+ DBusMessageIter array;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &array);
+
+ g_slist_foreach(data->interfaces, append_interface, &array);
+
+ dbus_message_iter_close_container(iter, &array);
+}
+
+static void append_object(gpointer data, gpointer user_data)
+{
+ struct generic_data *child = data;
+ DBusMessageIter *array = user_data;
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(array, DBUS_TYPE_DICT_ENTRY, NULL,
+ &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+ &child->path);
+ append_interfaces(child, &entry);
+ dbus_message_iter_close_container(array, &entry);
+
+ g_slist_foreach(child->objects, append_object, user_data);
+}
+
+static DBusMessage *get_objects(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct generic_data *data = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusMessageIter array;
+
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_OBJECT_PATH_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &array);
+
+ g_slist_foreach(data->objects, append_object, &array);
+
+ dbus_message_iter_close_container(&iter, &array);
+
+ return reply;
+}
+
+static const GDBusMethodTable manager_methods[] = {
+ { GDBUS_METHOD("GetManagedObjects", NULL,
+ GDBUS_ARGS({ "objects", "a{oa{sa{sv}}}" }), get_objects) },
+ { }
+};
+
+static const GDBusSignalTable manager_signals[] = {
+ { GDBUS_SIGNAL("InterfacesAdded",
+ GDBUS_ARGS({ "object", "o" },
+ { "interfaces", "a{sa{sv}}" })) },
+ { GDBUS_SIGNAL("InterfacesRemoved",
+ GDBUS_ARGS({ "object", "o" }, { "interfaces", "as" })) },
+ { }
+};
+
+static gboolean add_interface(struct generic_data *data,
+ const char *name,
+ const GDBusMethodTable *methods,
+ const GDBusSignalTable *signals,
+ const GDBusPropertyTable *properties,
+ void *user_data,
+ GDBusDestroyFunction destroy)
+{
+ struct interface_data *iface;
+ const GDBusMethodTable *method;
+ const GDBusSignalTable *signal;
+ const GDBusPropertyTable *property;
+
+ for (method = methods; method && method->name; method++) {
+ if (!check_experimental(method->flags,
+ G_DBUS_METHOD_FLAG_EXPERIMENTAL))
+ goto done;
+ }
+
+ for (signal = signals; signal && signal->name; signal++) {
+ if (!check_experimental(signal->flags,
+ G_DBUS_SIGNAL_FLAG_EXPERIMENTAL))
+ goto done;
+ }
+
+ for (property = properties; property && property->name; property++) {
+ if (!check_experimental(property->flags,
+ G_DBUS_PROPERTY_FLAG_EXPERIMENTAL))
+ goto done;
+ }
+
+ /* Nothing to register */
+ return FALSE;
+
+done:
+ iface = g_new0(struct interface_data, 1);
+ iface->name = g_strdup(name);
+ iface->methods = methods;
+ iface->signals = signals;
+ iface->properties = properties;
+ iface->user_data = user_data;
+ iface->destroy = destroy;
+
+ data->interfaces = g_slist_append(data->interfaces, iface);
+ if (data->parent == NULL)
+ return TRUE;
+
+ data->added = g_slist_append(data->added, iface);
+
+ add_pending(data);
+
+ return TRUE;
+}
+
+static struct generic_data *object_path_ref(DBusConnection *connection,
+ const char *path)
+{
+ struct generic_data *data;
+
+ if (dbus_connection_get_object_path_data(connection, path,
+ (void *) &data) == TRUE) {
+ if (data != NULL) {
+ data->refcount++;
+ return data;
+ }
+ }
+
+ data = g_new0(struct generic_data, 1);
+ data->conn = dbus_connection_ref(connection);
+ data->path = g_strdup(path);
+ data->refcount = 1;
+
+ data->introspect = g_strdup(DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE "<node></node>");
+
+ if (!dbus_connection_register_object_path(connection, path,
+ &generic_table, data)) {
+ dbus_connection_unref(data->conn);
+ g_free(data->path);
+ g_free(data->introspect);
+ g_free(data);
+ return NULL;
+ }
+
+ invalidate_parent_data(connection, path);
+
+ add_interface(data, DBUS_INTERFACE_INTROSPECTABLE, introspect_methods,
+ NULL, NULL, data, NULL);
+
+ return data;
+}
+
+static void object_path_unref(DBusConnection *connection, const char *path)
+{
+ struct generic_data *data = NULL;
+
+ if (dbus_connection_get_object_path_data(connection, path,
+ (void *) &data) == FALSE)
+ return;
+
+ if (data == NULL)
+ return;
+
+ data->refcount--;
+
+ if (data->refcount > 0)
+ return;
+
+ remove_interface(data, DBUS_INTERFACE_INTROSPECTABLE);
+ remove_interface(data, DBUS_INTERFACE_PROPERTIES);
+
+ invalidate_parent_data(data->conn, data->path);
+
+ dbus_connection_unregister_object_path(data->conn, data->path);
+}
+
+static gboolean check_signal(DBusConnection *conn, const char *path,
+ const char *interface, const char *name,
+ const GDBusArgInfo **args)
+{
+ struct generic_data *data = NULL;
+ struct interface_data *iface;
+ const GDBusSignalTable *signal;
+
+ *args = NULL;
+ if (!dbus_connection_get_object_path_data(conn, path,
+ (void *) &data) || data == NULL) {
+ error("dbus_connection_emit_signal: path %s isn't registered",
+ path);
+ return FALSE;
+ }
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL) {
+ error("dbus_connection_emit_signal: %s does not implement %s",
+ path, interface);
+ return FALSE;
+ }
+
+ for (signal = iface->signals; signal && signal->name; signal++) {
+ if (strcmp(signal->name, name) != 0)
+ continue;
+
+ if (signal->flags & G_DBUS_SIGNAL_FLAG_EXPERIMENTAL) {
+ const char *env = g_getenv("GDBUS_EXPERIMENTAL");
+ if (g_strcmp0(env, "1") != 0)
+ break;
+ }
+
+ *args = signal->args;
+ return TRUE;
+ }
+
+ error("No signal named %s on interface %s", name, interface);
+ return FALSE;
+}
+
+gboolean g_dbus_register_interface(DBusConnection *connection,
+ const char *path, const char *name,
+ const GDBusMethodTable *methods,
+ const GDBusSignalTable *signals,
+ const GDBusPropertyTable *properties,
+ void *user_data,
+ GDBusDestroyFunction destroy)
+{
+ struct generic_data *data;
+
+ data = object_path_ref(connection, path);
+ if (data == NULL)
+ return FALSE;
+
+ if (find_interface(data->interfaces, name)) {
+ object_path_unref(connection, path);
+ return FALSE;
+ }
+
+ if (!add_interface(data, name, methods, signals, properties, user_data,
+ destroy)) {
+ object_path_unref(connection, path);
+ return FALSE;
+ }
+
+ if (properties != NULL && !find_interface(data->interfaces,
+ DBUS_INTERFACE_PROPERTIES))
+ add_interface(data, DBUS_INTERFACE_PROPERTIES,
+ properties_methods, properties_signals, NULL,
+ data, NULL);
+
+ g_free(data->introspect);
+ data->introspect = NULL;
+
+ return TRUE;
+}
+
+gboolean g_dbus_unregister_interface(DBusConnection *connection,
+ const char *path, const char *name)
+{
+ struct generic_data *data = NULL;
+
+ if (path == NULL)
+ return FALSE;
+
+ if (dbus_connection_get_object_path_data(connection, path,
+ (void *) &data) == FALSE)
+ return FALSE;
+
+ if (data == NULL)
+ return FALSE;
+
+ if (remove_interface(data, name) == FALSE)
+ return FALSE;
+
+ g_free(data->introspect);
+ data->introspect = NULL;
+
+ object_path_unref(connection, data->path);
+
+ return TRUE;
+}
+
+gboolean g_dbus_register_security(const GDBusSecurityTable *security)
+{
+ if (security_table != NULL)
+ return FALSE;
+
+ security_table = security;
+
+ return TRUE;
+}
+
+gboolean g_dbus_unregister_security(const GDBusSecurityTable *security)
+{
+ security_table = NULL;
+
+ return TRUE;
+}
+
+DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name,
+ const char *format, va_list args)
+{
+ char str[1024];
+
+ if (format)
+ vsnprintf(str, sizeof(str), format, args);
+ else
+ str[0] = '\0';
+
+ return dbus_message_new_error(message, name, str);
+}
+
+DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name,
+ const char *format, ...)
+{
+ va_list args;
+ DBusMessage *reply;
+
+ va_start(args, format);
+
+ reply = g_dbus_create_error_valist(message, name, format, args);
+
+ va_end(args);
+
+ return reply;
+}
+
+DBusMessage *g_dbus_create_reply_valist(DBusMessage *message,
+ int type, va_list args)
+{
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return NULL;
+
+ if (dbus_message_append_args_valist(reply, type, args) == FALSE) {
+ dbus_message_unref(reply);
+ return NULL;
+ }
+
+ return reply;
+}
+
+DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...)
+{
+ va_list args;
+ DBusMessage *reply;
+
+ va_start(args, type);
+
+ reply = g_dbus_create_reply_valist(message, type, args);
+
+ va_end(args);
+
+ return reply;
+}
+
+static void g_dbus_flush(DBusConnection *connection)
+{
+ GSList *l;
+
+ for (l = pending; l;) {
+ struct generic_data *data = l->data;
+
+ l = l->next;
+ if (data->conn != connection)
+ continue;
+
+ process_changes(data);
+ }
+}
+
+gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message)
+{
+ dbus_bool_t result = FALSE;
+
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_METHOD_CALL)
+ dbus_message_set_no_reply(message, TRUE);
+ else if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_SIGNAL) {
+ const char *path = dbus_message_get_path(message);
+ const char *interface = dbus_message_get_interface(message);
+ const char *name = dbus_message_get_member(message);
+ const GDBusArgInfo *args;
+
+ if (!check_signal(connection, path, interface, name, &args))
+ goto out;
+ }
+
+ /* Flush pending signal to guarantee message order */
+ g_dbus_flush(connection);
+
+ result = dbus_connection_send(connection, message, NULL);
+
+out:
+ dbus_message_unref(message);
+
+ return result;
+}
+
+gboolean g_dbus_send_message_with_reply(DBusConnection *connection,
+ DBusMessage *message,
+ DBusPendingCall **call, int timeout)
+{
+ dbus_bool_t ret;
+
+ /* Flush pending signal to guarantee message order */
+ g_dbus_flush(connection);
+
+ ret = dbus_connection_send_with_reply(connection, message, call,
+ timeout);
+
+ if (ret == TRUE && call != NULL && *call == NULL) {
+ error("Unable to send message (passing fd blocked?)");
+ return FALSE;
+ }
+
+ return ret;
+}
+
+gboolean g_dbus_send_error_valist(DBusConnection *connection,
+ DBusMessage *message, const char *name,
+ const char *format, va_list args)
+{
+ DBusMessage *error;
+
+ error = g_dbus_create_error_valist(message, name, format, args);
+ if (error == NULL)
+ return FALSE;
+
+ return g_dbus_send_message(connection, error);
+}
+
+gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message,
+ const char *name, const char *format, ...)
+{
+ va_list args;
+ gboolean result;
+
+ va_start(args, format);
+
+ result = g_dbus_send_error_valist(connection, message, name,
+ format, args);
+
+ va_end(args);
+
+ return result;
+}
+
+gboolean g_dbus_send_reply_valist(DBusConnection *connection,
+ DBusMessage *message, int type, va_list args)
+{
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(message);
+ if (reply == NULL)
+ return FALSE;
+
+ if (dbus_message_append_args_valist(reply, type, args) == FALSE) {
+ dbus_message_unref(reply);
+ return FALSE;
+ }
+
+ return g_dbus_send_message(connection, reply);
+}
+
+gboolean g_dbus_send_reply(DBusConnection *connection,
+ DBusMessage *message, int type, ...)
+{
+ va_list args;
+ gboolean result;
+
+ va_start(args, type);
+
+ result = g_dbus_send_reply_valist(connection, message, type, args);
+
+ va_end(args);
+
+ return result;
+}
+
+gboolean g_dbus_emit_signal(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name, int type, ...)
+{
+ va_list args;
+ gboolean result;
+
+ va_start(args, type);
+
+ result = g_dbus_emit_signal_valist(connection, path, interface,
+ name, type, args);
+
+ va_end(args);
+
+ return result;
+}
+
+gboolean g_dbus_emit_signal_valist(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name, int type, va_list args)
+{
+ DBusMessage *signal;
+ dbus_bool_t ret;
+ const GDBusArgInfo *args_info;
+
+ if (!check_signal(connection, path, interface, name, &args_info))
+ return FALSE;
+
+ signal = dbus_message_new_signal(path, interface, name);
+ if (signal == NULL) {
+ error("Unable to allocate new %s.%s signal", interface, name);
+ return FALSE;
+ }
+
+ ret = dbus_message_append_args_valist(signal, type, args);
+ if (!ret)
+ goto fail;
+
+ if (g_dbus_args_have_signature(args_info, signal) == FALSE) {
+ error("%s.%s: got unexpected signature '%s'", interface, name,
+ dbus_message_get_signature(signal));
+ ret = FALSE;
+ goto fail;
+ }
+
+ return g_dbus_send_message(connection, signal);
+
+fail:
+ dbus_message_unref(signal);
+
+ return ret;
+}
+
+static void process_properties_from_interface(struct generic_data *data,
+ struct interface_data *iface)
+{
+ GSList *l;
+ DBusMessage *signal;
+ DBusMessageIter iter, dict, array;
+ GSList *invalidated;
+
+ data->pending_prop = FALSE;
+
+ if (iface->pending_prop == NULL)
+ return;
+
+ signal = dbus_message_new_signal(data->path,
+ DBUS_INTERFACE_PROPERTIES, "PropertiesChanged");
+ if (signal == NULL) {
+ error("Unable to allocate new " DBUS_INTERFACE_PROPERTIES
+ ".PropertiesChanged signal");
+ return;
+ }
+
+ iface->pending_prop = g_slist_reverse(iface->pending_prop);
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &iface->name);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ invalidated = NULL;
+
+ for (l = iface->pending_prop; l != NULL; l = l->next) {
+ GDBusPropertyTable *p = l->data;
+
+ if (p->get == NULL)
+ continue;
+
+ if (p->exists != NULL && !p->exists(p, iface->user_data)) {
+ invalidated = g_slist_prepend(invalidated, p);
+ continue;
+ }
+
+ append_property(iface, p, &dict);
+ }
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_STRING_AS_STRING, &array);
+ for (l = invalidated; l != NULL; l = g_slist_next(l)) {
+ GDBusPropertyTable *p = l->data;
+
+ dbus_message_iter_append_basic(&array, DBUS_TYPE_STRING,
+ &p->name);
+ }
+ g_slist_free(invalidated);
+ dbus_message_iter_close_container(&iter, &array);
+
+ g_slist_free(iface->pending_prop);
+ iface->pending_prop = NULL;
+
+ /* Use dbus_connection_send to avoid recursive calls to g_dbus_flush */
+ dbus_connection_send(data->conn, signal, NULL);
+ dbus_message_unref(signal);
+}
+
+static void process_property_changes(struct generic_data *data)
+{
+ GSList *l;
+
+ for (l = data->interfaces; l != NULL; l = l->next) {
+ struct interface_data *iface = l->data;
+
+ process_properties_from_interface(data, iface);
+ }
+}
+
+void g_dbus_emit_property_changed(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name)
+{
+ const GDBusPropertyTable *property;
+ struct generic_data *data;
+ struct interface_data *iface;
+
+ if (path == NULL)
+ return;
+
+ if (!dbus_connection_get_object_path_data(connection, path,
+ (void **) &data) || data == NULL)
+ return;
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL)
+ return;
+
+ /*
+ * If ObjectManager is attached, don't emit property changed if
+ * interface is not yet published
+ */
+ if (root && g_slist_find(data->added, iface))
+ return;
+
+ property = find_property(iface->properties, name);
+ if (property == NULL) {
+ error("Could not find property %s in %p", name,
+ iface->properties);
+ return;
+ }
+
+ if (g_slist_find(iface->pending_prop, (void *) property) != NULL)
+ return;
+
+ data->pending_prop = TRUE;
+ iface->pending_prop = g_slist_prepend(iface->pending_prop,
+ (void *) property);
+
+ add_pending(data);
+}
+
+gboolean g_dbus_get_properties(DBusConnection *connection, const char *path,
+ const char *interface, DBusMessageIter *iter)
+{
+ struct generic_data *data;
+ struct interface_data *iface;
+
+ if (path == NULL)
+ return FALSE;
+
+ if (!dbus_connection_get_object_path_data(connection, path,
+ (void **) &data) || data == NULL)
+ return FALSE;
+
+ iface = find_interface(data->interfaces, interface);
+ if (iface == NULL)
+ return FALSE;
+
+ append_properties(iface, iter);
+
+ return TRUE;
+}
+
+gboolean g_dbus_attach_object_manager(DBusConnection *connection)
+{
+ struct generic_data *data;
+
+ data = object_path_ref(connection, "/");
+ if (data == NULL)
+ return FALSE;
+
+ add_interface(data, DBUS_INTERFACE_OBJECT_MANAGER,
+ manager_methods, manager_signals,
+ NULL, data, NULL);
+ root = data;
+
+ return TRUE;
+}
+
+gboolean g_dbus_detach_object_manager(DBusConnection *connection)
+{
+ if (!g_dbus_unregister_interface(connection, "/",
+ DBUS_INTERFACE_OBJECT_MANAGER))
+ return FALSE;
+
+ root = NULL;
+
+ return TRUE;
+}
+
+void g_dbus_set_flags(int flags)
+{
+ global_flags = flags;
+}
+
+int g_dbus_get_flags(void)
+{
+ return global_flags;
+}
diff --git a/gdbus/polkit.c b/gdbus/polkit.c
new file mode 100644
index 0000000..9e95fa3
--- /dev/null
+++ b/gdbus/polkit.c
@@ -0,0 +1,202 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <dbus/dbus.h>
+
+#include <glib.h>
+
+int polkit_check_authorization(DBusConnection *conn,
+ const char *action, gboolean interaction,
+ void (*function) (dbus_bool_t authorized,
+ void *user_data),
+ void *user_data, int timeout);
+
+static void add_dict_with_string_value(DBusMessageIter *iter,
+ const char *key, const char *str)
+{
+ DBusMessageIter dict, entry, value;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+ dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_STRING_AS_STRING, &value);
+ dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
+ dbus_message_iter_close_container(&entry, &value);
+
+ dbus_message_iter_close_container(&dict, &entry);
+ dbus_message_iter_close_container(iter, &dict);
+}
+
+static void add_empty_string_dict(DBusMessageIter *iter)
+{
+ DBusMessageIter dict;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ dbus_message_iter_close_container(iter, &dict);
+}
+
+static void add_arguments(DBusConnection *conn, DBusMessageIter *iter,
+ const char *action, dbus_uint32_t flags)
+{
+ const char *busname = dbus_bus_get_unique_name(conn);
+ const char *kind = "system-bus-name";
+ const char *cancel = "";
+ DBusMessageIter subject;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
+ NULL, &subject);
+ dbus_message_iter_append_basic(&subject, DBUS_TYPE_STRING, &kind);
+ add_dict_with_string_value(&subject, "name", busname);
+ dbus_message_iter_close_container(iter, &subject);
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &action);
+ add_empty_string_dict(iter);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &flags);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &cancel);
+}
+
+static dbus_bool_t parse_result(DBusMessageIter *iter)
+{
+ DBusMessageIter result;
+ dbus_bool_t authorized, challenge;
+
+ dbus_message_iter_recurse(iter, &result);
+
+ dbus_message_iter_get_basic(&result, &authorized);
+ dbus_message_iter_get_basic(&result, &challenge);
+
+ return authorized;
+}
+
+struct authorization_data {
+ void (*function) (dbus_bool_t authorized, void *user_data);
+ void *user_data;
+};
+
+static void authorization_reply(DBusPendingCall *call, void *user_data)
+{
+ struct authorization_data *data = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ dbus_bool_t authorized = FALSE;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ goto done;
+
+ if (dbus_message_has_signature(reply, "(bba{ss})") == FALSE)
+ goto done;
+
+ dbus_message_iter_init(reply, &iter);
+
+ authorized = parse_result(&iter);
+
+done:
+ if (data->function != NULL)
+ data->function(authorized, data->user_data);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+#define AUTHORITY_DBUS "org.freedesktop.PolicyKit1"
+#define AUTHORITY_INTF "org.freedesktop.PolicyKit1.Authority"
+#define AUTHORITY_PATH "/org/freedesktop/PolicyKit1/Authority"
+
+int polkit_check_authorization(DBusConnection *conn,
+ const char *action, gboolean interaction,
+ void (*function) (dbus_bool_t authorized,
+ void *user_data),
+ void *user_data, int timeout)
+{
+ struct authorization_data *data;
+ DBusMessage *msg;
+ DBusMessageIter iter;
+ DBusPendingCall *call;
+ dbus_uint32_t flags = 0x00000000;
+
+ if (conn == NULL)
+ return -EINVAL;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (data == NULL)
+ return -ENOMEM;
+
+ msg = dbus_message_new_method_call(AUTHORITY_DBUS, AUTHORITY_PATH,
+ AUTHORITY_INTF, "CheckAuthorization");
+ if (msg == NULL) {
+ dbus_free(data);
+ return -ENOMEM;
+ }
+
+ if (interaction == TRUE)
+ flags |= 0x00000001;
+
+ if (action == NULL)
+ action = "org.freedesktop.policykit.exec";
+
+ dbus_message_iter_init_append(msg, &iter);
+ add_arguments(conn, &iter, action, flags);
+
+ if (dbus_connection_send_with_reply(conn, msg,
+ &call, timeout) == FALSE) {
+ dbus_message_unref(msg);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ if (call == NULL) {
+ dbus_message_unref(msg);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ data->function = function;
+ data->user_data = user_data;
+
+ dbus_pending_call_set_notify(call, authorization_reply,
+ data, dbus_free);
+
+ dbus_message_unref(msg);
+
+ return 0;
+}
diff --git a/gdbus/watch.c b/gdbus/watch.c
new file mode 100644
index 0000000..b60f650
--- /dev/null
+++ b/gdbus/watch.c
@@ -0,0 +1,818 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+
+#include <glib.h>
+#include <dbus/dbus.h>
+
+#include "gdbus.h"
+
+#define info(fmt...)
+#define error(fmt...)
+#define debug(fmt...)
+
+static DBusHandlerResult message_filter(DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+static guint listener_id = 0;
+static GSList *listeners = NULL;
+
+struct service_data {
+ DBusConnection *conn;
+ DBusPendingCall *call;
+ char *name;
+ const char *owner;
+ guint id;
+ struct filter_callback *callback;
+};
+
+struct filter_callback {
+ GDBusWatchFunction conn_func;
+ GDBusWatchFunction disc_func;
+ GDBusSignalFunction signal_func;
+ GDBusDestroyFunction destroy_func;
+ struct service_data *data;
+ void *user_data;
+ guint id;
+};
+
+struct filter_data {
+ DBusConnection *connection;
+ DBusHandleMessageFunction handle_func;
+ char *name;
+ char *owner;
+ char *path;
+ char *interface;
+ char *member;
+ char *argument;
+ GSList *callbacks;
+ GSList *processed;
+ guint name_watch;
+ gboolean lock;
+ gboolean registered;
+};
+
+static struct filter_data *filter_data_find_match(DBusConnection *connection,
+ const char *name,
+ const char *owner,
+ const char *path,
+ const char *interface,
+ const char *member,
+ const char *argument)
+{
+ GSList *current;
+
+ for (current = listeners;
+ current != NULL; current = current->next) {
+ struct filter_data *data = current->data;
+
+ if (connection != data->connection)
+ continue;
+
+ if (g_strcmp0(name, data->name) != 0)
+ continue;
+
+ if (g_strcmp0(owner, data->owner) != 0)
+ continue;
+
+ if (g_strcmp0(path, data->path) != 0)
+ continue;
+
+ if (g_strcmp0(interface, data->interface) != 0)
+ continue;
+
+ if (g_strcmp0(member, data->member) != 0)
+ continue;
+
+ if (g_strcmp0(argument, data->argument) != 0)
+ continue;
+
+ return data;
+ }
+
+ return NULL;
+}
+
+static struct filter_data *filter_data_find(DBusConnection *connection)
+{
+ GSList *current;
+
+ for (current = listeners;
+ current != NULL; current = current->next) {
+ struct filter_data *data = current->data;
+
+ if (connection != data->connection)
+ continue;
+
+ return data;
+ }
+
+ return NULL;
+}
+
+static void format_rule(struct filter_data *data, char *rule, size_t size)
+{
+ const char *sender;
+ int offset;
+
+ offset = snprintf(rule, size, "type='signal'");
+ sender = data->name ? : data->owner;
+
+ if (sender)
+ offset += snprintf(rule + offset, size - offset,
+ ",sender='%s'", sender);
+ if (data->path)
+ offset += snprintf(rule + offset, size - offset,
+ ",path='%s'", data->path);
+ if (data->interface)
+ offset += snprintf(rule + offset, size - offset,
+ ",interface='%s'", data->interface);
+ if (data->member)
+ offset += snprintf(rule + offset, size - offset,
+ ",member='%s'", data->member);
+ if (data->argument)
+ snprintf(rule + offset, size - offset,
+ ",arg0='%s'", data->argument);
+}
+
+static gboolean add_match(struct filter_data *data,
+ DBusHandleMessageFunction filter)
+{
+ DBusError err;
+ char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
+
+ format_rule(data, rule, sizeof(rule));
+ dbus_error_init(&err);
+
+ dbus_bus_add_match(data->connection, rule, &err);
+ if (dbus_error_is_set(&err)) {
+ error("Adding match rule \"%s\" failed: %s", rule,
+ err.message);
+ dbus_error_free(&err);
+ return FALSE;
+ }
+
+ data->handle_func = filter;
+ data->registered = TRUE;
+
+ return TRUE;
+}
+
+static gboolean remove_match(struct filter_data *data)
+{
+ DBusError err;
+ char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
+
+ format_rule(data, rule, sizeof(rule));
+
+ dbus_error_init(&err);
+
+ dbus_bus_remove_match(data->connection, rule, &err);
+ if (dbus_error_is_set(&err)) {
+ error("Removing owner match rule for %s failed: %s",
+ rule, err.message);
+ dbus_error_free(&err);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static struct filter_data *filter_data_get(DBusConnection *connection,
+ DBusHandleMessageFunction filter,
+ const char *sender,
+ const char *path,
+ const char *interface,
+ const char *member,
+ const char *argument)
+{
+ struct filter_data *data;
+ const char *name = NULL, *owner = NULL;
+
+ if (filter_data_find(connection) == NULL) {
+ if (!dbus_connection_add_filter(connection,
+ message_filter, NULL, NULL)) {
+ error("dbus_connection_add_filter() failed");
+ return NULL;
+ }
+ }
+
+ if (sender == NULL)
+ goto proceed;
+
+ if (sender[0] == ':')
+ owner = sender;
+ else
+ name = sender;
+
+proceed:
+ data = filter_data_find_match(connection, name, owner, path,
+ interface, member, argument);
+ if (data)
+ return data;
+
+ data = g_new0(struct filter_data, 1);
+
+ data->connection = dbus_connection_ref(connection);
+ data->name = g_strdup(name);
+ data->owner = g_strdup(owner);
+ data->path = g_strdup(path);
+ data->interface = g_strdup(interface);
+ data->member = g_strdup(member);
+ data->argument = g_strdup(argument);
+
+ if (!add_match(data, filter)) {
+ g_free(data);
+ return NULL;
+ }
+
+ listeners = g_slist_append(listeners, data);
+
+ return data;
+}
+
+static struct filter_callback *filter_data_find_callback(
+ struct filter_data *data,
+ guint id)
+{
+ GSList *l;
+
+ for (l = data->callbacks; l; l = l->next) {
+ struct filter_callback *cb = l->data;
+ if (cb->id == id)
+ return cb;
+ }
+ for (l = data->processed; l; l = l->next) {
+ struct filter_callback *cb = l->data;
+ if (cb->id == id)
+ return cb;
+ }
+
+ return NULL;
+}
+
+static void filter_data_free(struct filter_data *data)
+{
+ GSList *l;
+
+ /* Remove filter if there are no listeners left for the connection */
+ if (filter_data_find(data->connection) == NULL)
+ dbus_connection_remove_filter(data->connection, message_filter,
+ NULL);
+
+ for (l = data->callbacks; l != NULL; l = l->next)
+ g_free(l->data);
+
+ g_slist_free(data->callbacks);
+ g_dbus_remove_watch(data->connection, data->name_watch);
+ g_free(data->name);
+ g_free(data->owner);
+ g_free(data->path);
+ g_free(data->interface);
+ g_free(data->member);
+ g_free(data->argument);
+ dbus_connection_unref(data->connection);
+ g_free(data);
+}
+
+static void filter_data_call_and_free(struct filter_data *data)
+{
+ GSList *l;
+
+ for (l = data->callbacks; l != NULL; l = l->next) {
+ struct filter_callback *cb = l->data;
+ if (cb->disc_func)
+ cb->disc_func(data->connection, cb->user_data);
+ if (cb->destroy_func)
+ cb->destroy_func(cb->user_data);
+ g_free(cb);
+ }
+
+ filter_data_free(data);
+}
+
+static struct filter_callback *filter_data_add_callback(
+ struct filter_data *data,
+ GDBusWatchFunction connect,
+ GDBusWatchFunction disconnect,
+ GDBusSignalFunction signal,
+ GDBusDestroyFunction destroy,
+ void *user_data)
+{
+ struct filter_callback *cb = NULL;
+
+ cb = g_new0(struct filter_callback, 1);
+
+ cb->conn_func = connect;
+ cb->disc_func = disconnect;
+ cb->signal_func = signal;
+ cb->destroy_func = destroy;
+ cb->user_data = user_data;
+ cb->id = ++listener_id;
+
+ if (data->lock)
+ data->processed = g_slist_append(data->processed, cb);
+ else
+ data->callbacks = g_slist_append(data->callbacks, cb);
+
+ return cb;
+}
+
+static void service_data_free(struct service_data *data)
+{
+ struct filter_callback *callback = data->callback;
+
+ dbus_connection_unref(data->conn);
+
+ if (data->call)
+ dbus_pending_call_unref(data->call);
+
+ if (data->id)
+ g_source_remove(data->id);
+
+ g_free(data->name);
+ g_free(data);
+
+ callback->data = NULL;
+}
+
+/* Returns TRUE if data is freed */
+static gboolean filter_data_remove_callback(struct filter_data *data,
+ struct filter_callback *cb)
+{
+ data->callbacks = g_slist_remove(data->callbacks, cb);
+ data->processed = g_slist_remove(data->processed, cb);
+
+ /* Cancel pending operations */
+ if (cb->data) {
+ if (cb->data->call)
+ dbus_pending_call_cancel(cb->data->call);
+ service_data_free(cb->data);
+ }
+
+ if (cb->destroy_func)
+ cb->destroy_func(cb->user_data);
+
+ g_free(cb);
+
+ /* Don't remove the filter if other callbacks exist or data is lock
+ * processing callbacks */
+ if (data->callbacks || data->lock)
+ return FALSE;
+
+ if (data->registered && !remove_match(data))
+ return FALSE;
+
+ listeners = g_slist_remove(listeners, data);
+ filter_data_free(data);
+
+ return TRUE;
+}
+
+static DBusHandlerResult signal_filter(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct filter_data *data = user_data;
+ struct filter_callback *cb;
+
+ while (data->callbacks) {
+ cb = data->callbacks->data;
+
+ if (cb->signal_func && !cb->signal_func(connection, message,
+ cb->user_data)) {
+ if (filter_data_remove_callback(data, cb))
+ break;
+
+ continue;
+ }
+
+ /* Check if the watch was removed/freed by the callback
+ * function */
+ if (!g_slist_find(data->callbacks, cb))
+ continue;
+
+ data->callbacks = g_slist_remove(data->callbacks, cb);
+ data->processed = g_slist_append(data->processed, cb);
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static void update_name_cache(const char *name, const char *owner)
+{
+ GSList *l;
+
+ for (l = listeners; l != NULL; l = l->next) {
+ struct filter_data *data = l->data;
+
+ if (g_strcmp0(data->name, name) != 0)
+ continue;
+
+ g_free(data->owner);
+ data->owner = g_strdup(owner);
+ }
+}
+
+static const char *check_name_cache(const char *name)
+{
+ GSList *l;
+
+ for (l = listeners; l != NULL; l = l->next) {
+ struct filter_data *data = l->data;
+
+ if (g_strcmp0(data->name, name) != 0)
+ continue;
+
+ return data->owner;
+ }
+
+ return NULL;
+}
+
+static DBusHandlerResult service_filter(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct filter_data *data = user_data;
+ struct filter_callback *cb;
+ char *name, *old, *new;
+
+ if (!dbus_message_get_args(message, NULL,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_STRING, &old,
+ DBUS_TYPE_STRING, &new,
+ DBUS_TYPE_INVALID)) {
+ error("Invalid arguments for NameOwnerChanged signal");
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ update_name_cache(name, new);
+
+ while (data->callbacks) {
+ cb = data->callbacks->data;
+
+ if (*new == '\0') {
+ if (cb->disc_func)
+ cb->disc_func(connection, cb->user_data);
+ } else {
+ if (cb->conn_func)
+ cb->conn_func(connection, cb->user_data);
+ }
+
+ /* Check if the watch was removed/freed by the callback
+ * function */
+ if (!g_slist_find(data->callbacks, cb))
+ continue;
+
+ /* Only auto remove if it is a bus name watch */
+ if (data->argument[0] == ':' &&
+ (cb->conn_func == NULL || cb->disc_func == NULL)) {
+ if (filter_data_remove_callback(data, cb))
+ break;
+
+ continue;
+ }
+
+ data->callbacks = g_slist_remove(data->callbacks, cb);
+ data->processed = g_slist_append(data->processed, cb);
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+
+static DBusHandlerResult message_filter(DBusConnection *connection,
+ DBusMessage *message, void *user_data)
+{
+ struct filter_data *data;
+ const char *sender, *path, *iface, *member, *arg = NULL;
+ GSList *current, *delete_listener = NULL;
+
+ /* Only filter signals */
+ if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_SIGNAL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ sender = dbus_message_get_sender(message);
+ path = dbus_message_get_path(message);
+ iface = dbus_message_get_interface(message);
+ member = dbus_message_get_member(message);
+ dbus_message_get_args(message, NULL, DBUS_TYPE_STRING, &arg, DBUS_TYPE_INVALID);
+
+ /* If sender != NULL it is always the owner */
+
+ for (current = listeners; current != NULL; current = current->next) {
+ data = current->data;
+
+ if (connection != data->connection)
+ continue;
+
+ if (!sender && data->owner)
+ continue;
+
+ if (data->owner && g_str_equal(sender, data->owner) == FALSE)
+ continue;
+
+ if (data->path && g_str_equal(path, data->path) == FALSE)
+ continue;
+
+ if (data->interface && g_str_equal(iface,
+ data->interface) == FALSE)
+ continue;
+
+ if (data->member && g_str_equal(member, data->member) == FALSE)
+ continue;
+
+ if (data->argument && g_str_equal(arg,
+ data->argument) == FALSE)
+ continue;
+
+ if (data->handle_func) {
+ data->lock = TRUE;
+
+ data->handle_func(connection, message, data);
+
+ data->callbacks = data->processed;
+ data->processed = NULL;
+ data->lock = FALSE;
+ }
+
+ if (!data->callbacks)
+ delete_listener = g_slist_prepend(delete_listener,
+ current);
+ }
+
+ if (delete_listener == NULL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ for (current = delete_listener; current != NULL;
+ current = delete_listener->next) {
+ GSList *l = current->data;
+
+ data = l->data;
+
+ /* Has any other callback added callbacks back to this data? */
+ if (data->callbacks != NULL)
+ continue;
+
+ remove_match(data);
+ listeners = g_slist_delete_link(listeners, l);
+
+ filter_data_free(data);
+ }
+
+ g_slist_free(delete_listener);
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static gboolean update_service(void *user_data)
+{
+ struct service_data *data = user_data;
+ struct filter_callback *cb = data->callback;
+ DBusConnection *conn;
+
+ conn = dbus_connection_ref(data->conn);
+ service_data_free(data);
+
+ if (cb->conn_func)
+ cb->conn_func(conn, cb->user_data);
+
+ dbus_connection_unref(conn);
+
+ return FALSE;
+}
+
+static void service_reply(DBusPendingCall *call, void *user_data)
+{
+ struct service_data *data = user_data;
+ DBusMessage *reply;
+ DBusError err;
+
+ reply = dbus_pending_call_steal_reply(call);
+ if (reply == NULL)
+ return;
+
+ dbus_error_init(&err);
+
+ if (dbus_set_error_from_message(&err, reply))
+ goto fail;
+
+ if (dbus_message_get_args(reply, &err,
+ DBUS_TYPE_STRING, &data->owner,
+ DBUS_TYPE_INVALID) == FALSE)
+ goto fail;
+
+ update_service(data);
+
+ goto done;
+
+fail:
+ error("%s", err.message);
+ dbus_error_free(&err);
+ service_data_free(data);
+done:
+ dbus_message_unref(reply);
+}
+
+static void check_service(DBusConnection *connection,
+ const char *name,
+ struct filter_callback *callback)
+{
+ DBusMessage *message;
+ struct service_data *data;
+
+ data = g_try_malloc0(sizeof(*data));
+ if (data == NULL) {
+ error("Can't allocate data structure");
+ return;
+ }
+
+ data->conn = dbus_connection_ref(connection);
+ data->name = g_strdup(name);
+ data->callback = callback;
+ callback->data = data;
+
+ data->owner = check_name_cache(name);
+ if (data->owner != NULL) {
+ data->id = g_idle_add(update_service, data);
+ return;
+ }
+
+ message = dbus_message_new_method_call(DBUS_SERVICE_DBUS,
+ DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS, "GetNameOwner");
+ if (message == NULL) {
+ error("Can't allocate new message");
+ g_free(data);
+ return;
+ }
+
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+
+ if (dbus_connection_send_with_reply(connection, message,
+ &data->call, -1) == FALSE) {
+ error("Failed to execute method call");
+ g_free(data);
+ goto done;
+ }
+
+ if (data->call == NULL) {
+ error("D-Bus connection not available");
+ g_free(data);
+ goto done;
+ }
+
+ dbus_pending_call_set_notify(data->call, service_reply, data, NULL);
+
+done:
+ dbus_message_unref(message);
+}
+
+guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
+ GDBusWatchFunction connect,
+ GDBusWatchFunction disconnect,
+ void *user_data, GDBusDestroyFunction destroy)
+{
+ struct filter_data *data;
+ struct filter_callback *cb;
+
+ if (name == NULL)
+ return 0;
+
+ data = filter_data_get(connection, service_filter,
+ DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS, "NameOwnerChanged",
+ name);
+ if (data == NULL)
+ return 0;
+
+ cb = filter_data_add_callback(data, connect, disconnect, NULL, destroy,
+ user_data);
+ if (cb == NULL)
+ return 0;
+
+ if (connect)
+ check_service(connection, name, cb);
+
+ return cb->id;
+}
+
+guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
+ GDBusWatchFunction func,
+ void *user_data, GDBusDestroyFunction destroy)
+{
+ return g_dbus_add_service_watch(connection, name, NULL, func,
+ user_data, destroy);
+}
+
+guint g_dbus_add_signal_watch(DBusConnection *connection,
+ const char *sender, const char *path,
+ const char *interface, const char *member,
+ GDBusSignalFunction function, void *user_data,
+ GDBusDestroyFunction destroy)
+{
+ struct filter_data *data;
+ struct filter_callback *cb;
+
+ data = filter_data_get(connection, signal_filter, sender, path,
+ interface, member, NULL);
+ if (data == NULL)
+ return 0;
+
+ cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
+ user_data);
+ if (cb == NULL)
+ return 0;
+
+ if (data->name != NULL && data->name_watch == 0)
+ data->name_watch = g_dbus_add_service_watch(connection,
+ data->name, NULL,
+ NULL, NULL, NULL);
+
+ return cb->id;
+}
+
+guint g_dbus_add_properties_watch(DBusConnection *connection,
+ const char *sender, const char *path,
+ const char *interface,
+ GDBusSignalFunction function, void *user_data,
+ GDBusDestroyFunction destroy)
+{
+ struct filter_data *data;
+ struct filter_callback *cb;
+
+ data = filter_data_get(connection, signal_filter, sender, path,
+ DBUS_INTERFACE_PROPERTIES, "PropertiesChanged",
+ interface);
+ if (data == NULL)
+ return 0;
+
+ cb = filter_data_add_callback(data, NULL, NULL, function, destroy,
+ user_data);
+ if (cb == NULL)
+ return 0;
+
+ if (data->name != NULL && data->name_watch == 0)
+ data->name_watch = g_dbus_add_service_watch(connection,
+ data->name, NULL,
+ NULL, NULL, NULL);
+
+ return cb->id;
+}
+
+gboolean g_dbus_remove_watch(DBusConnection *connection, guint id)
+{
+ struct filter_data *data;
+ struct filter_callback *cb;
+ GSList *ldata;
+
+ if (id == 0)
+ return FALSE;
+
+ for (ldata = listeners; ldata; ldata = ldata->next) {
+ data = ldata->data;
+
+ cb = filter_data_find_callback(data, id);
+ if (cb) {
+ filter_data_remove_callback(data, cb);
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+void g_dbus_remove_all_watches(DBusConnection *connection)
+{
+ struct filter_data *data;
+
+ while ((data = filter_data_find(connection))) {
+ listeners = g_slist_remove(listeners, data);
+ filter_data_call_and_free(data);
+ }
+}
diff --git a/gdhcp/client.c b/gdhcp/client.c
new file mode 100644
index 0000000..c85fb8f
--- /dev/null
+++ b/gdhcp/client.c
@@ -0,0 +1,3423 @@
+/*
+ *
+ * DHCP client library with GLib integration
+ *
+ * Copyright (C) 2009-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <sys/time.h>
+#include <sys/timerfd.h>
+#include <resolv.h>
+
+#include <netpacket/packet.h>
+#include <netinet/if_ether.h>
+#include <net/ethernet.h>
+
+#include <linux/if.h>
+#include <linux/filter.h>
+
+#include <glib.h>
+
+#include "gdhcp.h"
+#include "common.h"
+#include "ipv4ll.h"
+#include "timer.h"
+#define DISCOVER_TIMEOUT 10
+#define DISCOVER_RETRIES 6
+
+#define REQUEST_TIMEOUT 5
+#define REQUEST_RETRIES 3
+
+typedef enum _listen_mode {
+ L_NONE,
+ L2,
+ L3,
+ L_ARP,
+} ListenMode;
+
+typedef enum _dhcp_client_state {
+ INIT_SELECTING,
+ REBOOTING,
+ REQUESTING,
+ BOUND,
+ RENEWING,
+ REBINDING,
+ RELEASED,
+ IPV4LL_PROBE,
+ IPV4LL_ANNOUNCE,
+ IPV4LL_MONITOR,
+ IPV4LL_DEFEND,
+ INFORMATION_REQ,
+ SOLICITATION,
+ REQUEST,
+ CONFIRM,
+ RENEW,
+ REBIND,
+ RELEASE,
+ DECLINE,
+} ClientState;
+
+struct _GDHCPClient {
+ int ref_count;
+ GDHCPType type;
+ ClientState state;
+ int ifindex;
+ char *interface;
+ uint8_t mac_address[6];
+ uint32_t xid;
+ uint32_t server_ip;
+ uint32_t requested_ip;
+ char *assigned_ip;
+ time_t start;
+ uint32_t lease_seconds;
+ ListenMode listen_mode;
+ int listener_sockfd;
+ uint8_t retry_times;
+ uint8_t ack_retry_times;
+ uint8_t conflicts;
+ guint timeout;
+ guint t1_timeout;
+ guint t2_timeout;
+ guint lease_timeout;
+ guint listener_watch;
+ GList *require_list;
+ GList *request_list;
+ GHashTable *code_value_hash;
+ GHashTable *send_value_hash;
+ GDHCPClientEventFunc lease_available_cb;
+ gpointer lease_available_data;
+ GDHCPClientEventFunc ipv4ll_available_cb;
+ gpointer ipv4ll_available_data;
+ GDHCPClientEventFunc no_lease_cb;
+ gpointer no_lease_data;
+ GDHCPClientEventFunc lease_lost_cb;
+ gpointer lease_lost_data;
+ GDHCPClientEventFunc ipv4ll_lost_cb;
+ gpointer ipv4ll_lost_data;
+ GDHCPClientEventFunc address_conflict_cb;
+ gpointer address_conflict_data;
+ GDHCPDebugFunc debug_func;
+ gpointer debug_data;
+ GDHCPClientEventFunc information_req_cb;
+ gpointer information_req_data;
+ GDHCPClientEventFunc solicitation_cb;
+ gpointer solicitation_data;
+ GDHCPClientEventFunc advertise_cb;
+ gpointer advertise_data;
+ GDHCPClientEventFunc request_cb;
+ gpointer request_data;
+ GDHCPClientEventFunc renew_cb;
+ gpointer renew_data;
+ GDHCPClientEventFunc wake_event_cb;
+ gpointer wake_event_data;
+ GDHCPClientEventFunc rebind_cb;
+ gpointer rebind_data;
+ GDHCPClientEventFunc release_cb;
+ gpointer release_data;
+ GDHCPClientEventFunc confirm_cb;
+ gpointer confirm_data;
+ GDHCPClientEventFunc decline_cb;
+ gpointer decline_data;
+ char *last_address;
+ unsigned char *duid;
+ int duid_len;
+ unsigned char *server_duid;
+ int server_duid_len;
+ uint16_t status_code;
+ uint32_t iaid;
+ uint32_t T1, T2;
+ uint32_t next_event;
+ int can_sleep;
+ struct in6_addr ia_na;
+ struct in6_addr ia_ta;
+ time_t last_request;
+ uint32_t expire;
+ bool retransmit;
+ struct timeval start_time;
+ bool request_bcast;
+};
+
+static inline void debug(GDHCPClient *client, const char *format, ...)
+{
+ char str[256];
+ va_list ap;
+
+ if (!client->debug_func)
+ return;
+
+ va_start(ap, format);
+
+ if (vsnprintf(str, sizeof(str), format, ap) > 0)
+ client->debug_func(str, client->debug_data);
+
+ va_end(ap);
+}
+
+static void set_wake(GDHCPClient *dhcp_client, uint32_t timeout)
+{
+ debug(dhcp_client, "Stay awake for %d", timeout);
+
+ dhcp_client->next_event = timeout + time(NULL);
+ dhcp_client->can_sleep = FALSE;
+ if (dhcp_client->wake_event_cb)
+ dhcp_client->wake_event_cb(dhcp_client,
+ dhcp_client->wake_event_data);
+}
+
+static void release_wake(GDHCPClient *dhcp_client, uint32_t timeout)
+{
+ debug(dhcp_client, "may sleep for %d", timeout);
+ dhcp_client->next_event = timeout + time(NULL);
+ dhcp_client->can_sleep = TRUE;
+ if (dhcp_client->wake_event_cb)
+ dhcp_client->wake_event_cb(dhcp_client,
+ dhcp_client->wake_event_data);
+}
+
+int g_dhcp_get_next_event(GDHCPClient *dhcp_client, time_t *next_event)
+{
+ *next_event = dhcp_client->next_event;
+ return dhcp_client->can_sleep;
+}
+
+/* Initialize the packet with the proper defaults */
+static void init_packet(GDHCPClient *dhcp_client, gpointer pkt, char type)
+{
+ if (dhcp_client->type == G_DHCP_IPV6)
+ dhcpv6_init_header(pkt, type);
+ else {
+ struct dhcp_packet *packet = pkt;
+
+ dhcp_init_header(packet, type);
+ memcpy(packet->chaddr, dhcp_client->mac_address, 6);
+ }
+}
+
+static void add_request_options(GDHCPClient *dhcp_client,
+ struct dhcp_packet *packet)
+{
+ int len = 0;
+ GList *list;
+ uint8_t code;
+ int end = dhcp_end_option(packet->options);
+
+ for (list = dhcp_client->request_list; list; list = list->next) {
+ code = (uint8_t) GPOINTER_TO_INT(list->data);
+
+ packet->options[end + OPT_DATA + len] = code;
+ len++;
+ }
+
+ if (len) {
+ packet->options[end + OPT_CODE] = DHCP_PARAM_REQ;
+ packet->options[end + OPT_LEN] = len;
+ packet->options[end + OPT_DATA + len] = DHCP_END;
+ }
+}
+
+struct hash_params {
+ unsigned char *buf;
+ int max_buf;
+ unsigned char **ptr_buf;
+};
+
+static void add_dhcpv6_binary_option(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ uint8_t *option = value;
+ uint16_t len;
+ struct hash_params *params = user_data;
+
+ /* option[0][1] contains option code */
+ len = option[2] << 8 | option[3];
+
+ if ((*params->ptr_buf + len + 2 + 2) > (params->buf + params->max_buf))
+ return;
+
+ memcpy(*params->ptr_buf, option, len + 2 + 2);
+ (*params->ptr_buf) += len + 2 + 2;
+}
+
+static void add_dhcpv6_send_options(GDHCPClient *dhcp_client,
+ unsigned char *buf, int max_buf,
+ unsigned char **ptr_buf)
+{
+ struct hash_params params = {
+ .buf = buf,
+ .max_buf = max_buf,
+ .ptr_buf = ptr_buf
+ };
+
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+
+ g_hash_table_foreach(dhcp_client->send_value_hash,
+ add_dhcpv6_binary_option, ¶ms);
+
+ *ptr_buf = *params.ptr_buf;
+}
+
+static void copy_option(uint8_t *buf, uint16_t code, uint16_t len,
+ uint8_t *msg)
+{
+ buf[0] = code >> 8;
+ buf[1] = code & 0xff;
+ buf[2] = len >> 8;
+ buf[3] = len & 0xff;
+ if (len > 0 && msg)
+ memcpy(&buf[4], msg, len);
+}
+
+static int32_t get_time_diff(struct timeval *tv)
+{
+ struct timeval now;
+ int32_t hsec;
+
+ gettimeofday(&now, NULL);
+
+ hsec = (now.tv_sec - tv->tv_sec) * 100;
+ hsec += (now.tv_usec - tv->tv_usec) / 10000;
+
+ return hsec;
+}
+
+static void remove_timeouts(GDHCPClient *dhcp_client)
+{
+
+ if (dhcp_client->timeout > 0)
+ g_rttimeout_source_remove(dhcp_client->timeout);
+ if (dhcp_client->t1_timeout > 0)
+ g_rttimeout_source_remove(dhcp_client->t1_timeout);
+ if (dhcp_client->t2_timeout > 0)
+ g_rttimeout_source_remove(dhcp_client->t2_timeout);
+ if (dhcp_client->lease_timeout > 0)
+ g_rttimeout_source_remove(dhcp_client->lease_timeout);
+
+ dhcp_client->timeout = 0;
+ dhcp_client->t1_timeout = 0;
+ dhcp_client->t2_timeout = 0;
+ dhcp_client->lease_timeout = 0;
+
+}
+
+static void add_dhcpv6_request_options(GDHCPClient *dhcp_client,
+ struct dhcpv6_packet *packet,
+ unsigned char *buf, int max_buf,
+ unsigned char **ptr_buf)
+{
+ GList *list;
+ uint16_t code, value;
+ bool added;
+ int32_t diff;
+ int len;
+
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+
+ for (list = dhcp_client->request_list; list; list = list->next) {
+ code = (uint16_t) GPOINTER_TO_INT(list->data);
+ added = false;
+
+ switch (code) {
+ case G_DHCPV6_CLIENTID:
+ if (!dhcp_client->duid)
+ return;
+
+ len = 2 + 2 + dhcp_client->duid_len;
+ if ((*ptr_buf + len) > (buf + max_buf)) {
+ debug(dhcp_client, "Too long dhcpv6 message "
+ "when writing client id option");
+ return;
+ }
+
+ copy_option(*ptr_buf, G_DHCPV6_CLIENTID,
+ dhcp_client->duid_len, dhcp_client->duid);
+ (*ptr_buf) += len;
+ added = true;
+ break;
+
+ case G_DHCPV6_SERVERID:
+ if (!dhcp_client->server_duid)
+ break;
+
+ len = 2 + 2 + dhcp_client->server_duid_len;
+ if ((*ptr_buf + len) > (buf + max_buf)) {
+ debug(dhcp_client, "Too long dhcpv6 message "
+ "when writing server id option");
+ return;
+ }
+
+ copy_option(*ptr_buf, G_DHCPV6_SERVERID,
+ dhcp_client->server_duid_len,
+ dhcp_client->server_duid);
+ (*ptr_buf) += len;
+ added = true;
+ break;
+
+ case G_DHCPV6_RAPID_COMMIT:
+ len = 2 + 2;
+ if ((*ptr_buf + len) > (buf + max_buf)) {
+ debug(dhcp_client, "Too long dhcpv6 message "
+ "when writing rapid commit option");
+ return;
+ }
+
+ copy_option(*ptr_buf, G_DHCPV6_RAPID_COMMIT, 0, 0);
+ (*ptr_buf) += len;
+ added = true;
+ break;
+
+ case G_DHCPV6_ORO:
+ break;
+
+ case G_DHCPV6_ELAPSED_TIME:
+ if (!dhcp_client->retransmit) {
+ /*
+ * Initial message, elapsed time is 0.
+ */
+ diff = 0;
+ } else {
+ diff = get_time_diff(&dhcp_client->start_time);
+ if (diff < 0 || diff > 0xffff)
+ diff = 0xffff;
+ }
+
+ len = 2 + 2 + 2;
+ if ((*ptr_buf + len) > (buf + max_buf)) {
+ debug(dhcp_client, "Too long dhcpv6 message "
+ "when writing elapsed time option");
+ return;
+ }
+
+ value = htons((uint16_t)diff);
+ copy_option(*ptr_buf, G_DHCPV6_ELAPSED_TIME,
+ 2, (uint8_t *)&value);
+ (*ptr_buf) += len;
+ added = true;
+ break;
+
+ case G_DHCPV6_DNS_SERVERS:
+ break;
+
+ case G_DHCPV6_DOMAIN_LIST:
+ break;
+
+ case G_DHCPV6_SNTP_SERVERS:
+ break;
+
+ default:
+ break;
+ }
+
+ if (added)
+ debug(dhcp_client, "option %d len %d added", code, len);
+ }
+}
+
+static void add_binary_option(gpointer key, gpointer value, gpointer user_data)
+{
+ uint8_t *option = value;
+ struct dhcp_packet *packet = user_data;
+
+ dhcp_add_binary_option(packet, option);
+}
+
+static void add_send_options(GDHCPClient *dhcp_client,
+ struct dhcp_packet *packet)
+{
+ g_hash_table_foreach(dhcp_client->send_value_hash,
+ add_binary_option, packet);
+}
+
+static const char *get_message_type(uint8_t type)
+{
+ switch (type) {
+ case DHCPDISCOVER:
+ return "DISCOVER";
+ case DHCPOFFER:
+ return "OFFER";
+ case DHCPREQUEST:
+ return "REQUEST";
+ case DHCPDECLINE:
+ return "DECLINE";
+ case DHCPACK:
+ return "ACK";
+ case DHCPNAK:
+ return "NAK";
+ case DHCPRELEASE:
+ return "RELEASE";
+ case DHCPINFORM:
+ return "INFORM";
+ default:
+ return "";
+ }
+}
+/*
+ * Return an RFC 951- and 2131-complaint BOOTP 'secs' value that
+ * represents the number of seconds elapsed from the start of
+ * attempting DHCP to satisfy some DHCP servers that allow for an
+ * "authoritative" reply before responding.
+ */
+static uint16_t dhcp_attempt_secs(GDHCPClient *dhcp_client)
+{
+ return htons(MIN(time(NULL) - dhcp_client->start, UINT16_MAX));
+}
+
+static int send_discover(GDHCPClient *dhcp_client, uint32_t requested)
+{
+ const uint8_t type = DHCPDISCOVER;
+ struct dhcp_packet packet;
+ struct in_addr dest;
+ char destbuf[INET_ADDRSTRLEN];
+
+ init_packet(dhcp_client, &packet, type);
+
+ packet.xid = dhcp_client->xid;
+ packet.secs = dhcp_attempt_secs(dhcp_client);
+
+ if (requested)
+ dhcp_add_option_uint32(&packet, DHCP_REQUESTED_IP, requested);
+
+ /* Explicitly saying that we want RFC-compliant packets helps
+ * some buggy DHCP servers to NOT send bigger packets */
+ dhcp_add_option_uint16(&packet, DHCP_MAX_SIZE, 576);
+
+ add_request_options(dhcp_client, &packet);
+
+ add_send_options(dhcp_client, &packet);
+
+ dest.s_addr = INADDR_BROADCAST;
+
+ debug(dhcp_client, "%s on %s to %s port %d interval %d",
+ get_message_type(type),
+ dhcp_client->interface,
+ inet_ntop(AF_INET, &dest, destbuf, sizeof(destbuf)),
+ SERVER_PORT,
+ DISCOVER_TIMEOUT);
+
+ set_wake(dhcp_client, DISCOVER_TIMEOUT);
+
+ return dhcp_send_raw_packet(&packet, INADDR_ANY, CLIENT_PORT,
+ dest.s_addr, SERVER_PORT,
+ MAC_BCAST_ADDR, dhcp_client->ifindex,
+ dhcp_client->retry_times % 2);
+}
+
+static int send_request(GDHCPClient *dhcp_client)
+{
+ const uint8_t type = DHCPREQUEST;
+ struct dhcp_packet packet;
+ struct in_addr rlog, dlog;
+ char requestbuf[INET_ADDRSTRLEN], destbuf[INET_ADDRSTRLEN];
+
+ debug(dhcp_client, "sending DHCP request (state %d)",
+ dhcp_client->state);
+
+ init_packet(dhcp_client, &packet, type);
+
+ packet.xid = dhcp_client->xid;
+ packet.secs = dhcp_attempt_secs(dhcp_client);
+
+ if (dhcp_client->state == REQUESTING || dhcp_client->state == REBOOTING)
+ dhcp_add_option_uint32(&packet, DHCP_REQUESTED_IP,
+ dhcp_client->requested_ip);
+
+ if (dhcp_client->state == REQUESTING)
+ dhcp_add_option_uint32(&packet, DHCP_SERVER_ID,
+ dhcp_client->server_ip);
+
+ dhcp_add_option_uint16(&packet, DHCP_MAX_SIZE, 576);
+
+ add_request_options(dhcp_client, &packet);
+
+ add_send_options(dhcp_client, &packet);
+
+ rlog.s_addr = htonl(dhcp_client->requested_ip);
+ dlog.s_addr = INADDR_BROADCAST;
+ debug(dhcp_client, "%s of %s on %s to %s port %d interval %d",
+ get_message_type(type),
+ inet_ntop(AF_INET, &rlog, requestbuf, sizeof(requestbuf)),
+ dhcp_client->interface,
+ inet_ntop(AF_INET, &dlog, destbuf, sizeof(destbuf)),
+ SERVER_PORT,
+ REQUEST_TIMEOUT);
+
+ if (dhcp_client->state == RENEWING || dhcp_client->state == REBINDING)
+ packet.ciaddr = htonl(dhcp_client->requested_ip);
+
+ set_wake(dhcp_client, REQUEST_TIMEOUT);
+
+ if (dhcp_client->state == RENEWING )
+ return dhcp_send_kernel_packet(&packet,
+ dhcp_client->requested_ip, CLIENT_PORT,
+ dhcp_client->server_ip, SERVER_PORT,
+ dhcp_client->listener_sockfd);
+
+ return dhcp_send_raw_packet(&packet, INADDR_ANY, CLIENT_PORT,
+ INADDR_BROADCAST, SERVER_PORT,
+ MAC_BCAST_ADDR, dhcp_client->ifindex,
+ dhcp_client->request_bcast);
+}
+
+static int send_release(GDHCPClient *dhcp_client,
+ uint32_t server, uint32_t ciaddr)
+{
+ const uint8_t type = DHCPRELEASE;
+ struct dhcp_packet packet;
+ uint64_t rand;
+ struct in_addr rlog, dlog;
+ char releasebuf[INET_ADDRSTRLEN], destbuf[INET_ADDRSTRLEN];
+
+ debug(dhcp_client, "sending DHCP release request");
+
+ init_packet(dhcp_client, &packet, DHCPRELEASE);
+ dhcp_get_random(&rand);
+ packet.xid = rand;
+ packet.ciaddr = htonl(ciaddr);
+
+ dhcp_add_option_uint32(&packet, DHCP_SERVER_ID, server);
+
+ rlog.s_addr = htonl(ciaddr);
+ dlog.s_addr = htonl(server);
+ debug(dhcp_client, "%s of %s on %s to %s port %d",
+ get_message_type(type),
+ inet_ntop(AF_INET, &rlog, releasebuf, sizeof(releasebuf)),
+ dhcp_client->interface,
+ inet_ntop(AF_INET, &dlog, destbuf, sizeof(destbuf)),
+ SERVER_PORT);
+
+ return dhcp_send_kernel_packet(&packet, ciaddr, CLIENT_PORT,
+ server, SERVER_PORT,
+ dhcp_client->listener_sockfd);
+}
+
+static gboolean ipv4ll_probe_timeout(gpointer dhcp_data);
+static int switch_listening_mode(GDHCPClient *dhcp_client,
+ ListenMode listen_mode);
+
+static gboolean send_probe_packet(gpointer dhcp_data)
+{
+ GDHCPClient *dhcp_client;
+ guint timeout;
+
+ dhcp_client = dhcp_data;
+ /* if requested_ip is not valid, pick a new address*/
+ if (dhcp_client->requested_ip == 0) {
+ debug(dhcp_client, "pick a new random address");
+ dhcp_client->requested_ip = ipv4ll_random_ip();
+ }
+
+ debug(dhcp_client, "sending IPV4LL probe request");
+
+ if (dhcp_client->retry_times == 1) {
+ dhcp_client->state = IPV4LL_PROBE;
+ switch_listening_mode(dhcp_client, L_ARP);
+ }
+ ipv4ll_send_arp_packet(dhcp_client->mac_address, 0,
+ dhcp_client->requested_ip, dhcp_client->ifindex);
+
+ if (dhcp_client->retry_times < PROBE_NUM) {
+ /*add a random timeout in range of PROBE_MIN to PROBE_MAX*/
+ timeout = ipv4ll_random_delay_ms(PROBE_MAX-PROBE_MIN);
+ timeout += PROBE_MIN*1000;
+ } else
+ timeout = (ANNOUNCE_WAIT * 1000);
+
+ dhcp_client->timeout = g_rttimeout_add_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ timeout,
+ ipv4ll_probe_timeout,
+ dhcp_client,
+ NULL);
+ return FALSE;
+}
+
+static gboolean ipv4ll_announce_timeout(gpointer dhcp_data);
+static gboolean ipv4ll_defend_timeout(gpointer dhcp_data);
+
+static gboolean send_announce_packet(gpointer dhcp_data)
+{
+ GDHCPClient *dhcp_client;
+
+ dhcp_client = dhcp_data;
+
+ debug(dhcp_client, "sending IPV4LL announce request");
+
+ ipv4ll_send_arp_packet(dhcp_client->mac_address,
+ dhcp_client->requested_ip,
+ dhcp_client->requested_ip,
+ dhcp_client->ifindex);
+
+ remove_timeouts(dhcp_client);
+
+ if (dhcp_client->state == IPV4LL_DEFEND) {
+ dhcp_client->timeout =
+ g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ DEFEND_INTERVAL,
+ ipv4ll_defend_timeout,
+ dhcp_client,
+ NULL);
+ return TRUE;
+ } else
+ dhcp_client->timeout =
+ g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ ANNOUNCE_INTERVAL,
+ ipv4ll_announce_timeout,
+ dhcp_client,
+ NULL);
+ return TRUE;
+}
+
+static void get_interface_mac_address(int index, uint8_t *mac_address)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ perror("Open socket error");
+ return;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+ if (err < 0) {
+ perror("Get interface name error");
+ goto done;
+ }
+
+ err = ioctl(sk, SIOCGIFHWADDR, &ifr);
+ if (err < 0) {
+ perror("Get mac address error");
+ goto done;
+ }
+
+ memcpy(mac_address, ifr.ifr_hwaddr.sa_data, 6);
+
+done:
+ close(sk);
+}
+
+void g_dhcpv6_client_set_retransmit(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client)
+ return;
+
+ dhcp_client->retransmit = true;
+}
+
+void g_dhcpv6_client_clear_retransmit(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client)
+ return;
+
+ dhcp_client->retransmit = false;
+}
+
+int g_dhcpv6_create_duid(GDHCPDuidType duid_type, int index, int type,
+ unsigned char **duid, int *duid_len)
+{
+ time_t duid_time;
+
+ switch (duid_type) {
+ case G_DHCPV6_DUID_LLT:
+ *duid_len = 2 + 2 + 4 + ETH_ALEN;
+ *duid = g_try_malloc(*duid_len);
+ if (!*duid)
+ return -ENOMEM;
+
+ (*duid)[0] = 0;
+ (*duid)[1] = 1;
+ get_interface_mac_address(index, &(*duid)[2 + 2 + 4]);
+ (*duid)[2] = 0;
+ (*duid)[3] = type;
+ duid_time = time(NULL) - DUID_TIME_EPOCH;
+ (*duid)[4] = duid_time >> 24;
+ (*duid)[5] = duid_time >> 16;
+ (*duid)[6] = duid_time >> 8;
+ (*duid)[7] = duid_time & 0xff;
+ break;
+ case G_DHCPV6_DUID_EN:
+ return -EINVAL;
+ case G_DHCPV6_DUID_LL:
+ *duid_len = 2 + 2 + ETH_ALEN;
+ *duid = g_try_malloc(*duid_len);
+ if (!*duid)
+ return -ENOMEM;
+
+ (*duid)[0] = 0;
+ (*duid)[1] = 3;
+ get_interface_mac_address(index, &(*duid)[2 + 2]);
+ (*duid)[2] = 0;
+ (*duid)[3] = type;
+ break;
+ }
+
+ return 0;
+}
+
+static gchar *convert_to_hex(unsigned char *buf, int len)
+{
+ gchar *ret = g_try_malloc(len * 2 + 1);
+ int i;
+
+ for (i = 0; ret && i < len; i++)
+ g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
+
+ return ret;
+}
+
+int g_dhcpv6_client_set_duid(GDHCPClient *dhcp_client, unsigned char *duid,
+ int duid_len)
+{
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return -EINVAL;
+
+ g_free(dhcp_client->duid);
+
+ dhcp_client->duid = duid;
+ dhcp_client->duid_len = duid_len;
+
+ if (dhcp_client->debug_func) {
+ gchar *hex = convert_to_hex(duid, duid_len);
+ debug(dhcp_client, "DUID(%d) %s", duid_len, hex);
+ g_free(hex);
+ }
+
+ return 0;
+}
+
+int g_dhcpv6_client_set_pd(GDHCPClient *dhcp_client, uint32_t *T1,
+ uint32_t *T2, GSList *prefixes)
+{
+ uint8_t options[1452];
+ unsigned int max_buf = sizeof(options);
+ int len, count = g_slist_length(prefixes);
+
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return -EINVAL;
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_IA_PD);
+
+ memset(options, 0, sizeof(options));
+
+ options[0] = dhcp_client->iaid >> 24;
+ options[1] = dhcp_client->iaid >> 16;
+ options[2] = dhcp_client->iaid >> 8;
+ options[3] = dhcp_client->iaid;
+
+ if (T1) {
+ uint32_t t = htonl(*T1);
+ memcpy(&options[4], &t, 4);
+ }
+
+ if (T2) {
+ uint32_t t = htonl(*T2);
+ memcpy(&options[8], &t, 4);
+ }
+
+ len = 12;
+
+ if (count > 0) {
+ GSList *list;
+
+ for (list = prefixes; list; list = list->next) {
+ GDHCPIAPrefix *prefix = list->data;
+ uint8_t sub_option[4+4+1+16];
+
+ if ((len + 2 + 2 + sizeof(sub_option)) >= max_buf) {
+ debug(dhcp_client,
+ "Too long dhcpv6 message "
+ "when writing IA prefix option");
+ return -EINVAL;
+ }
+
+ memset(&sub_option, 0, sizeof(sub_option));
+
+ /* preferred and validity time are left zero */
+
+ sub_option[8] = prefix->prefixlen;
+ memcpy(&sub_option[9], &prefix->prefix, 16);
+
+ copy_option(&options[len], G_DHCPV6_IA_PREFIX,
+ sizeof(sub_option), sub_option);
+ len += 2 + 2 + sizeof(sub_option);
+ }
+ }
+
+ g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_PD,
+ options, len);
+
+ return 0;
+}
+
+uint32_t g_dhcpv6_client_get_iaid(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return 0;
+
+ return dhcp_client->iaid;
+}
+
+void g_dhcpv6_client_set_iaid(GDHCPClient *dhcp_client, uint32_t iaid)
+{
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return;
+
+ dhcp_client->iaid = iaid;
+}
+
+void g_dhcpv6_client_create_iaid(GDHCPClient *dhcp_client, int index,
+ unsigned char *iaid)
+{
+ uint8_t buf[6];
+
+ get_interface_mac_address(index, buf);
+
+ memcpy(iaid, &buf[2], 4);
+ dhcp_client->iaid = iaid[0] << 24 |
+ iaid[1] << 16 | iaid[2] << 8 | iaid[3];
+}
+
+int g_dhcpv6_client_get_timeouts(GDHCPClient *dhcp_client,
+ uint32_t *T1, uint32_t *T2,
+ time_t *started,
+ time_t *expire)
+{
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return -EINVAL;
+
+ if (T1)
+ *T1 = dhcp_client->T1;
+
+ if (T2)
+ *T2 = dhcp_client->T2;
+
+ if (started)
+ *started = dhcp_client->last_request;
+
+ if (expire)
+ *expire = dhcp_client->last_request + dhcp_client->expire;
+
+ return 0;
+}
+
+static uint8_t *create_iaaddr(GDHCPClient *dhcp_client, uint8_t *buf,
+ uint16_t len)
+{
+ buf[0] = 0;
+ buf[1] = G_DHCPV6_IAADDR;
+ buf[2] = 0;
+ buf[3] = len;
+ memcpy(&buf[4], &dhcp_client->ia_na, 16);
+ memset(&buf[20], 0, 4); /* preferred */
+ memset(&buf[24], 0, 4); /* valid */
+ return buf;
+}
+
+static uint8_t *append_iaaddr(GDHCPClient *dhcp_client, uint8_t *buf,
+ const char *address)
+{
+ struct in6_addr addr;
+
+ if (inet_pton(AF_INET6, address, &addr) != 1)
+ return NULL;
+
+ buf[0] = 0;
+ buf[1] = G_DHCPV6_IAADDR;
+ buf[2] = 0;
+ buf[3] = 24;
+ memcpy(&buf[4], &addr, 16);
+ memset(&buf[20], 0, 4); /* preferred */
+ memset(&buf[24], 0, 4); /* valid */
+ return &buf[28];
+}
+
+static void put_iaid(GDHCPClient *dhcp_client, int index, uint8_t *buf)
+{
+ uint32_t iaid;
+
+ iaid = g_dhcpv6_client_get_iaid(dhcp_client);
+ if (iaid == 0) {
+ g_dhcpv6_client_create_iaid(dhcp_client, index, buf);
+ return;
+ }
+
+ buf[0] = iaid >> 24;
+ buf[1] = iaid >> 16;
+ buf[2] = iaid >> 8;
+ buf[3] = iaid;
+}
+
+int g_dhcpv6_client_set_ia(GDHCPClient *dhcp_client, int index,
+ int code, uint32_t *T1, uint32_t *T2,
+ bool add_iaaddr, const char *ia_na)
+{
+ if (code == G_DHCPV6_IA_TA) {
+ uint8_t ia_options[4];
+
+ put_iaid(dhcp_client, index, ia_options);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_IA_TA);
+ g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_TA,
+ ia_options, sizeof(ia_options));
+
+ } else if (code == G_DHCPV6_IA_NA) {
+ struct in6_addr addr;
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_IA_NA);
+
+ /*
+ * If caller has specified the IPv6 address it wishes to
+ * to use (ia_na != NULL and address is valid), then send
+ * the address to server.
+ * If caller did not specify the address (ia_na == NULL) and
+ * if the current address is not set, then we should not send
+ * the address sub-option.
+ */
+ if (add_iaaddr && ((!ia_na &&
+ !IN6_IS_ADDR_UNSPECIFIED(&dhcp_client->ia_na))
+ || (ia_na &&
+ inet_pton(AF_INET6, ia_na, &addr) == 1))) {
+#define IAADDR_LEN (16+4+4)
+ uint8_t ia_options[4+4+4+2+2+IAADDR_LEN];
+
+ if (ia_na)
+ memcpy(&dhcp_client->ia_na, &addr,
+ sizeof(struct in6_addr));
+
+ put_iaid(dhcp_client, index, ia_options);
+
+ if (T1) {
+ ia_options[4] = *T1 >> 24;
+ ia_options[5] = *T1 >> 16;
+ ia_options[6] = *T1 >> 8;
+ ia_options[7] = *T1;
+ } else
+ memset(&ia_options[4], 0x00, 4);
+
+ if (T2) {
+ ia_options[8] = *T2 >> 24;
+ ia_options[9] = *T2 >> 16;
+ ia_options[10] = *T2 >> 8;
+ ia_options[11] = *T2;
+ } else
+ memset(&ia_options[8], 0x00, 4);
+
+ create_iaaddr(dhcp_client, &ia_options[12],
+ IAADDR_LEN);
+
+ g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_NA,
+ ia_options, sizeof(ia_options));
+ } else {
+ uint8_t ia_options[4+4+4];
+
+ put_iaid(dhcp_client, index, ia_options);
+
+ memset(&ia_options[4], 0x00, 4); /* T1 (4 bytes) */
+ memset(&ia_options[8], 0x00, 4); /* T2 (4 bytes) */
+
+ g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_IA_NA,
+ ia_options, sizeof(ia_options));
+ }
+
+ } else
+ return -EINVAL;
+
+ return 0;
+}
+
+int g_dhcpv6_client_set_ias(GDHCPClient *dhcp_client, int index,
+ int code, uint32_t *T1, uint32_t *T2,
+ GSList *addresses)
+{
+ GSList *list;
+ uint8_t *ia_options, *pos;
+ int len, count, total_len;
+
+ count = g_slist_length(addresses);
+ if (count == 0)
+ return -EINVAL;
+
+ g_dhcp_client_set_request(dhcp_client, code);
+
+ if (code == G_DHCPV6_IA_TA)
+ len = 4; /* IAID */
+ else if (code == G_DHCPV6_IA_NA)
+ len = 4 + 4 + 4; /* IAID + T1 + T2 */
+ else
+ return -EINVAL;
+
+ total_len = len + count * (2 + 2 + 16 + 4 + 4);
+ ia_options = g_try_malloc0(total_len);
+ if (!ia_options)
+ return -ENOMEM;
+
+ put_iaid(dhcp_client, index, ia_options);
+
+ pos = &ia_options[len]; /* skip the IA_NA or IA_TA */
+
+ for (list = addresses; list; list = list->next) {
+ pos = append_iaaddr(dhcp_client, pos, list->data);
+ if (!pos)
+ break;
+ }
+
+ if (code == G_DHCPV6_IA_NA) {
+ if (T1) {
+ ia_options[4] = *T1 >> 24;
+ ia_options[5] = *T1 >> 16;
+ ia_options[6] = *T1 >> 8;
+ ia_options[7] = *T1;
+ } else
+ memset(&ia_options[4], 0x00, 4);
+
+ if (T2) {
+ ia_options[8] = *T2 >> 24;
+ ia_options[9] = *T2 >> 16;
+ ia_options[10] = *T2 >> 8;
+ ia_options[11] = *T2;
+ } else
+ memset(&ia_options[8], 0x00, 4);
+ }
+
+ g_dhcpv6_client_set_send(dhcp_client, code, ia_options, total_len);
+
+ g_free(ia_options);
+
+ return 0;
+}
+
+int g_dhcpv6_client_set_oro(GDHCPClient *dhcp_client, int args, ...)
+{
+ va_list va;
+ int i, j, len = sizeof(uint16_t) * args;
+ uint8_t *values;
+
+ values = g_try_malloc(len);
+ if (!values)
+ return -ENOMEM;
+
+ va_start(va, args);
+ for (i = 0, j = 0; i < args; i++) {
+ uint16_t value = va_arg(va, int);
+ values[j++] = value >> 8;
+ values[j++] = value & 0xff;
+ }
+ va_end(va);
+
+ g_dhcpv6_client_set_send(dhcp_client, G_DHCPV6_ORO, values, len);
+
+ g_free(values);
+
+ return 0;
+}
+
+static int send_dhcpv6_msg(GDHCPClient *dhcp_client, int type, char *msg)
+{
+ struct dhcpv6_packet *packet;
+ uint8_t buf[MAX_DHCPV6_PKT_SIZE];
+ unsigned char *ptr;
+ int ret, max_buf;
+
+ memset(buf, 0, sizeof(buf));
+ packet = (struct dhcpv6_packet *)&buf[0];
+ ptr = buf + sizeof(struct dhcpv6_packet);
+
+ debug(dhcp_client, "sending DHCPv6 %s message", msg);
+
+ init_packet(dhcp_client, packet, type);
+
+ if (!dhcp_client->retransmit) {
+ dhcp_client->xid = packet->transaction_id[0] << 16 |
+ packet->transaction_id[1] << 8 |
+ packet->transaction_id[2];
+ gettimeofday(&dhcp_client->start_time, NULL);
+ } else {
+ packet->transaction_id[0] = dhcp_client->xid >> 16;
+ packet->transaction_id[1] = dhcp_client->xid >> 8 ;
+ packet->transaction_id[2] = dhcp_client->xid;
+ }
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_ELAPSED_TIME);
+
+ debug(dhcp_client, "sending DHCPv6 %s message xid 0x%04x", msg,
+ dhcp_client->xid);
+
+ max_buf = MAX_DHCPV6_PKT_SIZE - sizeof(struct dhcpv6_packet);
+
+ add_dhcpv6_request_options(dhcp_client, packet, buf, max_buf, &ptr);
+
+ add_dhcpv6_send_options(dhcp_client, buf, max_buf, &ptr);
+
+ ret = dhcpv6_send_packet(dhcp_client->ifindex, packet, ptr - buf);
+
+ debug(dhcp_client, "sent %d pkt %p len %d", ret, packet, ptr - buf);
+ return ret;
+}
+
+static int send_solicitation(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_SOLICIT, "solicit");
+}
+
+static int send_dhcpv6_request(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_REQUEST, "request");
+}
+
+static int send_dhcpv6_confirm(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_CONFIRM, "confirm");
+}
+
+static int send_dhcpv6_renew(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_RENEW, "renew");
+}
+
+static int send_dhcpv6_rebind(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_REBIND, "rebind");
+}
+
+static int send_dhcpv6_decline(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_DECLINE, "decline");
+}
+
+static int send_dhcpv6_release(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_RELEASE, "release");
+}
+
+static int send_information_req(GDHCPClient *dhcp_client)
+{
+ return send_dhcpv6_msg(dhcp_client, DHCPV6_INFORMATION_REQ,
+ "information-req");
+}
+
+static void remove_value(gpointer data, gpointer user_data)
+{
+ char *value = data;
+ g_free(value);
+}
+
+static void remove_option_value(gpointer data)
+{
+ GList *option_value = data;
+
+ g_list_foreach(option_value, remove_value, NULL);
+ g_list_free(option_value);
+}
+
+GDHCPClient *g_dhcp_client_new(GDHCPType type,
+ int ifindex, GDHCPClientError *error)
+{
+ GDHCPClient *dhcp_client;
+
+ if (ifindex < 0) {
+ *error = G_DHCP_CLIENT_ERROR_INVALID_INDEX;
+ return NULL;
+ }
+
+ dhcp_client = g_try_new0(GDHCPClient, 1);
+ if (!dhcp_client) {
+ *error = G_DHCP_CLIENT_ERROR_NOMEM;
+ return NULL;
+ }
+
+ dhcp_client->interface = get_interface_name(ifindex);
+ if (!dhcp_client->interface) {
+ *error = G_DHCP_CLIENT_ERROR_INTERFACE_UNAVAILABLE;
+ goto error;
+ }
+
+ if (!interface_is_up(ifindex)) {
+ *error = G_DHCP_CLIENT_ERROR_INTERFACE_DOWN;
+ goto error;
+ }
+
+ get_interface_mac_address(ifindex, dhcp_client->mac_address);
+
+ dhcp_client->listener_sockfd = -1;
+ dhcp_client->listen_mode = L_NONE;
+ dhcp_client->ref_count = 1;
+ dhcp_client->type = type;
+ dhcp_client->ifindex = ifindex;
+ dhcp_client->lease_available_cb = NULL;
+ dhcp_client->ipv4ll_available_cb = NULL;
+ dhcp_client->no_lease_cb = NULL;
+ dhcp_client->lease_lost_cb = NULL;
+ dhcp_client->ipv4ll_lost_cb = NULL;
+ dhcp_client->address_conflict_cb = NULL;
+ dhcp_client->listener_watch = 0;
+ dhcp_client->retry_times = 0;
+ dhcp_client->ack_retry_times = 0;
+ dhcp_client->code_value_hash = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL, remove_option_value);
+ dhcp_client->send_value_hash = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL, g_free);
+ dhcp_client->request_list = NULL;
+ dhcp_client->require_list = NULL;
+ dhcp_client->duid = NULL;
+ dhcp_client->duid_len = 0;
+ dhcp_client->last_request = time(NULL);
+ dhcp_client->expire = 0;
+ dhcp_client->request_bcast = false;
+
+ *error = G_DHCP_CLIENT_ERROR_NONE;
+
+ return dhcp_client;
+
+error:
+ g_free(dhcp_client->interface);
+ g_free(dhcp_client);
+ return NULL;
+}
+
+#define SERVER_AND_CLIENT_PORTS ((67 << 16) + 68)
+
+static int dhcp_l2_socket(int ifindex)
+{
+ int fd;
+ struct sockaddr_ll sock;
+
+ /*
+ * Comment:
+ *
+ * I've selected not to see LL header, so BPF doesn't see it, too.
+ * The filter may also pass non-IP and non-ARP packets, but we do
+ * a more complete check when receiving the message in userspace.
+ *
+ * and filter shamelessly stolen from:
+ *
+ * http://www.flamewarmaster.de/software/dhcpclient/
+ *
+ * There are a few other interesting ideas on that page (look under
+ * "Motivation"). Use of netlink events is most interesting. Think
+ * of various network servers listening for events and reconfiguring.
+ * That would obsolete sending HUP signals and/or make use of restarts.
+ *
+ * Copyright: 2006, 2007 Stefan Rompf <sux@loplof.de>.
+ * License: GPL v2.
+ *
+ * TODO: make conditional?
+ */
+ static const struct sock_filter filter_instr[] = {
+ /* check for udp */
+ BPF_STMT(BPF_LD|BPF_B|BPF_ABS, 9),
+ /* L5, L1, is UDP? */
+ BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, IPPROTO_UDP, 2, 0),
+ /* ugly check for arp on ethernet-like and IPv4 */
+ BPF_STMT(BPF_LD|BPF_W|BPF_ABS, 2), /* L1: */
+ BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0x08000604, 3, 4),/* L3, L4 */
+ /* skip IP header */
+ BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0), /* L5: */
+ /* check udp source and destination ports */
+ BPF_STMT(BPF_LD|BPF_W|BPF_IND, 0),
+ /* L3, L4 */
+ BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, SERVER_AND_CLIENT_PORTS, 0, 1),
+ /* returns */
+ BPF_STMT(BPF_RET|BPF_K, 0x0fffffff), /* L3: pass */
+ BPF_STMT(BPF_RET|BPF_K, 0), /* L4: reject */
+ };
+
+ static const struct sock_fprog filter_prog = {
+ .len = sizeof(filter_instr) / sizeof(filter_instr[0]),
+ /* casting const away: */
+ .filter = (struct sock_filter *) filter_instr,
+ };
+
+ fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_IP));
+ if (fd < 0)
+ return -errno;
+
+ if (SERVER_PORT == 67 && CLIENT_PORT == 68)
+ /* Use only if standard ports are in use */
+ setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &filter_prog,
+ sizeof(filter_prog));
+
+ memset(&sock, 0, sizeof(sock));
+ sock.sll_family = AF_PACKET;
+ sock.sll_protocol = htons(ETH_P_IP);
+ sock.sll_ifindex = ifindex;
+
+ if (bind(fd, (struct sockaddr *) &sock, sizeof(sock)) != 0) {
+ int err = -errno;
+ close(fd);
+ return err;
+ }
+
+ return fd;
+}
+
+static bool sanity_check(struct ip_udp_dhcp_packet *packet, int bytes)
+{
+ if (packet->ip.protocol != IPPROTO_UDP)
+ return false;
+
+ if (packet->ip.version != IPVERSION)
+ return false;
+
+ if (packet->ip.ihl != sizeof(packet->ip) >> 2)
+ return false;
+
+ if (packet->udp.dest != htons(CLIENT_PORT))
+ return false;
+
+ if (ntohs(packet->udp.len) != (uint16_t)(bytes - sizeof(packet->ip)))
+ return false;
+
+ return true;
+}
+
+static int dhcp_recv_l2_packet(struct dhcp_packet *dhcp_pkt, int fd,
+ struct sockaddr_in *dst_addr)
+{
+ int bytes;
+ struct ip_udp_dhcp_packet packet;
+ uint16_t check;
+
+ memset(&packet, 0, sizeof(packet));
+
+ bytes = read(fd, &packet, sizeof(packet));
+ if (bytes < 0)
+ return -1;
+
+ if (bytes < (int) (sizeof(packet.ip) + sizeof(packet.udp)))
+ return -1;
+
+ if (bytes < ntohs(packet.ip.tot_len))
+ /* packet is bigger than sizeof(packet), we did partial read */
+ return -1;
+
+ /* ignore any extra garbage bytes */
+ bytes = ntohs(packet.ip.tot_len);
+
+ if (!sanity_check(&packet, bytes))
+ return -1;
+
+ check = packet.ip.check;
+ packet.ip.check = 0;
+ if (check != dhcp_checksum(&packet.ip, sizeof(packet.ip)))
+ return -1;
+
+ /* verify UDP checksum. IP header has to be modified for this */
+ memset(&packet.ip, 0, offsetof(struct iphdr, protocol));
+ /* ip.xx fields which are not memset: protocol, check, saddr, daddr */
+ packet.ip.tot_len = packet.udp.len; /* yes, this is needed */
+ check = packet.udp.check;
+ packet.udp.check = 0;
+ if (check && check != dhcp_checksum(&packet, bytes))
+ return -1;
+
+ memcpy(dhcp_pkt, &packet.data, bytes - (sizeof(packet.ip) +
+ sizeof(packet.udp)));
+
+ if (dhcp_pkt->cookie != htonl(DHCP_MAGIC))
+ return -1;
+
+ dst_addr->sin_addr.s_addr = packet.ip.daddr;
+
+ return bytes - (sizeof(packet.ip) + sizeof(packet.udp));
+}
+
+static void ipv4ll_start(GDHCPClient *dhcp_client)
+{
+ guint timeout;
+
+ remove_timeouts(dhcp_client);
+
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->retry_times = 0;
+ dhcp_client->requested_ip = 0;
+
+ dhcp_client->requested_ip = ipv4ll_random_ip();
+
+ /*first wait a random delay to avoid storm of arp request on boot*/
+ timeout = ipv4ll_random_delay_ms(PROBE_WAIT);
+
+ dhcp_client->retry_times++;
+ dhcp_client->timeout = g_rttimeout_add_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ timeout,
+ send_probe_packet,
+ dhcp_client,
+ NULL);
+}
+
+static void ipv4ll_stop(GDHCPClient *dhcp_client)
+{
+
+ switch_listening_mode(dhcp_client, L_NONE);
+
+ remove_timeouts(dhcp_client);
+
+ if (dhcp_client->listener_watch > 0) {
+ g_source_remove(dhcp_client->listener_watch);
+ dhcp_client->listener_watch = 0;
+ }
+
+ dhcp_client->state = IPV4LL_PROBE;
+ dhcp_client->retry_times = 0;
+ dhcp_client->requested_ip = 0;
+
+ g_free(dhcp_client->assigned_ip);
+ dhcp_client->assigned_ip = NULL;
+}
+
+static int ipv4ll_recv_arp_packet(GDHCPClient *dhcp_client)
+{
+ int bytes;
+ struct ether_arp arp;
+ uint32_t ip_requested;
+ int source_conflict;
+ int target_conflict;
+
+ memset(&arp, 0, sizeof(arp));
+ bytes = read(dhcp_client->listener_sockfd, &arp, sizeof(arp));
+ if (bytes < 0)
+ return bytes;
+
+ if (arp.arp_op != htons(ARPOP_REPLY) &&
+ arp.arp_op != htons(ARPOP_REQUEST))
+ return -EINVAL;
+
+ ip_requested = htonl(dhcp_client->requested_ip);
+ source_conflict = !memcmp(arp.arp_spa, &ip_requested,
+ sizeof(ip_requested));
+
+ target_conflict = !memcmp(arp.arp_tpa, &ip_requested,
+ sizeof(ip_requested));
+
+ if (!source_conflict && !target_conflict)
+ return 0;
+
+ dhcp_client->conflicts++;
+
+ debug(dhcp_client, "IPV4LL conflict detected");
+
+ if (dhcp_client->state == IPV4LL_MONITOR) {
+ if (!source_conflict)
+ return 0;
+ dhcp_client->state = IPV4LL_DEFEND;
+ debug(dhcp_client, "DEFEND mode conflicts : %d",
+ dhcp_client->conflicts);
+ /*Try to defend with a single announce*/
+ send_announce_packet(dhcp_client);
+ return 0;
+ }
+
+ if (dhcp_client->state == IPV4LL_DEFEND) {
+ if (!source_conflict)
+ return 0;
+ else if (dhcp_client->ipv4ll_lost_cb)
+ dhcp_client->ipv4ll_lost_cb(dhcp_client,
+ dhcp_client->ipv4ll_lost_data);
+ }
+
+ ipv4ll_stop(dhcp_client);
+
+ if (dhcp_client->conflicts < MAX_CONFLICTS) {
+ /*restart whole state machine*/
+ dhcp_client->retry_times++;
+ dhcp_client->timeout =
+ g_rttimeout_add_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ ipv4ll_random_delay_ms(PROBE_WAIT),
+ send_probe_packet,
+ dhcp_client,
+ NULL);
+ }
+ /* Here we got a lot of conflicts, RFC3927 states that we have
+ * to wait RATE_LIMIT_INTERVAL before retrying,
+ * but we just report failure.
+ */
+ else if (dhcp_client->no_lease_cb)
+ dhcp_client->no_lease_cb(dhcp_client,
+ dhcp_client->no_lease_data);
+
+ return 0;
+}
+
+static bool check_package_owner(GDHCPClient *dhcp_client, gpointer pkt)
+{
+ if (dhcp_client->type == G_DHCP_IPV6) {
+ struct dhcpv6_packet *packet6 = pkt;
+ uint32_t xid;
+
+ if (!packet6)
+ return false;
+
+ xid = packet6->transaction_id[0] << 16 |
+ packet6->transaction_id[1] << 8 |
+ packet6->transaction_id[2];
+
+ if (xid != dhcp_client->xid)
+ return false;
+ } else {
+ struct dhcp_packet *packet = pkt;
+
+ if (packet->xid != dhcp_client->xid)
+ return false;
+
+ if (packet->hlen != 6)
+ return false;
+
+ if (memcmp(packet->chaddr, dhcp_client->mac_address, 6))
+ return false;
+ }
+
+ return true;
+}
+
+static void start_request(GDHCPClient *dhcp_client);
+
+static gboolean request_timeout(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+
+ debug(dhcp_client, "request timeout (retries %d)",
+ dhcp_client->retry_times);
+
+ dhcp_client->retry_times++;
+
+ start_request(dhcp_client);
+
+ return FALSE;
+}
+
+static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data);
+
+static int switch_listening_mode(GDHCPClient *dhcp_client,
+ ListenMode listen_mode)
+{
+ GIOChannel *listener_channel;
+ int listener_sockfd;
+
+ if (dhcp_client->listen_mode == listen_mode)
+ return 0;
+
+ debug(dhcp_client, "switch listening mode (%d ==> %d)",
+ dhcp_client->listen_mode, listen_mode);
+
+ if (dhcp_client->listen_mode != L_NONE) {
+ if (dhcp_client->listener_watch > 0)
+ g_source_remove(dhcp_client->listener_watch);
+ dhcp_client->listen_mode = L_NONE;
+ dhcp_client->listener_sockfd = -1;
+ dhcp_client->listener_watch = 0;
+ }
+
+ if (listen_mode == L_NONE)
+ return 0;
+
+ if (listen_mode == L2)
+ listener_sockfd = dhcp_l2_socket(dhcp_client->ifindex);
+ else if (listen_mode == L3) {
+ if (dhcp_client->type == G_DHCP_IPV6)
+ listener_sockfd = dhcp_l3_socket(DHCPV6_CLIENT_PORT,
+ dhcp_client->interface,
+ AF_INET6);
+ else
+ listener_sockfd = dhcp_l3_socket(CLIENT_PORT,
+ dhcp_client->interface,
+ AF_INET);
+ } else if (listen_mode == L_ARP)
+ listener_sockfd = ipv4ll_arp_socket(dhcp_client->ifindex);
+ else
+ return -EIO;
+
+ if (listener_sockfd < 0)
+ return -EIO;
+
+ listener_channel = g_io_channel_unix_new(listener_sockfd);
+ if (!listener_channel) {
+ /* Failed to create listener channel */
+ close(listener_sockfd);
+ return -EIO;
+ }
+
+ dhcp_client->listen_mode = listen_mode;
+ dhcp_client->listener_sockfd = listener_sockfd;
+
+ g_io_channel_set_close_on_unref(listener_channel, TRUE);
+ dhcp_client->listener_watch =
+ g_io_add_watch_full(listener_channel, G_PRIORITY_HIGH,
+ G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
+ listener_event, dhcp_client,
+ NULL);
+ g_io_channel_unref(listener_channel);
+
+ return 0;
+}
+
+static void start_request(GDHCPClient *dhcp_client)
+{
+ debug(dhcp_client, "start request (retries %d)",
+ dhcp_client->retry_times);
+
+ if (dhcp_client->retry_times == REQUEST_RETRIES) {
+ if (dhcp_client->no_lease_cb)
+ dhcp_client->no_lease_cb(dhcp_client,
+ dhcp_client->no_lease_data);
+ return;
+ }
+
+ if (dhcp_client->retry_times == 0) {
+ dhcp_client->state = REQUESTING;
+ switch_listening_mode(dhcp_client, L2);
+ }
+
+ send_request(dhcp_client);
+
+ dhcp_client->timeout = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ REQUEST_TIMEOUT,
+ request_timeout,
+ dhcp_client,
+ NULL);
+}
+#define MINIMUM_LEASE_DURATION 3600
+#define MAXIMUM_LEASE_DURATION (30*24*60*60)
+static uint32_t get_lease(GDHCPClient *dhcp_client, struct dhcp_packet *packet)
+{
+ uint8_t *option;
+ uint32_t lease_seconds;
+
+ option = dhcp_get_option(packet, DHCP_LEASE_TIME);
+ if (!option)
+ return 3600;
+
+ lease_seconds = get_be32(option);
+ if (lease_seconds < MINIMUM_LEASE_DURATION)
+ {
+ debug(dhcp_client, "actual lease %d, new lease %d", lease_seconds, MINIMUM_LEASE_DURATION);
+ lease_seconds = MINIMUM_LEASE_DURATION;
+ }
+
+ if (lease_seconds > MAXIMUM_LEASE_DURATION)
+ {
+ debug(dhcp_client, "actual lease %d, new lease %d", lease_seconds, MAXIMUM_LEASE_DURATION);
+ lease_seconds = MAXIMUM_LEASE_DURATION;
+ }
+
+ return lease_seconds;
+}
+
+static void restart_dhcp(GDHCPClient *dhcp_client, int retry_times)
+{
+ debug(dhcp_client, "restart DHCP (retries %d)", retry_times);
+
+ remove_timeouts(dhcp_client);
+
+ dhcp_client->retry_times = retry_times;
+ dhcp_client->requested_ip = 0;
+ dhcp_client->state = INIT_SELECTING;
+ switch_listening_mode(dhcp_client, L2);
+
+ g_dhcp_client_start(dhcp_client, dhcp_client->last_address);
+}
+
+static gboolean start_expire(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+
+ debug(dhcp_client, "lease expired");
+
+ /*remove all timeouts if they are set*/
+ remove_timeouts(dhcp_client);
+
+ restart_dhcp(dhcp_client, 0);
+
+ /* ip need to be cleared */
+ if (dhcp_client->lease_lost_cb)
+ dhcp_client->lease_lost_cb(dhcp_client,
+ dhcp_client->lease_lost_data);
+
+ return false;
+}
+
+static gboolean continue_rebound(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+ uint64_t rand;
+
+ switch_listening_mode(dhcp_client, L2);
+ send_request(dhcp_client);
+
+ if (dhcp_client->t2_timeout> 0)
+ g_source_remove(dhcp_client->t2_timeout);
+
+ /*recalculate remaining rebind time*/
+ dhcp_client->T2 >>= 1;
+ if (dhcp_client->T2 > 60) {
+ dhcp_get_random(&rand);
+ dhcp_client->t2_timeout =
+ g_rttimeout_add_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ dhcp_client->T2 * 1000 + (rand % 2000) - 1000,
+ continue_rebound,
+ dhcp_client,
+ NULL);
+ }
+ set_wake(dhcp_client, REQUEST_TIMEOUT);
+
+ return FALSE;
+}
+
+static gboolean start_rebound(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+
+ /*remove renew timer*/
+ if (dhcp_client->t1_timeout > 0)
+ g_source_remove(dhcp_client->t1_timeout);
+
+ debug(dhcp_client, "start rebound");
+ dhcp_client->state = REBINDING;
+
+ /*calculate total rebind time*/
+ dhcp_client->T2 = dhcp_client->expire - dhcp_client->T2;
+
+ /*send the first rebound and reschedule*/
+ continue_rebound(user_data);
+
+ return FALSE;
+}
+
+static gboolean continue_renew (gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+ uint64_t rand;
+
+ switch_listening_mode(dhcp_client, L3);
+ send_request(dhcp_client);
+
+ if (dhcp_client->t1_timeout > 0)
+ g_source_remove(dhcp_client->t1_timeout);
+
+ dhcp_client->t1_timeout = 0;
+
+ dhcp_client->T1 >>= 1;
+
+ if (dhcp_client->T1 > 60) {
+ dhcp_get_random(&rand);
+ dhcp_client->t1_timeout = g_rttimeout_add_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ dhcp_client->T1 * 1000 + (rand % 2000) - 1000,
+ continue_renew,
+ dhcp_client,
+ NULL);
+ }
+ set_wake(dhcp_client, REQUEST_TIMEOUT);
+
+ return FALSE;
+}
+static gboolean start_renew(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+
+ debug(dhcp_client, "start renew");
+ dhcp_client->state = RENEWING;
+
+ /*calculate total renew period*/
+ dhcp_client->T1 = dhcp_client->T2 - dhcp_client->T1;
+
+ /*send first renew and reschedule for half the remaining time.*/
+ continue_renew(user_data);
+
+ return FALSE;
+}
+
+static void start_bound(GDHCPClient *dhcp_client)
+{
+ debug(dhcp_client, "bound to %s -- renewal in %ld seconds.",
+ dhcp_client->assigned_ip,
+ dhcp_client->lease_seconds);
+
+ dhcp_client->state = BOUND;
+
+ remove_timeouts(dhcp_client);
+
+ /*
+ *TODO: T1 and T2 should be set through options instead of
+ * defaults as they are here.
+ */
+
+ dhcp_client->T1 = dhcp_client->lease_seconds >> 1;
+ dhcp_client->T2 = dhcp_client->lease_seconds * 0.875;
+ dhcp_client->expire = dhcp_client->lease_seconds;
+
+ dhcp_client->t1_timeout = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM,
+ G_PRIORITY_HIGH,
+ dhcp_client->T1,
+ start_renew, dhcp_client,
+ NULL);
+
+ dhcp_client->t2_timeout = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ dhcp_client->T2,
+ start_rebound, dhcp_client,
+ NULL);
+
+ dhcp_client->lease_timeout= g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ dhcp_client->expire,
+ start_expire, dhcp_client,
+ NULL);
+ release_wake(dhcp_client, dhcp_client->T1);
+}
+
+static gboolean restart_dhcp_timeout(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+
+ debug(dhcp_client, "restart DHCP timeout");
+
+ if (dhcp_client->state == REBOOTING) {
+ g_free(dhcp_client->last_address);
+ dhcp_client->last_address = NULL;
+ restart_dhcp(dhcp_client, 0);
+ } else {
+ dhcp_client->ack_retry_times++;
+ restart_dhcp(dhcp_client, dhcp_client->ack_retry_times);
+ }
+ return FALSE;
+}
+
+static char *get_ip(uint32_t ip)
+{
+ struct in_addr addr;
+
+ addr.s_addr = ip;
+
+ return g_strdup(inet_ntoa(addr));
+}
+
+/* get a rough idea of how long an option will be */
+static const uint8_t len_of_option_as_string[] = {
+ [OPTION_IP] = sizeof("255.255.255.255 "),
+ [OPTION_STRING] = 1,
+ [OPTION_U8] = sizeof("255 "),
+ [OPTION_U16] = sizeof("65535 "),
+ [OPTION_U32] = sizeof("4294967295 "),
+};
+
+static int sprint_nip(char *dest, const char *pre, const uint8_t *ip)
+{
+ return sprintf(dest, "%s%u.%u.%u.%u", pre, ip[0], ip[1], ip[2], ip[3]);
+}
+
+/* Create "opt_value1 option_value2 ..." string */
+static char *malloc_option_value_string(uint8_t *option, GDHCPOptionType type)
+{
+ unsigned upper_length;
+ int len, optlen;
+ char *dest, *ret;
+
+ len = option[OPT_LEN - OPT_DATA];
+ type &= OPTION_TYPE_MASK;
+ optlen = dhcp_option_lengths[type];
+ if (optlen == 0)
+ return NULL;
+ upper_length = len_of_option_as_string[type] *
+ ((unsigned)len / (unsigned)optlen);
+ dest = ret = g_malloc(upper_length + 1);
+ if (!ret)
+ return NULL;
+
+ while (len >= optlen) {
+ switch (type) {
+ case OPTION_IP:
+ dest += sprint_nip(dest, "", option);
+ break;
+ case OPTION_U16: {
+ uint16_t val_u16 = get_be16(option);
+ dest += sprintf(dest, "%u", val_u16);
+ break;
+ }
+ case OPTION_U32: {
+ uint32_t val_u32 = get_be32(option);
+ dest += sprintf(dest, "%u", val_u32);
+ break;
+ }
+ case OPTION_STRING:
+ memcpy(dest, option, len);
+ dest[len] = '\0';
+ return ret;
+ default:
+ break;
+ }
+ option += optlen;
+ len -= optlen;
+ if (len <= 0)
+ break;
+ *dest++ = ' ';
+ *dest = '\0';
+ }
+
+ return ret;
+}
+
+static GList *get_option_value_list(char *value, GDHCPOptionType type)
+{
+ char *pos = value;
+ GList *list = NULL;
+
+ if (!pos)
+ return NULL;
+
+ if (type == OPTION_STRING)
+ return g_list_append(list, g_strdup(value));
+
+ while ((pos = strchr(pos, ' '))) {
+ *pos = '\0';
+
+ list = g_list_append(list, g_strdup(value));
+
+ value = ++pos;
+ }
+
+ list = g_list_append(list, g_strdup(value));
+
+ return list;
+}
+
+static inline uint32_t get_uint32(unsigned char *value)
+{
+ return value[0] << 24 | value[1] << 16 |
+ value[2] << 8 | value[3];
+}
+
+static inline uint16_t get_uint16(unsigned char *value)
+{
+ return value[0] << 8 | value[1];
+}
+
+static GList *add_prefix(GDHCPClient *dhcp_client, GList *list,
+ struct in6_addr *addr,
+ unsigned char prefixlen, uint32_t preferred,
+ uint32_t valid)
+{
+ GDHCPIAPrefix *ia_prefix;
+
+ ia_prefix = g_try_new(GDHCPIAPrefix, 1);
+ if (!ia_prefix)
+ return list;
+
+ if (dhcp_client->debug_func) {
+ char addr_str[INET6_ADDRSTRLEN + 1];
+ inet_ntop(AF_INET6, addr, addr_str, INET6_ADDRSTRLEN);
+ debug(dhcp_client, "prefix %s/%d preferred %u valid %u",
+ addr_str, prefixlen, preferred, valid);
+ }
+
+ memcpy(&ia_prefix->prefix, addr, sizeof(struct in6_addr));
+ ia_prefix->prefixlen = prefixlen;
+ ia_prefix->preferred = preferred;
+ ia_prefix->valid = valid;
+ ia_prefix->expire = time(NULL) + valid;
+
+ return g_list_prepend(list, ia_prefix);
+}
+
+static GList *get_addresses(GDHCPClient *dhcp_client,
+ int code, int len,
+ unsigned char *value,
+ uint16_t *status)
+{
+ GList *list = NULL;
+ struct in6_addr addr;
+ uint32_t iaid, T1 = 0, T2 = 0, preferred = 0, valid = 0;
+ uint16_t option_len, option_code, st = 0, max_len;
+ int addr_count = 0, prefix_count = 0, i, pos;
+ unsigned char prefixlen;
+ unsigned int shortest_valid = 0;
+ uint8_t *option;
+ char *str;
+
+ if (!value || len < 4)
+ return NULL;
+
+ iaid = get_uint32(&value[0]);
+ if (dhcp_client->iaid != iaid)
+ return NULL;
+
+ if (code == G_DHCPV6_IA_NA || code == G_DHCPV6_IA_PD) {
+ T1 = get_uint32(&value[4]);
+ T2 = get_uint32(&value[8]);
+
+ if (T1 > T2)
+ /* IA_NA: RFC 3315, 22.4 */
+ /* IA_PD: RFC 3633, ch 9 */
+ return NULL;
+
+ pos = 12;
+ } else
+ pos = 4;
+
+ if (len <= pos)
+ return NULL;
+
+ max_len = len - pos;
+
+ debug(dhcp_client, "header %d sub-option max len %d", pos, max_len);
+
+ /* We have more sub-options in this packet. */
+ do {
+ option = dhcpv6_get_sub_option(&value[pos], max_len,
+ &option_code, &option_len);
+
+ debug(dhcp_client, "pos %d option %p code %d len %d",
+ pos, option, option_code, option_len);
+
+ if (!option)
+ break;
+
+ if (pos >= len)
+ break;
+
+ switch (option_code) {
+ case G_DHCPV6_IAADDR:
+ i = 0;
+ memcpy(&addr, &option[0], sizeof(addr));
+ i += sizeof(addr);
+ preferred = get_uint32(&option[i]);
+ i += 4;
+ valid = get_uint32(&option[i]);
+
+ addr_count++;
+ break;
+
+ case G_DHCPV6_STATUS_CODE:
+ st = get_uint16(&option[0]);
+ debug(dhcp_client, "error code %d", st);
+ if (option_len > 2) {
+ str = g_strndup((gchar *)&option[2],
+ option_len - 2);
+ debug(dhcp_client, "error text: %s", str);
+ g_free(str);
+ }
+
+ *status = st;
+ break;
+
+ case G_DHCPV6_IA_PREFIX:
+ i = 0;
+ preferred = get_uint32(&option[i]);
+ i += 4;
+ valid = get_uint32(&option[i]);
+ i += 4;
+ prefixlen = option[i];
+ i += 1;
+ memcpy(&addr, &option[i], sizeof(addr));
+ i += sizeof(addr);
+ if (preferred < valid) {
+ /* RFC 3633, ch 10 */
+ list = add_prefix(dhcp_client, list, &addr,
+ prefixlen, preferred, valid);
+ if (shortest_valid > valid)
+ shortest_valid = valid;
+ prefix_count++;
+ }
+ break;
+ }
+
+ pos += 2 + 2 + option_len;
+
+ } while (pos < len);
+
+ if (addr_count > 0 && st == 0) {
+ /* We only support one address atm */
+ char addr_str[INET6_ADDRSTRLEN + 1];
+
+ if (preferred > valid)
+ /* RFC 3315, 22.6 */
+ return NULL;
+
+ dhcp_client->T1 = T1;
+ dhcp_client->T2 = T2;
+
+ inet_ntop(AF_INET6, &addr, addr_str, INET6_ADDRSTRLEN);
+ debug(dhcp_client, "address count %d addr %s T1 %u T2 %u",
+ addr_count, addr_str, T1, T2);
+
+ list = g_list_append(list, g_strdup(addr_str));
+
+ if (code == G_DHCPV6_IA_NA)
+ memcpy(&dhcp_client->ia_na, &addr,
+ sizeof(struct in6_addr));
+ else
+ memcpy(&dhcp_client->ia_ta, &addr,
+ sizeof(struct in6_addr));
+
+ if (valid != dhcp_client->expire)
+ dhcp_client->expire = valid;
+ }
+
+ if (prefix_count > 0 && list) {
+ /*
+ * This means we have a list of prefixes to delegate.
+ */
+ list = g_list_reverse(list);
+
+ debug(dhcp_client, "prefix count %d T1 %u T2 %u",
+ prefix_count, T1, T2);
+
+ dhcp_client->T1 = T1;
+ dhcp_client->T2 = T2;
+
+ dhcp_client->expire = shortest_valid;
+ }
+
+ if (status && *status != 0)
+ debug(dhcp_client, "status %d", *status);
+
+ return list;
+}
+
+static GList *get_domains(int maxlen, unsigned char *value)
+
+{
+ GList *list = NULL;
+ int pos = 0;
+ unsigned char *c;
+ char dns_name[NS_MAXDNAME + 1];
+
+ if (!value || maxlen < 3)
+ return NULL;
+
+ while (pos < maxlen) {
+ strncpy(dns_name, (char *)&value[pos], NS_MAXDNAME);
+
+ c = (unsigned char *)dns_name;
+ while (c && *c) {
+ int jump;
+ jump = *c;
+ *c = '.';
+ c += jump + 1;
+ }
+ list = g_list_prepend(list, g_strdup(&dns_name[1]));
+ pos += (char *)c - dns_name + 1;
+ }
+
+ return g_list_reverse(list);
+}
+
+static GList *get_dhcpv6_option_value_list(GDHCPClient *dhcp_client,
+ int code, int len,
+ unsigned char *value,
+ uint16_t *status)
+{
+ GList *list = NULL;
+ char *str;
+ int i;
+
+ if (!value)
+ return NULL;
+
+ switch (code) {
+ case G_DHCPV6_DNS_SERVERS: /* RFC 3646, chapter 3 */
+ case G_DHCPV6_SNTP_SERVERS: /* RFC 4075, chapter 4 */
+ if (len % 16) {
+ debug(dhcp_client,
+ "%s server list length (%d) is invalid",
+ code == G_DHCPV6_DNS_SERVERS ? "DNS" : "SNTP",
+ len);
+ return NULL;
+ }
+ for (i = 0; i < len; i += 16) {
+
+ str = g_try_malloc0(INET6_ADDRSTRLEN+1);
+ if (!str)
+ return list;
+
+ if (!inet_ntop(AF_INET6, &value[i], str,
+ INET6_ADDRSTRLEN))
+ g_free(str);
+ else
+ list = g_list_append(list, str);
+ }
+ break;
+
+ case G_DHCPV6_IA_NA: /* RFC 3315, chapter 22.4 */
+ case G_DHCPV6_IA_TA: /* RFC 3315, chapter 22.5 */
+ case G_DHCPV6_IA_PD: /* RFC 3633, chapter 9 */
+ list = get_addresses(dhcp_client, code, len, value, status);
+ break;
+
+ case G_DHCPV6_DOMAIN_LIST:
+ list = get_domains(len, value);
+ break;
+
+ default:
+ break;
+ }
+
+ return list;
+}
+
+static void get_dhcpv6_request(GDHCPClient *dhcp_client,
+ struct dhcpv6_packet *packet,
+ uint16_t pkt_len, uint16_t *status)
+{
+ GList *list, *value_list;
+ uint8_t *option;
+ uint16_t code;
+ uint16_t option_len;
+
+ for (list = dhcp_client->request_list; list; list = list->next) {
+ code = (uint16_t) GPOINTER_TO_INT(list->data);
+
+ option = dhcpv6_get_option(packet, pkt_len, code, &option_len,
+ NULL);
+ if (!option) {
+ g_hash_table_remove(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code));
+ continue;
+ }
+
+ value_list = get_dhcpv6_option_value_list(dhcp_client, code,
+ option_len, option, status);
+
+ debug(dhcp_client, "code %d %p len %d list %p", code, option,
+ option_len, value_list);
+
+ if (!value_list)
+ g_hash_table_remove(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code));
+ else
+ g_hash_table_insert(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code), value_list);
+ }
+}
+
+static void get_request(GDHCPClient *dhcp_client, struct dhcp_packet *packet)
+{
+ GDHCPOptionType type;
+ GList *list, *value_list;
+ char *option_value;
+ uint8_t *option;
+ uint8_t code;
+
+ for (list = dhcp_client->request_list; list; list = list->next) {
+ code = (uint8_t) GPOINTER_TO_INT(list->data);
+
+ option = dhcp_get_option(packet, code);
+ if (!option) {
+ g_hash_table_remove(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code));
+ continue;
+ }
+
+ type = dhcp_get_code_type(code);
+
+ option_value = malloc_option_value_string(option, type);
+ if (!option_value)
+ g_hash_table_remove(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code));
+
+ value_list = get_option_value_list(option_value, type);
+
+ g_free(option_value);
+
+ if (!value_list)
+ g_hash_table_remove(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code));
+ else
+ g_hash_table_insert(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) code), value_list);
+ }
+}
+
+static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+ struct sockaddr_in dst_addr = { 0 };
+ struct dhcp_packet packet;
+ struct dhcpv6_packet *packet6 = NULL;
+ uint8_t *message_type = NULL, *client_id = NULL, *option,
+ *server_id = NULL;
+ uint16_t option_len = 0, status = 0;
+ uint32_t xid = 0;
+ gpointer pkt;
+ unsigned char buf[MAX_DHCPV6_PKT_SIZE];
+ uint16_t pkt_len = 0;
+ int count;
+ int re;
+ const char *p = NULL;
+ struct in_addr slog;
+ char serverbuf[INET_ADDRSTRLEN], requestbuf[INET_ADDRSTRLEN], gatebuf[INET_ADDRSTRLEN];
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ dhcp_client->listener_watch = 0;
+ return FALSE;
+ }
+
+ if (dhcp_client->listen_mode == L_NONE)
+ return FALSE;
+
+ pkt = &packet;
+
+ dhcp_client->status_code = 0;
+
+ if (dhcp_client->listen_mode == L2) {
+ re = dhcp_recv_l2_packet(&packet,
+ dhcp_client->listener_sockfd,
+ &dst_addr);
+ xid = packet.xid;
+ } else if (dhcp_client->listen_mode == L3) {
+ if (dhcp_client->type == G_DHCP_IPV6) {
+ re = dhcpv6_recv_l3_packet(&packet6, buf, sizeof(buf),
+ dhcp_client->listener_sockfd);
+ pkt_len = re;
+ pkt = packet6;
+ xid = packet6->transaction_id[0] << 16 |
+ packet6->transaction_id[1] << 8 |
+ packet6->transaction_id[2];
+
+ } else {
+ re = dhcp_recv_l3_packet(&packet,
+ dhcp_client->listener_sockfd);
+ xid = packet.xid;
+ }
+ } else if (dhcp_client->listen_mode == L_ARP) {
+ ipv4ll_recv_arp_packet(dhcp_client);
+ return TRUE;
+ } else
+ re = -EIO;
+
+ if (re < 0)
+ return TRUE;
+
+ if (!check_package_owner(dhcp_client, pkt))
+ return TRUE;
+
+ if (dhcp_client->type == G_DHCP_IPV6) {
+ if (!packet6)
+ return TRUE;
+
+ count = 0;
+ client_id = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_CLIENTID, &option_len, &count);
+
+ if (!client_id || count == 0 || option_len == 0 ||
+ memcmp(dhcp_client->duid, client_id,
+ dhcp_client->duid_len) != 0) {
+ debug(dhcp_client,
+ "client duid error, discarding msg %p/%d/%d",
+ client_id, option_len, count);
+ return TRUE;
+ }
+
+ option = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_STATUS_CODE, &option_len, NULL);
+ if (option != 0 && option_len > 0) {
+ status = option[0]<<8 | option[1];
+ if (status != 0) {
+ debug(dhcp_client, "error code %d", status);
+ if (option_len > 2) {
+ gchar *txt = g_strndup(
+ (gchar *)&option[2],
+ option_len - 2);
+ debug(dhcp_client, "error text: %s",
+ txt);
+ g_free(txt);
+ }
+ }
+ dhcp_client->status_code = status;
+ }
+ } else {
+ message_type = dhcp_get_option(&packet, DHCP_MESSAGE_TYPE);
+ if (!message_type)
+ return TRUE;
+ }
+
+ if (!message_type && !client_id)
+ /* No message type / client id option, ignore package */
+ return TRUE;
+
+ debug(dhcp_client, "received DHCP packet xid 0x%04x "
+ "(current state %d)", ntohl(xid), dhcp_client->state);
+
+ if (message_type) {
+ p = get_message_type(*message_type);
+
+ debug(dhcp_client, "received DHCP%s (%#02x) packet "
+ "(current state %d)",
+ p,
+ *message_type,
+ dhcp_client->state);
+ } else {
+ debug(dhcp_client, "received DHCPv6 packet "
+ "(current state %d)",
+ dhcp_client->state);
+ }
+
+ switch (dhcp_client->state) {
+ case INIT_SELECTING:
+ if (message_type == NULL ) {
+ debug(dhcp_client, "INIT_SELECTING but message_type is NULL" );
+ return TRUE;
+ }
+ if (*message_type != DHCPOFFER)
+ return TRUE;
+
+ remove_timeouts(dhcp_client);
+ dhcp_client->timeout = 0;
+ dhcp_client->retry_times = 0;
+
+ option = dhcp_get_option(&packet, DHCP_SERVER_ID);
+ dhcp_client->server_ip = get_be32(option);
+ dhcp_client->requested_ip = ntohl(packet.yiaddr);
+
+ dhcp_client->state = REQUESTING;
+
+ if (dst_addr.sin_addr.s_addr == INADDR_BROADCAST)
+ dhcp_client->request_bcast = true;
+ else
+ dhcp_client->request_bcast = false;
+
+ debug(dhcp_client, "init ip %s -> %sadding broadcast flag",
+ inet_ntoa(dst_addr.sin_addr),
+ dhcp_client->request_bcast ? "" : "not ");
+
+ slog.s_addr = htonl(dhcp_client->server_ip);
+ debug(dhcp_client, "%s of %s from %s (%s)",
+ p,
+ inet_ntop(AF_INET, &(packet.yiaddr),
+ requestbuf, sizeof(requestbuf)),
+ inet_ntop(AF_INET, &slog,
+ serverbuf, sizeof(serverbuf)),
+ inet_ntop(AF_INET, &(packet.gateway_nip),
+ gatebuf, sizeof(gatebuf)));
+
+ start_request(dhcp_client);
+
+ return TRUE;
+ case REBOOTING:
+ if (dst_addr.sin_addr.s_addr == INADDR_BROADCAST)
+ dhcp_client->request_bcast = true;
+ else
+ dhcp_client->request_bcast = false;
+
+ debug(dhcp_client, "ip %s -> %sadding broadcast flag",
+ inet_ntoa(dst_addr.sin_addr),
+ dhcp_client->request_bcast ? "" : "not ");
+ /* fall through */
+ case REQUESTING:
+ case RENEWING:
+ case REBINDING:
+ if (message_type == NULL ) {
+ debug(dhcp_client, "REQUESTING/RENEWING/REBINDING/REBOOTING but message_type is NULL" );
+ return TRUE;
+ }
+ if (*message_type == DHCPACK) {
+ dhcp_client->retry_times = 0;
+
+ remove_timeouts(dhcp_client);
+
+ dhcp_client->lease_seconds = get_lease(dhcp_client, &packet);
+
+ get_request(dhcp_client, &packet);
+
+ switch_listening_mode(dhcp_client, L_NONE);
+
+ g_free(dhcp_client->assigned_ip);
+ dhcp_client->assigned_ip = get_ip(packet.yiaddr);
+
+ if (dhcp_client->state == REBOOTING) {
+ option = dhcp_get_option(&packet,
+ DHCP_SERVER_ID);
+ dhcp_client->server_ip = get_be32(option);
+ }
+
+ slog.s_addr = htonl(dhcp_client->server_ip);
+ debug(dhcp_client, "%s of %s from %s (%s)",
+ p,
+ inet_ntop(AF_INET, &(packet.yiaddr),
+ requestbuf, sizeof(requestbuf)),
+ inet_ntop(AF_INET, &slog,
+ serverbuf, sizeof(serverbuf)),
+ inet_ntop(AF_INET, &(packet.gateway_nip),
+ gatebuf, sizeof(gatebuf)));
+
+ /* Address should be set up here */
+ if (dhcp_client->lease_available_cb)
+ dhcp_client->lease_available_cb(dhcp_client,
+ dhcp_client->lease_available_data);
+
+ start_bound(dhcp_client);
+ } else if (*message_type == DHCPNAK) {
+ dhcp_client->retry_times = 0;
+
+ remove_timeouts(dhcp_client);
+
+ dhcp_client->timeout = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM,
+ G_PRIORITY_HIGH, 3,
+ restart_dhcp_timeout,
+ dhcp_client,
+ NULL);
+ }
+
+ break;
+ case SOLICITATION:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return TRUE;
+
+ if (packet6->message != DHCPV6_REPLY &&
+ packet6->message != DHCPV6_ADVERTISE)
+ return TRUE;
+
+ count = 0;
+ server_id = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_SERVERID, &option_len, &count);
+ if (!server_id || count != 1 || option_len == 0) {
+ /* RFC 3315, 15.10 */
+ debug(dhcp_client,
+ "server duid error, discarding msg %p/%d/%d",
+ server_id, option_len, count);
+ return TRUE;
+ }
+ dhcp_client->server_duid = g_try_malloc(option_len);
+ if (!dhcp_client->server_duid)
+ return TRUE;
+ memcpy(dhcp_client->server_duid, server_id, option_len);
+ dhcp_client->server_duid_len = option_len;
+
+ if (packet6->message == DHCPV6_REPLY) {
+ uint8_t *rapid_commit;
+ count = 0;
+ option_len = 0;
+ rapid_commit = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_RAPID_COMMIT,
+ &option_len, &count);
+ if (!rapid_commit || option_len != 0 ||
+ count != 1)
+ /* RFC 3315, 17.1.4 */
+ return TRUE;
+ }
+
+ switch_listening_mode(dhcp_client, L_NONE);
+
+ if (dhcp_client->status_code == 0)
+ get_dhcpv6_request(dhcp_client, packet6, pkt_len,
+ &dhcp_client->status_code);
+
+ if (packet6->message == DHCPV6_ADVERTISE) {
+ if (dhcp_client->advertise_cb)
+ dhcp_client->advertise_cb(dhcp_client,
+ dhcp_client->advertise_data);
+ return TRUE;
+ }
+
+ if (dhcp_client->solicitation_cb) {
+ /*
+ * The dhcp_client might not be valid after the
+ * callback call so just return immediately.
+ */
+ dhcp_client->solicitation_cb(dhcp_client,
+ dhcp_client->solicitation_data);
+ return TRUE;
+ }
+ break;
+ case REBIND:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return TRUE;
+
+ server_id = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_SERVERID, &option_len, &count);
+ if (!dhcp_client->server_duid && server_id &&
+ count == 1) {
+ /*
+ * If we do not have server duid yet, then get it now.
+ * Prefix delegation renew support needs it.
+ */
+ dhcp_client->server_duid = g_try_malloc(option_len);
+ if (!dhcp_client->server_duid)
+ return TRUE;
+ memcpy(dhcp_client->server_duid, server_id, option_len);
+ dhcp_client->server_duid_len = option_len;
+ }
+ /* fall through */
+ case INFORMATION_REQ:
+ case REQUEST:
+ case RENEW:
+ case RELEASE:
+ case CONFIRM:
+ case DECLINE:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return TRUE;
+
+ if (packet6->message != DHCPV6_REPLY)
+ return TRUE;
+
+ count = 0;
+ option_len = 0;
+ server_id = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_SERVERID, &option_len, &count);
+ if (!server_id || count != 1 || option_len == 0 ||
+ (dhcp_client->server_duid_len > 0 &&
+ memcmp(dhcp_client->server_duid, server_id,
+ dhcp_client->server_duid_len) != 0)) {
+ /* RFC 3315, 15.10 */
+ debug(dhcp_client,
+ "server duid error, discarding msg %p/%d/%d",
+ server_id, option_len, count);
+ return TRUE;
+ }
+
+ switch_listening_mode(dhcp_client, L_NONE);
+
+ get_dhcpv6_request(dhcp_client, packet6, pkt_len,
+ &dhcp_client->status_code);
+
+ if (dhcp_client->information_req_cb) {
+ /*
+ * The dhcp_client might not be valid after the
+ * callback call so just return immediately.
+ */
+ dhcp_client->information_req_cb(dhcp_client,
+ dhcp_client->information_req_data);
+ return TRUE;
+ }
+ if (dhcp_client->request_cb) {
+ dhcp_client->request_cb(dhcp_client,
+ dhcp_client->request_data);
+ return TRUE;
+ }
+ if (dhcp_client->renew_cb) {
+ dhcp_client->renew_cb(dhcp_client,
+ dhcp_client->renew_data);
+ return TRUE;
+ }
+ if (dhcp_client->rebind_cb) {
+ dhcp_client->rebind_cb(dhcp_client,
+ dhcp_client->rebind_data);
+ return TRUE;
+ }
+ if (dhcp_client->release_cb) {
+ dhcp_client->release_cb(dhcp_client,
+ dhcp_client->release_data);
+ return TRUE;
+ }
+ if (dhcp_client->decline_cb) {
+ dhcp_client->decline_cb(dhcp_client,
+ dhcp_client->decline_data);
+ return TRUE;
+ }
+ if (dhcp_client->confirm_cb) {
+ count = 0;
+ server_id = dhcpv6_get_option(packet6, pkt_len,
+ G_DHCPV6_SERVERID, &option_len,
+ &count);
+ if (!server_id || count != 1 ||
+ option_len == 0) {
+ /* RFC 3315, 15.10 */
+ debug(dhcp_client,
+ "confirm server duid error, "
+ "discarding msg %p/%d/%d",
+ server_id, option_len, count);
+ return TRUE;
+ }
+ dhcp_client->server_duid = g_try_malloc(option_len);
+ if (!dhcp_client->server_duid)
+ return TRUE;
+ memcpy(dhcp_client->server_duid, server_id, option_len);
+ dhcp_client->server_duid_len = option_len;
+
+ dhcp_client->confirm_cb(dhcp_client,
+ dhcp_client->confirm_data);
+ return TRUE;
+ }
+ break;
+ default:
+ break;
+ }
+
+ if (message_type) {
+ debug(dhcp_client, "processed DHCP%s (%#02x) packet (new state %d)",
+ p,
+ *message_type,
+ dhcp_client->state);
+ } else {
+ debug(dhcp_client, "processed DHCPv6 packet (new state %d)",
+ dhcp_client->state);
+ }
+ return TRUE;
+}
+
+static gboolean discover_timeout(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+
+ dhcp_client->retry_times++;
+
+ /*
+ * We do not send the REQUESTED IP option if we are retrying because
+ * if the server is non-authoritative it will ignore the request if the
+ * option is present.
+ */
+ g_dhcp_client_start(dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean reboot_timeout(gpointer user_data)
+{
+ GDHCPClient *dhcp_client = user_data;
+ dhcp_client->retry_times = 0;
+ dhcp_client->requested_ip = 0;
+ dhcp_client->state = INIT_SELECTING;
+ /*
+ * We do not send the REQUESTED IP option because the server didn't
+ * respond when we send DHCPREQUEST with the REQUESTED IP option in
+ * init-reboot state
+ */
+ g_dhcp_client_start(dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean ipv4ll_defend_timeout(gpointer dhcp_data)
+{
+ GDHCPClient *dhcp_client = dhcp_data;
+
+ debug(dhcp_client, "back to MONITOR mode");
+
+ dhcp_client->conflicts = 0;
+ dhcp_client->state = IPV4LL_MONITOR;
+
+ return FALSE;
+}
+
+static gboolean ipv4ll_announce_timeout(gpointer dhcp_data)
+{
+ GDHCPClient *dhcp_client = dhcp_data;
+ uint32_t ip;
+
+ debug(dhcp_client, "request timeout (retries %d)",
+ dhcp_client->retry_times);
+
+ if (dhcp_client->retry_times != ANNOUNCE_NUM) {
+ dhcp_client->retry_times++;
+ send_announce_packet(dhcp_client);
+ return FALSE;
+ }
+
+ ip = htonl(dhcp_client->requested_ip);
+ debug(dhcp_client, "switching to monitor mode");
+ dhcp_client->state = IPV4LL_MONITOR;
+ dhcp_client->assigned_ip = get_ip(ip);
+
+ if (dhcp_client->ipv4ll_available_cb)
+ dhcp_client->ipv4ll_available_cb(dhcp_client,
+ dhcp_client->ipv4ll_available_data);
+ dhcp_client->conflicts = 0;
+
+ return FALSE;
+}
+
+static gboolean ipv4ll_probe_timeout(gpointer dhcp_data)
+{
+
+ GDHCPClient *dhcp_client = dhcp_data;
+
+ debug(dhcp_client, "IPV4LL probe timeout (retries %d)",
+ dhcp_client->retry_times);
+
+ if (dhcp_client->retry_times == PROBE_NUM) {
+ dhcp_client->state = IPV4LL_ANNOUNCE;
+ dhcp_client->retry_times = 0;
+
+ dhcp_client->retry_times++;
+ send_announce_packet(dhcp_client);
+ return FALSE;
+ }
+ dhcp_client->retry_times++;
+ send_probe_packet(dhcp_client);
+
+ return FALSE;
+}
+
+int g_dhcp_client_start(GDHCPClient *dhcp_client, const char *last_address)
+{
+ int re;
+ uint32_t addr;
+ uint64_t rand;
+
+ if (dhcp_client->type == G_DHCP_IPV6) {
+ if (dhcp_client->information_req_cb) {
+ dhcp_client->state = INFORMATION_REQ;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_information_req(dhcp_client);
+
+ } else if (dhcp_client->solicitation_cb) {
+ dhcp_client->state = SOLICITATION;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_solicitation(dhcp_client);
+
+ } else if (dhcp_client->request_cb) {
+ dhcp_client->state = REQUEST;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_dhcpv6_request(dhcp_client);
+
+ } else if (dhcp_client->confirm_cb) {
+ dhcp_client->state = CONFIRM;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_dhcpv6_confirm(dhcp_client);
+
+ } else if (dhcp_client->renew_cb) {
+ dhcp_client->state = RENEW;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_dhcpv6_renew(dhcp_client);
+
+ } else if (dhcp_client->rebind_cb) {
+ dhcp_client->state = REBIND;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_dhcpv6_rebind(dhcp_client);
+
+ } else if (dhcp_client->release_cb) {
+ dhcp_client->state = RENEW;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_dhcpv6_release(dhcp_client);
+ } else if (dhcp_client->decline_cb) {
+ dhcp_client->state = DECLINE;
+ re = switch_listening_mode(dhcp_client, L3);
+ if (re != 0) {
+ switch_listening_mode(dhcp_client, L_NONE);
+ dhcp_client->state = 0;
+ return re;
+ }
+ send_dhcpv6_decline(dhcp_client);
+ }
+
+ return 0;
+ }
+
+ if (dhcp_client->type == G_DHCP_IPV4LL) {
+ dhcp_client->state = INIT_SELECTING;
+ ipv4ll_start(dhcp_client);
+ return 0;
+ }
+
+ if (dhcp_client->retry_times == DISCOVER_RETRIES) {
+ if (dhcp_client->no_lease_cb)
+ dhcp_client->no_lease_cb(dhcp_client,
+ dhcp_client->no_lease_data);
+ dhcp_client->retry_times = 0;
+ return 0;
+ }
+
+ if (dhcp_client->retry_times == 0) {
+ g_free(dhcp_client->assigned_ip);
+ dhcp_client->assigned_ip = NULL;
+
+ dhcp_client->state = INIT_SELECTING;
+ re = switch_listening_mode(dhcp_client, L2);
+ if (re != 0)
+ return re;
+
+ dhcp_get_random(&rand);
+ dhcp_client->xid = rand;
+ dhcp_client->start = time(NULL);
+ }
+
+ if (!last_address) {
+ addr = 0;
+ } else {
+ addr = ntohl(inet_addr(last_address));
+ if (addr == 0xFFFFFFFF) {
+ addr = 0;
+ } else {
+ g_free(dhcp_client->last_address);
+ dhcp_client->last_address = g_strdup(last_address);
+ }
+ }
+
+ if ((addr != 0) && (dhcp_client->type != G_DHCP_IPV4LL)) {
+ debug(dhcp_client, "DHCP client start with state init_reboot");
+ dhcp_client->requested_ip = addr;
+ dhcp_client->state = REBOOTING;
+ send_request(dhcp_client);
+
+ dhcp_client->timeout = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM,
+ G_PRIORITY_HIGH,
+ REQUEST_TIMEOUT,
+ reboot_timeout,
+ dhcp_client,
+ NULL);
+ return 0;
+ }
+ send_discover(dhcp_client, addr);
+
+ dhcp_client->timeout = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME_ALARM, G_PRIORITY_HIGH,
+ DISCOVER_TIMEOUT,
+ discover_timeout,
+ dhcp_client,
+ NULL);
+ return 0;
+}
+
+void g_dhcp_client_stop(GDHCPClient *dhcp_client)
+{
+ switch_listening_mode(dhcp_client, L_NONE);
+
+ if (dhcp_client->state == BOUND ||
+ dhcp_client->state == RENEWING ||
+ dhcp_client->state == REBINDING)
+ send_release(dhcp_client, dhcp_client->server_ip,
+ dhcp_client->requested_ip);
+
+ remove_timeouts(dhcp_client);
+
+ if (dhcp_client->listener_watch > 0) {
+ g_source_remove(dhcp_client->listener_watch);
+ dhcp_client->listener_watch = 0;
+ }
+
+ dhcp_client->retry_times = 0;
+ dhcp_client->ack_retry_times = 0;
+
+ dhcp_client->requested_ip = 0;
+ dhcp_client->state = RELEASED;
+ dhcp_client->lease_seconds = 0;
+ dhcp_client->request_bcast = false;
+}
+
+GList *g_dhcp_client_get_option(GDHCPClient *dhcp_client,
+ unsigned char option_code)
+{
+ return g_hash_table_lookup(dhcp_client->code_value_hash,
+ GINT_TO_POINTER((int) option_code));
+}
+
+void g_dhcp_client_register_event(GDHCPClient *dhcp_client,
+ GDHCPClientEvent event,
+ GDHCPClientEventFunc func,
+ gpointer data)
+{
+ switch (event) {
+ case G_DHCP_CLIENT_EVENT_LEASE_AVAILABLE:
+ dhcp_client->lease_available_cb = func;
+ dhcp_client->lease_available_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_IPV4LL_AVAILABLE:
+ if (dhcp_client->type == G_DHCP_IPV6)
+ return;
+ dhcp_client->ipv4ll_available_cb = func;
+ dhcp_client->ipv4ll_available_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_NO_LEASE:
+ dhcp_client->no_lease_cb = func;
+ dhcp_client->no_lease_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_LEASE_LOST:
+ dhcp_client->lease_lost_cb = func;
+ dhcp_client->lease_lost_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_IPV4LL_LOST:
+ if (dhcp_client->type == G_DHCP_IPV6)
+ return;
+ dhcp_client->ipv4ll_lost_cb = func;
+ dhcp_client->ipv4ll_lost_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_ADDRESS_CONFLICT:
+ dhcp_client->address_conflict_cb = func;
+ dhcp_client->address_conflict_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_INFORMATION_REQ:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->information_req_cb = func;
+ dhcp_client->information_req_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_SOLICITATION:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->solicitation_cb = func;
+ dhcp_client->solicitation_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_ADVERTISE:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->advertise_cb = func;
+ dhcp_client->advertise_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_REQUEST:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->request_cb = func;
+ dhcp_client->request_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_RENEW:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->renew_cb = func;
+ dhcp_client->renew_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_REBIND:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->rebind_cb = func;
+ dhcp_client->rebind_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_RELEASE:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->release_cb = func;
+ dhcp_client->release_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_CONFIRM:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->confirm_cb = func;
+ dhcp_client->confirm_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_DECLINE:
+ if (dhcp_client->type != G_DHCP_IPV6)
+ return;
+ dhcp_client->decline_cb = func;
+ dhcp_client->decline_data = data;
+ return;
+ case G_DHCP_CLIENT_EVENT_WAKE_EVENT:
+ dhcp_client->wake_event_cb = func;
+ dhcp_client->wake_event_data= data;
+ return;
+ }
+}
+
+int g_dhcp_client_get_index(GDHCPClient *dhcp_client)
+{
+ return dhcp_client->ifindex;
+}
+
+char *g_dhcp_client_get_server_address(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client)
+ return NULL;
+
+ return get_ip(dhcp_client->server_ip);
+}
+
+char *g_dhcp_client_get_address(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client)
+ return NULL;
+
+ return g_strdup(dhcp_client->assigned_ip);
+}
+
+char *g_dhcp_client_get_netmask(GDHCPClient *dhcp_client)
+{
+ GList *option = NULL;
+
+ if (dhcp_client->type == G_DHCP_IPV6)
+ return NULL;
+
+ switch (dhcp_client->state) {
+ case IPV4LL_DEFEND:
+ case IPV4LL_MONITOR:
+ return g_strdup("255.255.0.0");
+ case BOUND:
+ case RENEWING:
+ case REBINDING:
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
+ if (option)
+ return g_strdup(option->data);
+ case INIT_SELECTING:
+ case REBOOTING:
+ case REQUESTING:
+ case RELEASED:
+ case IPV4LL_PROBE:
+ case IPV4LL_ANNOUNCE:
+ case INFORMATION_REQ:
+ case SOLICITATION:
+ case REQUEST:
+ case CONFIRM:
+ case RENEW:
+ case REBIND:
+ case RELEASE:
+ case DECLINE:
+ break;
+ }
+ return NULL;
+}
+
+GDHCPClientError g_dhcp_client_set_request(GDHCPClient *dhcp_client,
+ unsigned int option_code)
+{
+ if (!g_list_find(dhcp_client->request_list,
+ GINT_TO_POINTER((int)option_code)))
+ dhcp_client->request_list = g_list_prepend(
+ dhcp_client->request_list,
+ (GINT_TO_POINTER((int) option_code)));
+
+ return G_DHCP_CLIENT_ERROR_NONE;
+}
+
+void g_dhcp_client_clear_requests(GDHCPClient *dhcp_client)
+{
+ g_list_free(dhcp_client->request_list);
+ dhcp_client->request_list = NULL;
+}
+
+void g_dhcp_client_clear_values(GDHCPClient *dhcp_client)
+{
+ g_hash_table_remove_all(dhcp_client->send_value_hash);
+}
+
+static uint8_t *alloc_dhcp_option(int code, const uint8_t *data, unsigned size)
+{
+ uint8_t *storage;
+
+ storage = g_try_malloc(size + OPT_DATA);
+ if (!storage)
+ return NULL;
+
+ storage[OPT_CODE] = code;
+ storage[OPT_LEN] = size;
+ memcpy(&storage[OPT_DATA], data, size);
+
+ return storage;
+}
+
+static uint8_t *alloc_dhcp_data_option(int code, const uint8_t *data,
+ unsigned size)
+{
+ return alloc_dhcp_option(code, data, MIN(size, 255));
+}
+
+static uint8_t *alloc_dhcp_string_option(int code, const char *str)
+{
+ return alloc_dhcp_data_option(code, (const uint8_t *)str, strlen(str));
+}
+
+GDHCPClientError g_dhcp_client_set_id(GDHCPClient *dhcp_client)
+{
+ const unsigned maclen = 6;
+ const unsigned idlen = maclen + 1;
+ const uint8_t option_code = G_DHCP_CLIENT_ID;
+ uint8_t idbuf[idlen];
+ uint8_t *data_option;
+
+ idbuf[0] = ARPHRD_ETHER;
+
+ memcpy(&idbuf[1], dhcp_client->mac_address, maclen);
+
+ data_option = alloc_dhcp_data_option(option_code, idbuf, idlen);
+ if (!data_option)
+ return G_DHCP_CLIENT_ERROR_NOMEM;
+
+ g_hash_table_insert(dhcp_client->send_value_hash,
+ GINT_TO_POINTER((int) option_code), data_option);
+
+ return G_DHCP_CLIENT_ERROR_NONE;
+}
+
+/* Now only support send hostname */
+GDHCPClientError g_dhcp_client_set_send(GDHCPClient *dhcp_client,
+ unsigned char option_code, const char *option_value)
+{
+ uint8_t *binary_option;
+
+ if (option_code == G_DHCP_HOST_NAME && option_value) {
+ binary_option = alloc_dhcp_string_option(option_code,
+ option_value);
+ if (!binary_option)
+ return G_DHCP_CLIENT_ERROR_NOMEM;
+
+ g_hash_table_insert(dhcp_client->send_value_hash,
+ GINT_TO_POINTER((int) option_code), binary_option);
+ }
+
+ return G_DHCP_CLIENT_ERROR_NONE;
+}
+
+static uint8_t *alloc_dhcpv6_option(uint16_t code, uint8_t *option,
+ uint16_t len)
+{
+ uint8_t *storage;
+
+ storage = g_malloc(2 + 2 + len);
+ if (!storage)
+ return NULL;
+
+ storage[0] = code >> 8;
+ storage[1] = code & 0xff;
+ storage[2] = len >> 8;
+ storage[3] = len & 0xff;
+ memcpy(storage + 2 + 2, option, len);
+
+ return storage;
+}
+
+gboolean g_dhcpv6_client_clear_send(GDHCPClient *dhcp_client, uint16_t code)
+{
+ return g_hash_table_remove(dhcp_client->send_value_hash,
+ GINT_TO_POINTER((int)code));
+}
+
+void g_dhcpv6_client_set_send(GDHCPClient *dhcp_client,
+ uint16_t option_code,
+ uint8_t *option_value,
+ uint16_t option_len)
+{
+ if (option_value) {
+ uint8_t *binary_option;
+
+ debug(dhcp_client, "setting option %d to %p len %d",
+ option_code, option_value, option_len);
+
+ binary_option = alloc_dhcpv6_option(option_code, option_value,
+ option_len);
+ if (binary_option)
+ g_hash_table_insert(dhcp_client->send_value_hash,
+ GINT_TO_POINTER((int) option_code),
+ binary_option);
+ }
+}
+
+void g_dhcpv6_client_reset_request(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return;
+
+ dhcp_client->last_request = time(NULL);
+}
+
+uint16_t g_dhcpv6_client_get_status(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client || dhcp_client->type != G_DHCP_IPV6)
+ return 0;
+
+ return dhcp_client->status_code;
+}
+
+GDHCPClient *g_dhcp_client_ref(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client)
+ return NULL;
+
+ __sync_fetch_and_add(&dhcp_client->ref_count, 1);
+
+ return dhcp_client;
+}
+
+void g_dhcp_client_unref(GDHCPClient *dhcp_client)
+{
+ if (!dhcp_client)
+ return;
+
+ if (__sync_fetch_and_sub(&dhcp_client->ref_count, 1) != 1)
+ return;
+
+ g_dhcp_client_stop(dhcp_client);
+
+ g_free(dhcp_client->interface);
+ g_free(dhcp_client->assigned_ip);
+ g_free(dhcp_client->last_address);
+ g_free(dhcp_client->duid);
+ g_free(dhcp_client->server_duid);
+
+ g_list_free(dhcp_client->request_list);
+ g_list_free(dhcp_client->require_list);
+
+ g_hash_table_destroy(dhcp_client->code_value_hash);
+ g_hash_table_destroy(dhcp_client->send_value_hash);
+
+ g_free(dhcp_client);
+}
+
+void g_dhcp_client_set_debug(GDHCPClient *dhcp_client,
+ GDHCPDebugFunc func, gpointer user_data)
+{
+ if (!dhcp_client)
+ return;
+
+ dhcp_client->debug_func = func;
+ dhcp_client->debug_data = user_data;
+}
+
+static GDHCPIAPrefix *copy_prefix(gpointer data)
+{
+ GDHCPIAPrefix *copy, *prefix = data;
+
+ copy = g_try_new(GDHCPIAPrefix, 1);
+ if (!copy)
+ return NULL;
+
+ memcpy(copy, prefix, sizeof(GDHCPIAPrefix));
+
+ return copy;
+}
+
+GSList *g_dhcpv6_copy_prefixes(GSList *prefixes)
+{
+ GSList *copy = NULL;
+ GSList *list;
+
+ for (list = prefixes; list; list = list->next)
+ copy = g_slist_prepend(copy, copy_prefix(list->data));
+
+ return copy;
+}
diff --git a/gdhcp/common.c b/gdhcp/common.c
new file mode 100644
index 0000000..8859a82
--- /dev/null
+++ b/gdhcp/common.c
@@ -0,0 +1,792 @@
+/*
+ * DHCP library with GLib integration
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/ioctl.h>
+#include <stdint.h>
+#include <string.h>
+#include <endian.h>
+#include <net/if_arp.h>
+#include <linux/if.h>
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#include <arpa/inet.h>
+#include <fcntl.h>
+
+#include "gdhcp.h"
+#include "common.h"
+
+static const DHCPOption client_options[] = {
+ { OPTION_IP, 0x01 }, /* subnet-mask */
+ { OPTION_IP | OPTION_LIST, 0x03 }, /* routers */
+ { OPTION_IP | OPTION_LIST, 0x06 }, /* domain-name-servers */
+ { OPTION_STRING, 0x0c }, /* hostname */
+ { OPTION_STRING, 0x0f }, /* domain-name */
+ { OPTION_IP | OPTION_LIST, 0x2a }, /* ntp-servers */
+ { OPTION_U32, 0x33 }, /* dhcp-lease-time */
+ /* Options below will not be exposed to user */
+ { OPTION_IP, 0x32 }, /* requested-ip */
+ { OPTION_U8, 0x35 }, /* message-type */
+ { OPTION_U32, 0x36 }, /* server-id */
+ { OPTION_U16, 0x39 }, /* max-size */
+ { OPTION_STRING, 0x3c }, /* vendor */
+ { OPTION_STRING, 0x3d }, /* client-id */
+ { OPTION_STRING, 0xfc }, /* UNOFFICIAL proxy-pac */
+ { OPTION_UNKNOWN, 0x00 },
+};
+
+#define URANDOM "/dev/urandom"
+static int random_fd = -1;
+
+int dhcp_get_random(uint64_t *val)
+{
+ int r;
+
+ if (random_fd < 0) {
+ random_fd = open(URANDOM, O_RDONLY);
+ if (random_fd < 0) {
+ r = -errno;
+ *val = random();
+
+ return r;
+ }
+ }
+
+ if (read(random_fd, val, sizeof(uint64_t)) < 0) {
+ r = -errno;
+ *val = random();
+
+ return r;
+ }
+
+ return 0;
+}
+
+void dhcp_cleanup_random(void)
+{
+ if (random_fd < 0)
+ return;
+
+ close(random_fd);
+ random_fd = -1;
+}
+
+GDHCPOptionType dhcp_get_code_type(uint8_t code)
+{
+ int i;
+
+ for (i = 0; client_options[i].code; i++) {
+ if (client_options[i].code == code)
+ return client_options[i].type;
+ }
+
+ return OPTION_UNKNOWN;
+}
+
+uint8_t *dhcp_get_option(struct dhcp_packet *packet, int code)
+{
+ int len, rem;
+ uint8_t *optionptr;
+ uint8_t overload = 0;
+
+ /* option bytes: [code][len][data1][data2]..[dataLEN] */
+ optionptr = packet->options;
+ rem = sizeof(packet->options);
+
+ while (1) {
+ if (rem <= 0)
+ /* Bad packet, malformed option field */
+ return NULL;
+
+ if (optionptr[OPT_CODE] == DHCP_PADDING) {
+ rem--;
+ optionptr++;
+
+ continue;
+ }
+
+ if (optionptr[OPT_CODE] == DHCP_END) {
+ if (overload & FILE_FIELD) {
+ overload &= ~FILE_FIELD;
+
+ optionptr = packet->file;
+ rem = sizeof(packet->file);
+
+ continue;
+ } else if (overload & SNAME_FIELD) {
+ overload &= ~SNAME_FIELD;
+
+ optionptr = packet->sname;
+ rem = sizeof(packet->sname);
+
+ continue;
+ }
+
+ break;
+ }
+
+ len = 2 + optionptr[OPT_LEN];
+
+ rem -= len;
+ if (rem < 0)
+ continue; /* complain and return NULL */
+
+ if (optionptr[OPT_CODE] == code)
+ return optionptr + OPT_DATA;
+
+ if (optionptr[OPT_CODE] == DHCP_OPTION_OVERLOAD)
+ overload |= optionptr[OPT_DATA];
+
+ optionptr += len;
+ }
+
+ return NULL;
+}
+
+int dhcp_end_option(uint8_t *optionptr)
+{
+ int i = 0;
+
+ while (optionptr[i] != DHCP_END) {
+ if (optionptr[i] != DHCP_PADDING)
+ i += optionptr[i + OPT_LEN] + OPT_DATA - 1;
+
+ i++;
+ }
+
+ return i;
+}
+
+uint8_t *dhcpv6_get_option(struct dhcpv6_packet *packet, uint16_t pkt_len,
+ int code, uint16_t *option_len, int *option_count)
+{
+ int rem, count = 0;
+ uint8_t *optionptr, *found = NULL;
+ uint16_t opt_code, opt_len, len;
+
+ optionptr = packet->options;
+ rem = pkt_len - 1 - 3;
+
+ if (rem <= 0)
+ goto bad_packet;
+
+ while (1) {
+ opt_code = optionptr[0] << 8 | optionptr[1];
+ opt_len = len = optionptr[2] << 8 | optionptr[3];
+ len += 2 + 2; /* skip code and len */
+
+ if (len < 4)
+ goto bad_packet;
+
+ rem -= len;
+ if (rem < 0)
+ break;
+
+ if (opt_code == code) {
+ if (option_len)
+ *option_len = opt_len;
+ found = optionptr + 2 + 2;
+ count++;
+ }
+
+ if (rem == 0)
+ break;
+
+ optionptr += len;
+ }
+
+ if (option_count)
+ *option_count = count;
+
+ return found;
+
+bad_packet:
+ if (option_len)
+ *option_len = 0;
+ if (option_count)
+ *option_count = 0;
+ return NULL;
+}
+
+uint8_t *dhcpv6_get_sub_option(unsigned char *option, uint16_t max_len,
+ uint16_t *option_code, uint16_t *option_len)
+{
+ int rem;
+ uint16_t code, len;
+
+ rem = max_len - 2 - 2;
+
+ if (rem <= 0)
+ /* Bad option */
+ return NULL;
+
+ code = option[0] << 8 | option[1];
+ len = option[2] << 8 | option[3];
+
+ rem -= len;
+ if (rem < 0)
+ return NULL;
+
+ *option_code = code;
+ *option_len = len;
+
+ return &option[4];
+}
+
+/*
+ * Add an option (supplied in binary form) to the options.
+ * Option format: [code][len][data1][data2]..[dataLEN]
+ */
+void dhcp_add_binary_option(struct dhcp_packet *packet, uint8_t *addopt)
+{
+ unsigned len;
+ uint8_t *optionptr = packet->options;
+ unsigned end = dhcp_end_option(optionptr);
+
+ len = OPT_DATA + addopt[OPT_LEN];
+
+ /* end position + (option code/length + addopt length) + end option */
+ if (end + len + 1 >= DHCP_OPTIONS_BUFSIZE)
+ /* option did not fit into the packet */
+ return;
+
+ memcpy(optionptr + end, addopt, len);
+
+ optionptr[end + len] = DHCP_END;
+}
+
+/*
+ * Add an option (supplied in binary form) to the options.
+ * Option format: [code][len][data1][data2]..[dataLEN]
+ */
+void dhcpv6_add_binary_option(struct dhcpv6_packet *packet, uint16_t max_len,
+ uint16_t *pkt_len, uint8_t *addopt)
+{
+ unsigned len;
+ uint8_t *optionptr = packet->options;
+
+ len = 2 + 2 + (addopt[2] << 8 | addopt[3]);
+
+ /* end position + (option code/length + addopt length) */
+ if (*pkt_len + len >= max_len)
+ /* option did not fit into the packet */
+ return;
+
+ memcpy(optionptr + *pkt_len, addopt, len);
+ *pkt_len += len;
+}
+
+static GDHCPOptionType check_option(uint8_t code, uint8_t data_len)
+{
+ GDHCPOptionType type = dhcp_get_code_type(code);
+ uint8_t len;
+
+ if (type == OPTION_UNKNOWN)
+ return type;
+
+ len = dhcp_option_lengths[type & OPTION_TYPE_MASK];
+ if (len != data_len) {
+ printf("Invalid option len %d (expecting %d) for code 0x%x\n",
+ data_len, len, code);
+ return OPTION_UNKNOWN;
+ }
+
+ return type;
+}
+
+void dhcp_add_option_uint32(struct dhcp_packet *packet, uint8_t code,
+ uint32_t data)
+{
+ uint8_t option[6];
+
+ if (check_option(code, sizeof(data)) == OPTION_UNKNOWN)
+ return;
+
+ option[OPT_CODE] = code;
+ option[OPT_LEN] = sizeof(data);
+ put_be32(data, option + OPT_DATA);
+
+ dhcp_add_binary_option(packet, option);
+
+ return;
+}
+
+void dhcp_add_option_uint16(struct dhcp_packet *packet, uint8_t code,
+ uint16_t data)
+{
+ uint8_t option[6];
+
+ if (check_option(code, sizeof(data)) == OPTION_UNKNOWN)
+ return;
+
+ option[OPT_CODE] = code;
+ option[OPT_LEN] = sizeof(data);
+ put_be16(data, option + OPT_DATA);
+
+ dhcp_add_binary_option(packet, option);
+
+ return;
+}
+
+void dhcp_add_option_uint8(struct dhcp_packet *packet, uint8_t code,
+ uint8_t data)
+{
+ uint8_t option[6];
+
+ if (check_option(code, sizeof(data)) == OPTION_UNKNOWN)
+ return;
+
+ option[OPT_CODE] = code;
+ option[OPT_LEN] = sizeof(data);
+ option[OPT_DATA] = data;
+
+ dhcp_add_binary_option(packet, option);
+
+ return;
+}
+
+void dhcp_init_header(struct dhcp_packet *packet, char type)
+{
+ memset(packet, 0, sizeof(*packet));
+
+ packet->op = BOOTREQUEST;
+
+ switch (type) {
+ case DHCPOFFER:
+ case DHCPACK:
+ case DHCPNAK:
+ packet->op = BOOTREPLY;
+ }
+
+ packet->htype = 1;
+ packet->hlen = 6;
+ packet->cookie = htonl(DHCP_MAGIC);
+ packet->options[0] = DHCP_END;
+
+ dhcp_add_option_uint8(packet, DHCP_MESSAGE_TYPE, type);
+}
+
+void dhcpv6_init_header(struct dhcpv6_packet *packet, uint8_t type)
+{
+ int id;
+ uint64_t rand;
+
+ memset(packet, 0, sizeof(*packet));
+
+ packet->message = type;
+
+ dhcp_get_random(&rand);
+ id = rand;
+
+ packet->transaction_id[0] = (id >> 16) & 0xff;
+ packet->transaction_id[1] = (id >> 8) & 0xff;
+ packet->transaction_id[2] = id & 0xff;
+}
+
+int dhcp_recv_l3_packet(struct dhcp_packet *packet, int fd)
+{
+ int n;
+
+ memset(packet, 0, sizeof(*packet));
+
+ n = read(fd, packet, sizeof(*packet));
+ if (n < 0)
+ return -errno;
+
+ if (packet->cookie != htonl(DHCP_MAGIC))
+ return -EPROTO;
+
+ return n;
+}
+
+int dhcpv6_recv_l3_packet(struct dhcpv6_packet **packet, unsigned char *buf,
+ int buf_len, int fd)
+{
+ int n;
+
+ n = read(fd, buf, buf_len);
+ if (n < 0)
+ return -errno;
+
+ *packet = (struct dhcpv6_packet *)buf;
+
+ return n;
+}
+
+/* TODO: Use glib checksum */
+uint16_t dhcp_checksum(void *addr, int count)
+{
+ /*
+ * Compute Internet Checksum for "count" bytes
+ * beginning at location "addr".
+ */
+ int32_t sum = 0;
+ uint16_t *source = (uint16_t *) addr;
+
+ while (count > 1) {
+ /* This is the inner loop */
+ sum += *source++;
+ count -= 2;
+ }
+
+ /* Add left-over byte, if any */
+ if (count > 0) {
+ /* Make sure that the left-over byte is added correctly both
+ * with little and big endian hosts */
+ uint16_t tmp = 0;
+ *(uint8_t *) &tmp = *(uint8_t *) source;
+ sum += tmp;
+ }
+ /* Fold 32-bit sum to 16 bits */
+ while (sum >> 16)
+ sum = (sum & 0xffff) + (sum >> 16);
+
+ return ~sum;
+}
+
+#define IN6ADDR_ALL_DHCP_RELAY_AGENTS_AND_SERVERS_MC_INIT \
+ { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0x1,0,0x2 } } } /* ff02::1:2 */
+static const struct in6_addr in6addr_all_dhcp_relay_agents_and_servers_mc =
+ IN6ADDR_ALL_DHCP_RELAY_AGENTS_AND_SERVERS_MC_INIT;
+
+int dhcpv6_send_packet(int index, struct dhcpv6_packet *dhcp_pkt, int len)
+{
+ struct msghdr m;
+ struct iovec v;
+ struct in6_pktinfo *pktinfo;
+ struct cmsghdr *cmsg;
+ int fd, ret, opt = 1;
+ struct sockaddr_in6 src;
+ struct sockaddr_in6 dst;
+ void *control_buf;
+ size_t control_buf_len;
+
+ fd = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
+ if (fd < 0)
+ return -errno;
+
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+ memset(&src, 0, sizeof(src));
+ src.sin6_family = AF_INET6;
+ src.sin6_port = htons(DHCPV6_CLIENT_PORT);
+
+ if (bind(fd, (struct sockaddr *) &src, sizeof(src)) <0) {
+ close(fd);
+ return -errno;
+ }
+
+ memset(&dst, 0, sizeof(dst));
+ dst.sin6_family = AF_INET6;
+ dst.sin6_port = htons(DHCPV6_SERVER_PORT);
+
+ dst.sin6_addr = in6addr_all_dhcp_relay_agents_and_servers_mc;
+
+ control_buf_len = CMSG_SPACE(sizeof(struct in6_pktinfo));
+ control_buf = g_try_malloc0(control_buf_len);
+ if (!control_buf) {
+ close(fd);
+ return -ENOMEM;
+ }
+
+ memset(&m, 0, sizeof(m));
+ memset(&v, 0, sizeof(v));
+
+ m.msg_name = &dst;
+ m.msg_namelen = sizeof(dst);
+
+ v.iov_base = (char *)dhcp_pkt;
+ v.iov_len = len;
+ m.msg_iov = &v;
+ m.msg_iovlen = 1;
+
+ m.msg_control = control_buf;
+ m.msg_controllen = control_buf_len;
+ cmsg = CMSG_FIRSTHDR(&m);
+ cmsg->cmsg_level = IPPROTO_IPV6;
+ cmsg->cmsg_type = IPV6_PKTINFO;
+ cmsg->cmsg_len = CMSG_LEN(sizeof(*pktinfo));
+
+ pktinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
+ memset(pktinfo, 0, sizeof(*pktinfo));
+ pktinfo->ipi6_ifindex = index;
+ m.msg_controllen = cmsg->cmsg_len;
+
+ ret = sendmsg(fd, &m, 0);
+ if (ret < 0) {
+ char *msg = "DHCPv6 msg send failed";
+
+ if (errno == EADDRNOTAVAIL) {
+ char *str = g_strdup_printf("%s (index %d)",
+ msg, index);
+ perror(str);
+ g_free(str);
+ } else
+ perror(msg);
+ }
+
+ g_free(control_buf);
+ close(fd);
+
+ return ret;
+}
+
+int dhcp_send_raw_packet(struct dhcp_packet *dhcp_pkt,
+ uint32_t source_ip, int source_port,
+ uint32_t dest_ip, int dest_port,
+ const uint8_t *dest_arp, int ifindex, bool bcast)
+{
+ struct sockaddr_ll dest;
+ struct ip_udp_dhcp_packet packet;
+ int fd, n;
+
+ enum {
+ IP_UPD_DHCP_SIZE = sizeof(struct ip_udp_dhcp_packet) -
+ EXTEND_FOR_BUGGY_SERVERS,
+ UPD_DHCP_SIZE = IP_UPD_DHCP_SIZE -
+ offsetof(struct ip_udp_dhcp_packet, udp),
+ };
+
+ fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_IP));
+ if (fd < 0)
+ return -errno;
+
+ if (bcast)
+ dhcp_pkt->flags |= htons(BROADCAST_FLAG);
+
+ memset(&dest, 0, sizeof(dest));
+ memset(&packet, 0, sizeof(packet));
+ packet.data = *dhcp_pkt;
+
+ dest.sll_family = AF_PACKET;
+ dest.sll_protocol = htons(ETH_P_IP);
+ dest.sll_ifindex = ifindex;
+ dest.sll_halen = 6;
+ memcpy(dest.sll_addr, dest_arp, 6);
+ if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) {
+ close(fd);
+ return -errno;
+ }
+
+ packet.ip.protocol = IPPROTO_UDP;
+ packet.ip.saddr = source_ip;
+ packet.ip.daddr = dest_ip;
+ packet.udp.source = htons(source_port);
+ packet.udp.dest = htons(dest_port);
+ /* size, excluding IP header: */
+ packet.udp.len = htons(UPD_DHCP_SIZE);
+ /* for UDP checksumming, ip.len is set to UDP packet len */
+ packet.ip.tot_len = packet.udp.len;
+ packet.udp.check = dhcp_checksum(&packet, IP_UPD_DHCP_SIZE);
+ /* but for sending, it is set to IP packet len */
+ packet.ip.tot_len = htons(IP_UPD_DHCP_SIZE);
+ packet.ip.ihl = sizeof(packet.ip) >> 2;
+ packet.ip.version = IPVERSION;
+ packet.ip.ttl = IPDEFTTL;
+ packet.ip.check = dhcp_checksum(&packet.ip, sizeof(packet.ip));
+
+ /*
+ * Currently we send full-sized DHCP packets (zero padded).
+ * If you need to change this: last byte of the packet is
+ * packet.data.options[dhcp_end_option(packet.data.options)]
+ */
+ n = sendto(fd, &packet, IP_UPD_DHCP_SIZE, 0,
+ (struct sockaddr *) &dest, sizeof(dest));
+ close(fd);
+
+ if (n < 0)
+ return -errno;
+
+ return n;
+}
+
+int dhcp_send_kernel_packet(struct dhcp_packet *dhcp_pkt,
+ uint32_t source_ip, int source_port,
+ uint32_t dest_ip, int dest_port, int fd)
+{
+ struct sockaddr_in client;
+ int n, opt = 1;
+
+ enum {
+ DHCP_SIZE = sizeof(struct dhcp_packet) -
+ EXTEND_FOR_BUGGY_SERVERS,
+ };
+
+ if (fd < 0) {
+ /* no socket opened, open a new socket to tx the packet and close it */
+ fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
+ if (fd < 0)
+ return -errno;
+
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+ memset(&client, 0, sizeof(client));
+ client.sin_family = AF_INET;
+ client.sin_port = htons(source_port);
+ client.sin_addr.s_addr = htonl(source_ip);
+ if (bind(fd, (struct sockaddr *) &client, sizeof(client)) < 0) {
+ close(fd);
+ return -errno;
+ }
+
+ memset(&client, 0, sizeof(client));
+ client.sin_family = AF_INET;
+ client.sin_port = htons(dest_port);
+ client.sin_addr.s_addr = htonl(dest_ip);
+ if (connect(fd, (struct sockaddr *) &client, sizeof(client)) < 0) {
+ close(fd);
+ return -errno;
+ }
+
+ n = write(fd, dhcp_pkt, DHCP_SIZE);
+
+ close(fd);
+ } else {
+ /* Using existing socket to transmit the packet */
+ memset(&client, 0, sizeof(client));
+ client.sin_family = AF_INET;
+ client.sin_port = htons(dest_port);
+ client.sin_addr.s_addr = htonl(dest_ip);
+
+ n = sendto(fd, dhcp_pkt, DHCP_SIZE, MSG_DONTWAIT,
+ (struct sockaddr *) &client, sizeof(client));
+ }
+
+ if (n < 0)
+ return -errno;
+
+ return n;
+}
+
+int dhcp_l3_socket(int port, const char *interface, int family)
+{
+ int fd, opt = 1, len;
+ struct sockaddr_in addr4;
+ struct sockaddr_in6 addr6;
+ struct sockaddr *addr;
+
+ fd = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_UDP);
+ if (fd < 0)
+ return -errno;
+
+ setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
+
+ if (setsockopt(fd, SOL_SOCKET, SO_BINDTODEVICE,
+ interface, strlen(interface) + 1) < 0) {
+ close(fd);
+ return -1;
+ }
+
+ if (family == AF_INET) {
+ memset(&addr4, 0, sizeof(addr4));
+ addr4.sin_family = family;
+ addr4.sin_port = htons(port);
+ addr = (struct sockaddr *)&addr4;
+ len = sizeof(addr4);
+ } else if (family == AF_INET6) {
+ memset(&addr6, 0, sizeof(addr6));
+ addr6.sin6_family = family;
+ addr6.sin6_port = htons(port);
+ addr = (struct sockaddr *)&addr6;
+ len = sizeof(addr6);
+ } else {
+ close(fd);
+ return -EINVAL;
+ }
+
+ if (bind(fd, addr, len) != 0) {
+ close(fd);
+ return -1;
+ }
+
+ return fd;
+}
+
+char *get_interface_name(int index)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ if (index < 0)
+ return NULL;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ perror("Open socket error");
+ return NULL;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+ if (err < 0) {
+ perror("Get interface name error");
+ close(sk);
+ return NULL;
+ }
+
+ close(sk);
+
+ return g_strdup(ifr.ifr_name);
+}
+
+bool interface_is_up(int index)
+{
+ int sk, err;
+ struct ifreq ifr;
+ bool ret = false;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ perror("Open socket error");
+ return false;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+ if (err < 0) {
+ perror("Get interface name error");
+ goto done;
+ }
+
+ err = ioctl(sk, SIOCGIFFLAGS, &ifr);
+ if (err < 0) {
+ perror("Get interface flags error");
+ goto done;
+ }
+
+ if (ifr.ifr_flags & IFF_UP)
+ ret = true;
+
+done:
+ close(sk);
+
+ return ret;
+}
diff --git a/gdhcp/common.h b/gdhcp/common.h
new file mode 100644
index 0000000..b92d214
--- /dev/null
+++ b/gdhcp/common.h
@@ -0,0 +1,220 @@
+/*
+ *
+ * DHCP client library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <netinet/udp.h>
+#include <netinet/ip.h>
+
+#include <glib.h>
+
+#include "unaligned.h"
+#include "gdhcp.h"
+
+#define CLIENT_PORT 68
+#define SERVER_PORT 67
+
+#define DHCPV6_CLIENT_PORT 546
+#define DHCPV6_SERVER_PORT 547
+#define MAX_DHCPV6_PKT_SIZE 1500
+
+#define EXTEND_FOR_BUGGY_SERVERS 80
+
+static const uint8_t MAC_BCAST_ADDR[ETH_ALEN] __attribute__((aligned(2))) = {
+ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
+};
+
+static const uint8_t MAC_ANY_ADDR[ETH_ALEN] __attribute__((aligned(2))) = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
+};
+
+/* DHCP packet */
+#define DHCP_MAGIC 0x63825363
+#define DHCP_OPTIONS_BUFSIZE 308
+#define BOOTREQUEST 1
+#define BOOTREPLY 2
+
+#define BROADCAST_FLAG 0x8000
+
+/* See RFC 2131 */
+struct dhcp_packet {
+ uint8_t op;
+ uint8_t htype;
+ uint8_t hlen;
+ uint8_t hops;
+ uint32_t xid;
+ uint16_t secs;
+ uint16_t flags;
+ uint32_t ciaddr;
+ uint32_t yiaddr;
+ uint32_t siaddr_nip;
+ uint32_t gateway_nip;
+ uint8_t chaddr[16];
+ uint8_t sname[64];
+ uint8_t file[128];
+ uint32_t cookie;
+ uint8_t options[DHCP_OPTIONS_BUFSIZE + EXTEND_FOR_BUGGY_SERVERS];
+} __attribute__((packed));
+
+struct ip_udp_dhcp_packet {
+ struct iphdr ip;
+ struct udphdr udp;
+ struct dhcp_packet data;
+} __attribute__((packed));
+
+/* See RFC 3315 */
+struct dhcpv6_packet {
+ uint8_t message;
+ uint8_t transaction_id[3];
+ uint8_t options[];
+} __attribute__((packed));
+
+
+/* See RFC 2132 */
+#define DHCP_PADDING 0x00
+#define DHCP_SUBNET 0x01
+#define DHCP_ROUTER 0x03
+#define DHCP_TIME_SERVER 0x04
+#define DHCP_NAME_SERVER 0x05
+#define DHCP_DNS_SERVER 0x06
+#define DHCP_HOST_NAME 0x0c
+#define DHCP_DOMAIN_NAME 0x0f
+#define DHCP_NTP_SERVER 0x2a
+#define DHCP_REQUESTED_IP 0x32
+#define DHCP_LEASE_TIME 0x33
+#define DHCP_OPTION_OVERLOAD 0x34
+#define DHCP_MESSAGE_TYPE 0x35
+#define DHCP_SERVER_ID 0x36
+#define DHCP_PARAM_REQ 0x37
+#define DHCP_ERR_MESSAGE 0x38
+#define DHCP_MAX_SIZE 0x39
+#define DHCP_VENDOR 0x3c
+#define DHCP_CLIENT_ID 0x3d
+#define DHCP_END 0xff
+
+#define OPT_CODE 0
+#define OPT_LEN 1
+#define OPT_DATA 2
+#define OPTION_FIELD 0
+#define FILE_FIELD 1
+#define SNAME_FIELD 2
+
+/* DHCP_MESSAGE_TYPE values */
+#define DHCPDISCOVER 1
+#define DHCPOFFER 2
+#define DHCPREQUEST 3
+#define DHCPDECLINE 4
+#define DHCPACK 5
+#define DHCPNAK 6
+#define DHCPRELEASE 7
+#define DHCPINFORM 8
+#define DHCP_MINTYPE DHCPDISCOVER
+#define DHCP_MAXTYPE DHCPINFORM
+
+/* Message types for DHCPv6, RFC 3315 sec 5.3 */
+#define DHCPV6_SOLICIT 1
+#define DHCPV6_ADVERTISE 2
+#define DHCPV6_REQUEST 3
+#define DHCPV6_CONFIRM 4
+#define DHCPV6_RENEW 5
+#define DHCPV6_REBIND 6
+#define DHCPV6_REPLY 7
+#define DHCPV6_RELEASE 8
+#define DHCPV6_DECLINE 9
+#define DHCPV6_RECONFIGURE 10
+#define DHCPV6_INFORMATION_REQ 11
+
+/*
+ * DUID time starts 2000-01-01.
+ */
+#define DUID_TIME_EPOCH 946684800
+
+typedef enum {
+ OPTION_UNKNOWN,
+ OPTION_IP,
+ OPTION_STRING,
+ OPTION_U8,
+ OPTION_U16,
+ OPTION_U32,
+ OPTION_TYPE_MASK = 0x0f,
+ OPTION_LIST = 0x10,
+} GDHCPOptionType;
+
+typedef struct dhcp_option {
+ GDHCPOptionType type;
+ uint8_t code;
+} DHCPOption;
+
+/* Length of the option types in binary form */
+static const uint8_t dhcp_option_lengths[] = {
+ [OPTION_IP] = 4,
+ [OPTION_STRING] = 1,
+ [OPTION_U8] = 1,
+ [OPTION_U16] = 2,
+ [OPTION_U32] = 4,
+};
+
+/* already defined within netinet/in.h if using GNU compiler */
+#ifndef __USE_GNU
+struct in6_pktinfo {
+ struct in6_addr ipi6_addr; /* src/dst IPv6 address */
+ unsigned int ipi6_ifindex; /* send/recv interface index */
+};
+#endif
+
+uint8_t *dhcp_get_option(struct dhcp_packet *packet, int code);
+uint8_t *dhcpv6_get_option(struct dhcpv6_packet *packet, uint16_t pkt_len,
+ int code, uint16_t *option_len, int *option_count);
+uint8_t *dhcpv6_get_sub_option(unsigned char *option, uint16_t max_len,
+ uint16_t *code, uint16_t *option_len);
+int dhcp_end_option(uint8_t *optionptr);
+void dhcp_add_binary_option(struct dhcp_packet *packet, uint8_t *addopt);
+void dhcpv6_add_binary_option(struct dhcpv6_packet *packet, uint16_t max_len,
+ uint16_t *pkt_len, uint8_t *addopt);
+void dhcp_add_option_uint8(struct dhcp_packet *packet,
+ uint8_t code, uint8_t data);
+void dhcp_add_option_uint16(struct dhcp_packet *packet,
+ uint8_t code, uint16_t data);
+void dhcp_add_option_uint32(struct dhcp_packet *packet,
+ uint8_t code, uint32_t data);
+GDHCPOptionType dhcp_get_code_type(uint8_t code);
+GDHCPOptionType dhcpv6_get_code_type(uint16_t code);
+
+uint16_t dhcp_checksum(void *addr, int count);
+
+void dhcp_init_header(struct dhcp_packet *packet, char type);
+void dhcpv6_init_header(struct dhcpv6_packet *packet, uint8_t type);
+
+int dhcp_send_raw_packet(struct dhcp_packet *dhcp_pkt,
+ uint32_t source_ip, int source_port,
+ uint32_t dest_ip, int dest_port,
+ const uint8_t *dest_arp, int ifindex,
+ bool bcast);
+int dhcpv6_send_packet(int index, struct dhcpv6_packet *dhcp_pkt, int len);
+int dhcp_send_kernel_packet(struct dhcp_packet *dhcp_pkt,
+ uint32_t source_ip, int source_port,
+ uint32_t dest_ip, int dest_port, int fd);
+int dhcp_l3_socket(int port, const char *interface, int family);
+int dhcp_recv_l3_packet(struct dhcp_packet *packet, int fd);
+int dhcpv6_recv_l3_packet(struct dhcpv6_packet **packet, unsigned char *buf,
+ int buf_len, int fd);
+int dhcp_l3_socket_send(int index, int port, int family);
+
+char *get_interface_name(int index);
+bool interface_is_up(int index);
diff --git a/gdhcp/gdhcp.h b/gdhcp/gdhcp.h
new file mode 100644
index 0000000..5ee079e
--- /dev/null
+++ b/gdhcp/gdhcp.h
@@ -0,0 +1,241 @@
+/*
+ *
+ * DHCP library with GLib integration
+ *
+ * Copyright (C) 2009-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __G_DHCP_H
+#define __G_DHCP_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <arpa/inet.h>
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* DHCP Client part*/
+struct _GDHCPClient;
+
+typedef struct _GDHCPClient GDHCPClient;
+
+typedef enum {
+ G_DHCP_CLIENT_ERROR_NONE,
+ G_DHCP_CLIENT_ERROR_INTERFACE_UNAVAILABLE,
+ G_DHCP_CLIENT_ERROR_INTERFACE_IN_USE,
+ G_DHCP_CLIENT_ERROR_INTERFACE_DOWN,
+ G_DHCP_CLIENT_ERROR_NOMEM,
+ G_DHCP_CLIENT_ERROR_INVALID_INDEX,
+ G_DHCP_CLIENT_ERROR_INVALID_OPTION
+} GDHCPClientError;
+
+typedef enum {
+ G_DHCP_CLIENT_EVENT_LEASE_AVAILABLE,
+ G_DHCP_CLIENT_EVENT_IPV4LL_AVAILABLE,
+ G_DHCP_CLIENT_EVENT_NO_LEASE,
+ G_DHCP_CLIENT_EVENT_LEASE_LOST,
+ G_DHCP_CLIENT_EVENT_IPV4LL_LOST,
+ G_DHCP_CLIENT_EVENT_ADDRESS_CONFLICT,
+ G_DHCP_CLIENT_EVENT_INFORMATION_REQ,
+ G_DHCP_CLIENT_EVENT_SOLICITATION,
+ G_DHCP_CLIENT_EVENT_ADVERTISE,
+ G_DHCP_CLIENT_EVENT_REQUEST,
+ G_DHCP_CLIENT_EVENT_RENEW,
+ G_DHCP_CLIENT_EVENT_REBIND,
+ G_DHCP_CLIENT_EVENT_RELEASE,
+ G_DHCP_CLIENT_EVENT_CONFIRM,
+ G_DHCP_CLIENT_EVENT_DECLINE,
+ G_DHCP_CLIENT_EVENT_WAKE_EVENT,
+} GDHCPClientEvent;
+
+typedef enum {
+ G_DHCP_IPV4,
+ G_DHCP_IPV6,
+ G_DHCP_IPV4LL,
+} GDHCPType;
+
+#define G_DHCP_SUBNET 0x01
+#define G_DHCP_ROUTER 0x03
+#define G_DHCP_TIME_SERVER 0x04
+#define G_DHCP_DNS_SERVER 0x06
+#define G_DHCP_DOMAIN_NAME 0x0f
+#define G_DHCP_HOST_NAME 0x0c
+#define G_DHCP_NTP_SERVER 0x2a
+#define G_DHCP_CLIENT_ID 0x3d
+
+#define G_DHCPV6_CLIENTID 1
+#define G_DHCPV6_SERVERID 2
+#define G_DHCPV6_IA_NA 3
+#define G_DHCPV6_IA_TA 4
+#define G_DHCPV6_IAADDR 5
+#define G_DHCPV6_ORO 6
+#define G_DHCPV6_PREFERENCE 7
+#define G_DHCPV6_ELAPSED_TIME 8
+#define G_DHCPV6_STATUS_CODE 13
+#define G_DHCPV6_RAPID_COMMIT 14
+#define G_DHCPV6_DNS_SERVERS 23
+#define G_DHCPV6_DOMAIN_LIST 24
+#define G_DHCPV6_IA_PD 25
+#define G_DHCPV6_IA_PREFIX 26
+#define G_DHCPV6_SNTP_SERVERS 31
+
+#define G_DHCPV6_ERROR_SUCCESS 0
+#define G_DHCPV6_ERROR_FAILURE 1
+#define G_DHCPV6_ERROR_NO_ADDR 2
+#define G_DHCPV6_ERROR_BINDING 3
+#define G_DHCPV6_ERROR_LINK 4
+#define G_DHCPV6_ERROR_MCAST 5
+#define G_DHCPV6_ERROR_NO_PREFIX 6
+
+typedef enum {
+ G_DHCPV6_DUID_LLT = 1,
+ G_DHCPV6_DUID_EN = 2,
+ G_DHCPV6_DUID_LL = 3,
+} GDHCPDuidType;
+
+typedef struct {
+ /*
+ * Note that no field in this struct can be allocated
+ * from heap or there will be a memory leak when the
+ * struct is freed by client.c:remove_option_value()
+ */
+ struct in6_addr prefix;
+ unsigned char prefixlen;
+ uint32_t preferred;
+ uint32_t valid;
+ time_t expire;
+} GDHCPIAPrefix;
+
+typedef void (*GDHCPClientEventFunc) (GDHCPClient *client, gpointer user_data);
+
+typedef void (*GDHCPDebugFunc)(const char *str, gpointer user_data);
+
+GDHCPClient *g_dhcp_client_new(GDHCPType type, int index,
+ GDHCPClientError *error);
+
+int g_dhcp_client_start(GDHCPClient *client, const char *last_address);
+void g_dhcp_client_stop(GDHCPClient *client);
+
+GDHCPClient *g_dhcp_client_ref(GDHCPClient *client);
+void g_dhcp_client_unref(GDHCPClient *client);
+
+void g_dhcp_client_register_event(GDHCPClient *client,
+ GDHCPClientEvent event,
+ GDHCPClientEventFunc func,
+ gpointer user_data);
+
+GDHCPClientError g_dhcp_client_set_request(GDHCPClient *client,
+ unsigned int option_code);
+void g_dhcp_client_clear_requests(GDHCPClient *dhcp_client);
+void g_dhcp_client_clear_values(GDHCPClient *dhcp_client);
+GDHCPClientError g_dhcp_client_set_id(GDHCPClient *client);
+GDHCPClientError g_dhcp_client_set_send(GDHCPClient *client,
+ unsigned char option_code,
+ const char *option_value);
+
+char *g_dhcp_client_get_server_address(GDHCPClient *client);
+char *g_dhcp_client_get_address(GDHCPClient *client);
+char *g_dhcp_client_get_netmask(GDHCPClient *client);
+GList *g_dhcp_client_get_option(GDHCPClient *client,
+ unsigned char option_code);
+int g_dhcp_client_get_index(GDHCPClient *client);
+
+void g_dhcp_client_set_debug(GDHCPClient *client,
+ GDHCPDebugFunc func, gpointer user_data);
+int g_dhcpv6_create_duid(GDHCPDuidType duid_type, int index, int type,
+ unsigned char **duid, int *duid_len);
+int g_dhcpv6_client_set_duid(GDHCPClient *dhcp_client, unsigned char *duid,
+ int duid_len);
+int g_dhcpv6_client_set_pd(GDHCPClient *dhcp_client, uint32_t *T1, uint32_t *T2,
+ GSList *prefixes);
+GSList *g_dhcpv6_copy_prefixes(GSList *prefixes);
+gboolean g_dhcpv6_client_clear_send(GDHCPClient *dhcp_client, uint16_t code);
+void g_dhcpv6_client_set_send(GDHCPClient *dhcp_client, uint16_t option_code,
+ uint8_t *option_value, uint16_t option_len);
+uint16_t g_dhcpv6_client_get_status(GDHCPClient *dhcp_client);
+int g_dhcpv6_client_set_oro(GDHCPClient *dhcp_client, int args, ...);
+void g_dhcpv6_client_create_iaid(GDHCPClient *dhcp_client, int index,
+ unsigned char *iaid);
+int g_dhcpv6_client_get_timeouts(GDHCPClient *dhcp_client,
+ uint32_t *T1, uint32_t *T2,
+ time_t *started, time_t *expire);
+uint32_t g_dhcpv6_client_get_iaid(GDHCPClient *dhcp_client);
+void g_dhcpv6_client_set_iaid(GDHCPClient *dhcp_client, uint32_t iaid);
+int g_dhcpv6_client_set_ia(GDHCPClient *dhcp_client, int index,
+ int code, uint32_t *T1, uint32_t *T2,
+ bool add_addresses, const char *address);
+int g_dhcpv6_client_set_ias(GDHCPClient *dhcp_client, int index,
+ int code, uint32_t *T1, uint32_t *T2,
+ GSList *addresses);
+void g_dhcpv6_client_reset_request(GDHCPClient *dhcp_client);
+void g_dhcpv6_client_set_retransmit(GDHCPClient *dhcp_client);
+void g_dhcpv6_client_clear_retransmit(GDHCPClient *dhcp_client);
+
+/* DHCP Server */
+typedef enum {
+ G_DHCP_SERVER_ERROR_NONE,
+ G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE,
+ G_DHCP_SERVER_ERROR_INTERFACE_IN_USE,
+ G_DHCP_SERVER_ERROR_INTERFACE_DOWN,
+ G_DHCP_SERVER_ERROR_NOMEM,
+ G_DHCP_SERVER_ERROR_INVALID_INDEX,
+ G_DHCP_SERVER_ERROR_INVALID_OPTION,
+ G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID
+} GDHCPServerError;
+
+typedef void (*GDHCPSaveLeaseFunc) (unsigned char *mac,
+ unsigned int nip, unsigned int expire);
+
+typedef void (*GDHCPLeaseAddedCb) (unsigned char *mac, uint32_t ip);
+
+struct _GDHCPServer;
+
+typedef struct _GDHCPServer GDHCPServer;
+
+GDHCPServer *g_dhcp_server_new(GDHCPType type,
+ int ifindex, GDHCPServerError *error);
+int g_dhcp_server_start(GDHCPServer *server);
+void g_dhcp_server_stop(GDHCPServer *server);
+
+GDHCPServer *g_dhcp_server_ref(GDHCPServer *server);
+void g_dhcp_server_unref(GDHCPServer *server);
+
+int g_dhcp_server_set_option(GDHCPServer *server,
+ unsigned char option_code, const char *option_value);
+int g_dhcp_server_set_ip_range(GDHCPServer *server,
+ const char *start_ip, const char *end_ip);
+void g_dhcp_server_set_debug(GDHCPServer *server,
+ GDHCPDebugFunc func, gpointer user_data);
+void g_dhcp_server_set_lease_time(GDHCPServer *dhcp_server,
+ unsigned int lease_time);
+void g_dhcp_server_set_save_lease(GDHCPServer *dhcp_server,
+ GDHCPSaveLeaseFunc func, gpointer user_data);
+void g_dhcp_server_set_lease_added_cb(GDHCPServer *dhcp_server,
+ GDHCPLeaseAddedCb cb);
+
+int dhcp_get_random(uint64_t *val);
+void dhcp_cleanup_random(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __G_DHCP_H */
diff --git a/gdhcp/ipv4ll.c b/gdhcp/ipv4ll.c
new file mode 100644
index 0000000..c43971f
--- /dev/null
+++ b/gdhcp/ipv4ll.c
@@ -0,0 +1,135 @@
+/*
+ *
+ * IPV4 Local Link library with GLib integration
+ *
+ * Copyright (C) 2009-2010 Aldebaran Robotics. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+
+#include <sys/time.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#include <netinet/if_ether.h>
+
+#include <arpa/inet.h>
+
+#include <glib.h>
+#include "ipv4ll.h"
+#include "common.h"
+
+/**
+ * Return a random link local IP (in host byte order)
+ */
+uint32_t ipv4ll_random_ip(void)
+{
+ unsigned tmp;
+ uint64_t rand;
+
+ do {
+ dhcp_get_random(&rand);
+ tmp = rand;
+ tmp = tmp & IN_CLASSB_HOST;
+ } while (tmp > (IN_CLASSB_HOST - 0x0200));
+ return ((LINKLOCAL_ADDR + 0x0100) + tmp);
+}
+
+/**
+ * Return a random delay in range of zero to secs*1000
+ */
+guint ipv4ll_random_delay_ms(guint secs)
+{
+ uint64_t rand;
+
+ dhcp_get_random(&rand);
+ return rand % (secs * 1000);
+}
+
+int ipv4ll_send_arp_packet(uint8_t* source_eth, uint32_t source_ip,
+ uint32_t target_ip, int ifindex)
+{
+ struct sockaddr_ll dest;
+ struct ether_arp p;
+ uint32_t ip_source;
+ uint32_t ip_target;
+ int fd, n;
+
+ fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_ARP));
+ if (fd < 0)
+ return -errno;
+
+ memset(&dest, 0, sizeof(dest));
+ memset(&p, 0, sizeof(p));
+
+ dest.sll_family = AF_PACKET;
+ dest.sll_protocol = htons(ETH_P_ARP);
+ dest.sll_ifindex = ifindex;
+ dest.sll_halen = ETH_ALEN;
+ memset(dest.sll_addr, 0xFF, ETH_ALEN);
+ if (bind(fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) {
+ close(fd);
+ return -errno;
+ }
+
+ ip_source = htonl(source_ip);
+ ip_target = htonl(target_ip);
+ p.arp_hrd = htons(ARPHRD_ETHER);
+ p.arp_pro = htons(ETHERTYPE_IP);
+ p.arp_hln = ETH_ALEN;
+ p.arp_pln = 4;
+ p.arp_op = htons(ARPOP_REQUEST);
+
+ memcpy(&p.arp_sha, source_eth, ETH_ALEN);
+ memcpy(&p.arp_spa, &ip_source, sizeof(p.arp_spa));
+ memcpy(&p.arp_tpa, &ip_target, sizeof(p.arp_tpa));
+
+ n = sendto(fd, &p, sizeof(p), 0,
+ (struct sockaddr*) &dest, sizeof(dest));
+ if (n < 0)
+ n = -errno;
+
+ close(fd);
+
+ return n;
+}
+
+int ipv4ll_arp_socket(int ifindex)
+{
+ int fd;
+ struct sockaddr_ll sock;
+
+ fd = socket(PF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, htons(ETH_P_ARP));
+ if (fd < 0)
+ return fd;
+
+ memset(&sock, 0, sizeof(sock));
+
+ sock.sll_family = AF_PACKET;
+ sock.sll_protocol = htons(ETH_P_ARP);
+ sock.sll_ifindex = ifindex;
+
+ if (bind(fd, (struct sockaddr *) &sock, sizeof(sock)) != 0) {
+ close(fd);
+ return -errno;
+ }
+
+ return fd;
+}
diff --git a/gdhcp/ipv4ll.h b/gdhcp/ipv4ll.h
new file mode 100644
index 0000000..bee8138
--- /dev/null
+++ b/gdhcp/ipv4ll.h
@@ -0,0 +1,55 @@
+/*
+ *
+ * IPV4 Local Link library with GLib integration
+ *
+ * Copyright (C) 2009-2010 Aldebaran Robotics. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __G_IPV4LL_H
+#define __G_IPV4LL_H
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 169.254.0.0 */
+#define LINKLOCAL_ADDR 0xa9fe0000
+
+/* See RFC 3927 */
+#define PROBE_WAIT 1
+#define PROBE_NUM 3
+#define PROBE_MIN 1
+#define PROBE_MAX 2
+#define ANNOUNCE_WAIT 2
+#define ANNOUNCE_NUM 2
+#define ANNOUNCE_INTERVAL 2
+#define MAX_CONFLICTS 10
+#define RATE_LIMIT_INTERVAL 60
+#define DEFEND_INTERVAL 10
+
+uint32_t ipv4ll_random_ip(void);
+guint ipv4ll_random_delay_ms(guint secs);
+int ipv4ll_send_arp_packet(uint8_t* source_eth, uint32_t source_ip,
+ uint32_t target_ip, int ifindex);
+int ipv4ll_arp_socket(int ifindex);
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !IPV4LL_H_ */
diff --git a/gdhcp/server.c b/gdhcp/server.c
new file mode 100644
index 0000000..8574c24
--- /dev/null
+++ b/gdhcp/server.c
@@ -0,0 +1,910 @@
+/*
+ *
+ * DHCP Server library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+
+#include <netpacket/packet.h>
+#include <net/ethernet.h>
+#include <net/if_arp.h>
+
+#include <linux/if.h>
+#include <linux/filter.h>
+
+#include <glib.h>
+
+#include "common.h"
+
+/* 8 hours */
+#define DEFAULT_DHCP_LEASE_SEC (8*60*60)
+
+/* 5 minutes */
+#define OFFER_TIME (5*60)
+
+struct _GDHCPServer {
+ int ref_count;
+ GDHCPType type;
+ bool started;
+ int ifindex;
+ char *interface;
+ uint32_t start_ip;
+ uint32_t end_ip;
+ uint32_t server_nip; /* our address in network byte order */
+ uint32_t lease_seconds;
+ int listener_sockfd;
+ guint listener_watch;
+ GIOChannel *listener_channel;
+ GList *lease_list;
+ GHashTable *nip_lease_hash;
+ GHashTable *option_hash; /* Options send to client */
+ GDHCPSaveLeaseFunc save_lease_func;
+ GDHCPLeaseAddedCb lease_added_cb;
+ GDHCPDebugFunc debug_func;
+ gpointer debug_data;
+};
+
+struct dhcp_lease {
+ time_t expire;
+ uint32_t lease_nip;
+ uint8_t lease_mac[ETH_ALEN];
+};
+
+static inline void debug(GDHCPServer *server, const char *format, ...)
+{
+ char str[256];
+ va_list ap;
+
+ if (!server->debug_func)
+ return;
+
+ va_start(ap, format);
+
+ if (vsnprintf(str, sizeof(str), format, ap) > 0)
+ server->debug_func(str, server->debug_data);
+
+ va_end(ap);
+}
+
+static struct dhcp_lease *find_lease_by_mac(GDHCPServer *dhcp_server,
+ const uint8_t *mac)
+{
+ GList *list;
+
+ for (list = dhcp_server->lease_list; list; list = list->next) {
+ struct dhcp_lease *lease = list->data;
+
+ if (memcmp(lease->lease_mac, mac, ETH_ALEN) == 0)
+ return lease;
+ }
+
+ return NULL;
+}
+
+static void remove_lease(GDHCPServer *dhcp_server, struct dhcp_lease *lease)
+{
+ dhcp_server->lease_list =
+ g_list_remove(dhcp_server->lease_list, lease);
+
+ g_hash_table_remove(dhcp_server->nip_lease_hash,
+ GINT_TO_POINTER((int) lease->lease_nip));
+ g_free(lease);
+}
+
+/* Clear the old lease and create the new one */
+static int get_lease(GDHCPServer *dhcp_server, uint32_t yiaddr,
+ const uint8_t *mac, struct dhcp_lease **lease)
+{
+ struct dhcp_lease *lease_nip, *lease_mac;
+
+ if (yiaddr == 0)
+ return -ENXIO;
+
+ if (ntohl(yiaddr) < dhcp_server->start_ip)
+ return -ENXIO;
+
+ if (ntohl(yiaddr) > dhcp_server->end_ip)
+ return -ENXIO;
+
+ if (memcmp(mac, MAC_BCAST_ADDR, ETH_ALEN) == 0)
+ return -ENXIO;
+
+ if (memcmp(mac, MAC_ANY_ADDR, ETH_ALEN) == 0)
+ return -ENXIO;
+
+ lease_mac = find_lease_by_mac(dhcp_server, mac);
+
+ lease_nip = g_hash_table_lookup(dhcp_server->nip_lease_hash,
+ GINT_TO_POINTER((int) ntohl(yiaddr)));
+ debug(dhcp_server, "lease_mac %p lease_nip %p", lease_mac, lease_nip);
+
+ if (lease_nip) {
+ dhcp_server->lease_list =
+ g_list_remove(dhcp_server->lease_list,
+ lease_nip);
+ g_hash_table_remove(dhcp_server->nip_lease_hash,
+ GINT_TO_POINTER((int) ntohl(yiaddr)));
+
+ if (!lease_mac)
+ *lease = lease_nip;
+ else if (lease_nip != lease_mac) {
+ remove_lease(dhcp_server, lease_mac);
+ *lease = lease_nip;
+ } else
+ *lease = lease_nip;
+
+ return 0;
+ }
+
+ if (lease_mac) {
+ dhcp_server->lease_list =
+ g_list_remove(dhcp_server->lease_list,
+ lease_mac);
+ g_hash_table_remove(dhcp_server->nip_lease_hash,
+ GINT_TO_POINTER((int) lease_mac->lease_nip));
+ *lease = lease_mac;
+
+ return 0;
+ }
+
+ *lease = g_try_new0(struct dhcp_lease, 1);
+ if (!*lease)
+ return -ENOMEM;
+
+ return 0;
+}
+
+static gint compare_expire(gconstpointer a, gconstpointer b)
+{
+ const struct dhcp_lease *lease1 = a;
+ const struct dhcp_lease *lease2 = b;
+
+ return lease2->expire - lease1->expire;
+}
+
+static struct dhcp_lease *add_lease(GDHCPServer *dhcp_server, uint32_t expire,
+ const uint8_t *chaddr, uint32_t yiaddr)
+{
+ struct dhcp_lease *lease = NULL;
+ int ret;
+
+ ret = get_lease(dhcp_server, yiaddr, chaddr, &lease);
+ if (ret != 0)
+ return NULL;
+
+ memset(lease, 0, sizeof(*lease));
+
+ memcpy(lease->lease_mac, chaddr, ETH_ALEN);
+ lease->lease_nip = ntohl(yiaddr);
+
+ if (expire == 0)
+ lease->expire = time(NULL) + dhcp_server->lease_seconds;
+ else
+ lease->expire = expire;
+
+ dhcp_server->lease_list = g_list_insert_sorted(dhcp_server->lease_list,
+ lease, compare_expire);
+
+ g_hash_table_insert(dhcp_server->nip_lease_hash,
+ GINT_TO_POINTER((int) lease->lease_nip), lease);
+
+ if (dhcp_server->lease_added_cb)
+ dhcp_server->lease_added_cb(lease->lease_mac, yiaddr);
+
+ return lease;
+}
+
+static struct dhcp_lease *find_lease_by_nip(GDHCPServer *dhcp_server,
+ uint32_t nip)
+{
+ return g_hash_table_lookup(dhcp_server->nip_lease_hash,
+ GINT_TO_POINTER((int) nip));
+}
+
+/* Check if the IP is taken; if it is, add it to the lease table */
+static bool arp_check(uint32_t nip, const uint8_t *safe_mac)
+{
+ /* TODO: Add ARP checking */
+ return true;
+}
+
+static bool is_expired_lease(struct dhcp_lease *lease)
+{
+ if (lease->expire < time(NULL))
+ return true;
+
+ return false;
+}
+
+static uint32_t find_free_or_expired_nip(GDHCPServer *dhcp_server,
+ const uint8_t *safe_mac)
+{
+ uint32_t ip_addr;
+ struct dhcp_lease *lease;
+ GList *list;
+ ip_addr = dhcp_server->start_ip;
+ for (; ip_addr <= dhcp_server->end_ip; ip_addr++) {
+ /* e.g. 192.168.55.0 */
+ if ((ip_addr & 0xff) == 0)
+ continue;
+
+ /* e.g. 192.168.55.255 */
+ if ((ip_addr & 0xff) == 0xff)
+ continue;
+
+ lease = find_lease_by_nip(dhcp_server, ip_addr);
+ if (lease)
+ continue;
+
+ if (arp_check(htonl(ip_addr), safe_mac))
+ return ip_addr;
+ }
+
+ /* The last lease is the oldest one */
+ list = g_list_last(dhcp_server->lease_list);
+ if (!list)
+ return 0;
+
+ lease = list->data;
+ if (!lease)
+ return 0;
+
+ if (!is_expired_lease(lease))
+ return 0;
+
+ if (!arp_check(lease->lease_nip, safe_mac))
+ return 0;
+
+ return lease->lease_nip;
+}
+
+static void lease_set_expire(GDHCPServer *dhcp_server,
+ struct dhcp_lease *lease, uint32_t expire)
+{
+ dhcp_server->lease_list = g_list_remove(dhcp_server->lease_list, lease);
+
+ lease->expire = expire;
+
+ dhcp_server->lease_list = g_list_insert_sorted(dhcp_server->lease_list,
+ lease, compare_expire);
+}
+
+static void destroy_lease_table(GDHCPServer *dhcp_server)
+{
+ GList *list;
+
+ g_hash_table_destroy(dhcp_server->nip_lease_hash);
+
+ dhcp_server->nip_lease_hash = NULL;
+
+ for (list = dhcp_server->lease_list; list; list = list->next) {
+ struct dhcp_lease *lease = list->data;
+
+ g_free(lease);
+ }
+
+ g_list_free(dhcp_server->lease_list);
+
+ dhcp_server->lease_list = NULL;
+}
+static uint32_t get_interface_address(int index)
+{
+ struct ifreq ifr;
+ int sk, err;
+ struct sockaddr_in *server_ip;
+ uint32_t ret = 0;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ perror("Open socket error");
+ return 0;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+ if (err < 0) {
+ perror("Get interface name error");
+ goto done;
+ }
+
+ err = ioctl(sk, SIOCGIFADDR, &ifr);
+ if (err < 0) {
+ perror("Get ip address error");
+ goto done;
+ }
+
+ server_ip = (struct sockaddr_in *) &ifr.ifr_addr;
+ ret = server_ip->sin_addr.s_addr;
+
+done:
+ close(sk);
+
+ return ret;
+}
+
+GDHCPServer *g_dhcp_server_new(GDHCPType type,
+ int ifindex, GDHCPServerError *error)
+{
+ GDHCPServer *dhcp_server = NULL;
+
+ if (ifindex < 0) {
+ *error = G_DHCP_SERVER_ERROR_INVALID_INDEX;
+ return NULL;
+ }
+
+ dhcp_server = g_try_new0(GDHCPServer, 1);
+ if (!dhcp_server) {
+ *error = G_DHCP_SERVER_ERROR_NOMEM;
+ return NULL;
+ }
+
+ dhcp_server->interface = get_interface_name(ifindex);
+ if (!dhcp_server->interface) {
+ *error = G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE;
+ goto error;
+ }
+
+ if (!interface_is_up(ifindex)) {
+ *error = G_DHCP_SERVER_ERROR_INTERFACE_DOWN;
+ goto error;
+ }
+
+ dhcp_server->server_nip = get_interface_address(ifindex);
+ if (dhcp_server->server_nip == 0) {
+ *error = G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID;
+ goto error;
+ }
+
+ dhcp_server->nip_lease_hash = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL, NULL);
+ dhcp_server->option_hash = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL, NULL);
+
+ dhcp_server->started = FALSE;
+
+ /* All the leases have the same fixed lease time,
+ * do not support DHCP_LEASE_TIME option from client.
+ */
+ dhcp_server->lease_seconds = DEFAULT_DHCP_LEASE_SEC;
+
+ dhcp_server->type = type;
+ dhcp_server->ref_count = 1;
+ dhcp_server->ifindex = ifindex;
+ dhcp_server->listener_sockfd = -1;
+ dhcp_server->listener_watch = -1;
+ dhcp_server->listener_channel = NULL;
+ dhcp_server->save_lease_func = NULL;
+ dhcp_server->debug_func = NULL;
+ dhcp_server->debug_data = NULL;
+
+ *error = G_DHCP_SERVER_ERROR_NONE;
+
+ return dhcp_server;
+
+error:
+ g_free(dhcp_server->interface);
+ g_free(dhcp_server);
+ return NULL;
+}
+
+
+static uint8_t check_packet_type(struct dhcp_packet *packet)
+{
+ uint8_t *type;
+
+ if (packet->hlen != ETH_ALEN)
+ return 0;
+
+ if (packet->op != BOOTREQUEST)
+ return 0;
+
+ type = dhcp_get_option(packet, DHCP_MESSAGE_TYPE);
+
+ if (!type)
+ return 0;
+
+ if (*type < DHCP_MINTYPE)
+ return 0;
+
+ if (*type > DHCP_MAXTYPE)
+ return 0;
+
+ return *type;
+}
+
+static void init_packet(GDHCPServer *dhcp_server, struct dhcp_packet *packet,
+ struct dhcp_packet *client_packet, char type)
+{
+ /* Sets op, htype, hlen, cookie fields
+ * and adds DHCP_MESSAGE_TYPE option */
+ dhcp_init_header(packet, type);
+
+ packet->xid = client_packet->xid;
+ memcpy(packet->chaddr, client_packet->chaddr,
+ sizeof(client_packet->chaddr));
+ packet->flags = client_packet->flags;
+ packet->gateway_nip = client_packet->gateway_nip;
+ packet->ciaddr = client_packet->ciaddr;
+ dhcp_add_option_uint32(packet, DHCP_SERVER_ID,
+ ntohl(dhcp_server->server_nip));
+}
+
+static void add_option(gpointer key, gpointer value, gpointer user_data)
+{
+ const char *option_value = value;
+ uint8_t option_code = GPOINTER_TO_INT(key);
+ struct in_addr nip;
+ struct dhcp_packet *packet = user_data;
+
+ if (!option_value)
+ return;
+
+ switch (option_code) {
+ case G_DHCP_SUBNET:
+ case G_DHCP_ROUTER:
+ case G_DHCP_DNS_SERVER:
+ if (inet_aton(option_value, &nip) == 0)
+ return;
+
+ dhcp_add_option_uint32(packet, (uint8_t) option_code,
+ ntohl(nip.s_addr));
+ break;
+ default:
+ return;
+ }
+}
+
+static void add_server_options(GDHCPServer *dhcp_server,
+ struct dhcp_packet *packet)
+{
+ g_hash_table_foreach(dhcp_server->option_hash,
+ add_option, packet);
+}
+
+static bool check_requested_nip(GDHCPServer *dhcp_server,
+ uint32_t requested_nip)
+{
+ struct dhcp_lease *lease;
+
+ if (requested_nip == 0)
+ return false;
+
+ if (requested_nip < dhcp_server->start_ip)
+ return false;
+
+ if (requested_nip > dhcp_server->end_ip)
+ return false;
+
+ lease = find_lease_by_nip(dhcp_server, requested_nip);
+ if (!lease)
+ return true;
+
+ if (!is_expired_lease(lease))
+ return false;
+
+ return true;
+}
+
+static void send_packet_to_client(GDHCPServer *dhcp_server,
+ struct dhcp_packet *dhcp_pkt)
+{
+ const uint8_t *chaddr;
+ uint32_t ciaddr;
+
+ if ((dhcp_pkt->flags & htons(BROADCAST_FLAG))
+ || dhcp_pkt->ciaddr == 0) {
+ debug(dhcp_server, "Broadcasting packet to client");
+ ciaddr = INADDR_BROADCAST;
+ chaddr = MAC_BCAST_ADDR;
+ } else {
+ debug(dhcp_server, "Unicasting packet to client ciaddr");
+ ciaddr = dhcp_pkt->ciaddr;
+ chaddr = dhcp_pkt->chaddr;
+ }
+
+ dhcp_send_raw_packet(dhcp_pkt,
+ dhcp_server->server_nip, SERVER_PORT,
+ ciaddr, CLIENT_PORT, chaddr,
+ dhcp_server->ifindex, false);
+}
+
+static void send_offer(GDHCPServer *dhcp_server,
+ struct dhcp_packet *client_packet,
+ struct dhcp_lease *lease,
+ uint32_t requested_nip)
+{
+ struct dhcp_packet packet;
+ struct in_addr addr;
+
+ init_packet(dhcp_server, &packet, client_packet, DHCPOFFER);
+
+ if (lease)
+ packet.yiaddr = htonl(lease->lease_nip);
+ else if (check_requested_nip(dhcp_server, requested_nip))
+ packet.yiaddr = htonl(requested_nip);
+ else
+ packet.yiaddr = htonl(find_free_or_expired_nip(
+ dhcp_server, client_packet->chaddr));
+
+ debug(dhcp_server, "find yiaddr %u", packet.yiaddr);
+
+ if (!packet.yiaddr) {
+ debug(dhcp_server, "Err: Can not found lease and send offer");
+ return;
+ }
+
+ lease = add_lease(dhcp_server, OFFER_TIME,
+ packet.chaddr, packet.yiaddr);
+ if (!lease) {
+ debug(dhcp_server,
+ "Err: No free IP addresses. OFFER abandoned");
+ return;
+ }
+
+ dhcp_add_option_uint32(&packet, DHCP_LEASE_TIME,
+ dhcp_server->lease_seconds);
+ add_server_options(dhcp_server, &packet);
+
+ addr.s_addr = packet.yiaddr;
+
+ debug(dhcp_server, "Sending OFFER of %s", inet_ntoa(addr));
+ send_packet_to_client(dhcp_server, &packet);
+}
+
+static void save_lease(GDHCPServer *dhcp_server)
+{
+ GList *list;
+
+ if (!dhcp_server->save_lease_func)
+ return;
+
+ for (list = dhcp_server->lease_list; list; list = list->next) {
+ struct dhcp_lease *lease = list->data;
+ dhcp_server->save_lease_func(lease->lease_mac,
+ lease->lease_nip, lease->expire);
+ }
+}
+
+static void send_ACK(GDHCPServer *dhcp_server,
+ struct dhcp_packet *client_packet, uint32_t dest)
+{
+ struct dhcp_packet packet;
+ uint32_t lease_time_sec;
+ struct in_addr addr;
+
+ init_packet(dhcp_server, &packet, client_packet, DHCPACK);
+ packet.yiaddr = htonl(dest);
+
+ lease_time_sec = dhcp_server->lease_seconds;
+
+ dhcp_add_option_uint32(&packet, DHCP_LEASE_TIME, lease_time_sec);
+
+ add_server_options(dhcp_server, &packet);
+
+ addr.s_addr = htonl(dest);
+
+ debug(dhcp_server, "Sending ACK to %s", inet_ntoa(addr));
+
+ send_packet_to_client(dhcp_server, &packet);
+
+ add_lease(dhcp_server, 0, packet.chaddr, packet.yiaddr);
+}
+
+static void send_NAK(GDHCPServer *dhcp_server,
+ struct dhcp_packet *client_packet)
+{
+ struct dhcp_packet packet;
+
+ init_packet(dhcp_server, &packet, client_packet, DHCPNAK);
+
+ debug(dhcp_server, "Sending NAK");
+
+ dhcp_send_raw_packet(&packet,
+ dhcp_server->server_nip, SERVER_PORT,
+ INADDR_BROADCAST, CLIENT_PORT, MAC_BCAST_ADDR,
+ dhcp_server->ifindex, false);
+}
+
+static void send_inform(GDHCPServer *dhcp_server,
+ struct dhcp_packet *client_packet)
+{
+ struct dhcp_packet packet;
+
+ init_packet(dhcp_server, &packet, client_packet, DHCPACK);
+ add_server_options(dhcp_server, &packet);
+ send_packet_to_client(dhcp_server, &packet);
+}
+
+static gboolean listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ GDHCPServer *dhcp_server = user_data;
+ struct dhcp_packet packet;
+ struct dhcp_lease *lease;
+ uint32_t requested_nip = 0;
+ uint8_t type, *server_id_option, *request_ip_option;
+ int re;
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ dhcp_server->listener_watch = 0;
+ return FALSE;
+ }
+
+ re = dhcp_recv_l3_packet(&packet, dhcp_server->listener_sockfd);
+ if (re < 0)
+ return TRUE;
+
+ type = check_packet_type(&packet);
+ if (type == 0)
+ return TRUE;
+
+ server_id_option = dhcp_get_option(&packet, DHCP_SERVER_ID);
+ if (server_id_option) {
+ uint32_t server_nid =
+ get_unaligned((const uint32_t *) server_id_option);
+
+ if (server_nid != dhcp_server->server_nip)
+ return TRUE;
+ }
+
+ request_ip_option = dhcp_get_option(&packet, DHCP_REQUESTED_IP);
+ if (request_ip_option)
+ requested_nip = get_be32(request_ip_option);
+
+ lease = find_lease_by_mac(dhcp_server, packet.chaddr);
+
+ switch (type) {
+ case DHCPDISCOVER:
+ debug(dhcp_server, "Received DISCOVER");
+
+ send_offer(dhcp_server, &packet, lease, requested_nip);
+ break;
+ case DHCPREQUEST:
+ debug(dhcp_server, "Received REQUEST NIP %d",
+ requested_nip);
+ if (requested_nip == 0) {
+ requested_nip = packet.ciaddr;
+ if (requested_nip == 0)
+ break;
+ }
+
+ if (lease && requested_nip == lease->lease_nip) {
+ debug(dhcp_server, "Sending ACK");
+ send_ACK(dhcp_server, &packet,
+ lease->lease_nip);
+ break;
+ }
+
+ if (server_id_option || !lease) {
+ debug(dhcp_server, "Sending NAK");
+ send_NAK(dhcp_server, &packet);
+ }
+
+ break;
+ case DHCPDECLINE:
+ debug(dhcp_server, "Received DECLINE");
+
+ if (!server_id_option)
+ break;
+
+ if (!request_ip_option)
+ break;
+
+ if (!lease)
+ break;
+
+ if (requested_nip == lease->lease_nip)
+ remove_lease(dhcp_server, lease);
+
+ break;
+ case DHCPRELEASE:
+ debug(dhcp_server, "Received RELEASE");
+
+ if (!server_id_option)
+ break;
+
+ if (!lease)
+ break;
+
+ if (packet.ciaddr == lease->lease_nip)
+ lease_set_expire(dhcp_server, lease,
+ time(NULL));
+ break;
+ case DHCPINFORM:
+ debug(dhcp_server, "Received INFORM");
+ send_inform(dhcp_server, &packet);
+ break;
+ }
+
+ return TRUE;
+}
+
+/* Caller need to load leases before call it */
+int g_dhcp_server_start(GDHCPServer *dhcp_server)
+{
+ GIOChannel *listener_channel;
+ int listener_sockfd;
+
+ if (dhcp_server->started)
+ return 0;
+
+ listener_sockfd = dhcp_l3_socket(SERVER_PORT,
+ dhcp_server->interface, AF_INET);
+ if (listener_sockfd < 0)
+ return -EIO;
+
+ listener_channel = g_io_channel_unix_new(listener_sockfd);
+ if (!listener_channel) {
+ close(listener_sockfd);
+ return -EIO;
+ }
+
+ dhcp_server->listener_sockfd = listener_sockfd;
+ dhcp_server->listener_channel = listener_channel;
+
+ g_io_channel_set_close_on_unref(listener_channel, TRUE);
+ dhcp_server->listener_watch =
+ g_io_add_watch_full(listener_channel, G_PRIORITY_HIGH,
+ G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
+ listener_event, dhcp_server,
+ NULL);
+ g_io_channel_unref(dhcp_server->listener_channel);
+
+ dhcp_server->started = TRUE;
+
+ return 0;
+}
+
+int g_dhcp_server_set_option(GDHCPServer *dhcp_server,
+ unsigned char option_code, const char *option_value)
+{
+ struct in_addr nip;
+
+ if (!option_value)
+ return -EINVAL;
+
+ debug(dhcp_server, "option_code %d option_value %s",
+ option_code, option_value);
+ switch (option_code) {
+ case G_DHCP_SUBNET:
+ case G_DHCP_ROUTER:
+ case G_DHCP_DNS_SERVER:
+ if (inet_aton(option_value, &nip) == 0)
+ return -ENXIO;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ g_hash_table_replace(dhcp_server->option_hash,
+ GINT_TO_POINTER((int) option_code),
+ (gpointer) option_value);
+ return 0;
+}
+
+void g_dhcp_server_set_save_lease(GDHCPServer *dhcp_server,
+ GDHCPSaveLeaseFunc func, gpointer user_data)
+{
+ if (!dhcp_server)
+ return;
+
+ dhcp_server->save_lease_func = func;
+}
+
+void g_dhcp_server_set_lease_added_cb(GDHCPServer *dhcp_server,
+ GDHCPLeaseAddedCb cb)
+{
+ if (!dhcp_server)
+ return;
+
+ dhcp_server->lease_added_cb = cb;
+}
+
+GDHCPServer *g_dhcp_server_ref(GDHCPServer *dhcp_server)
+{
+ if (!dhcp_server)
+ return NULL;
+
+ __sync_fetch_and_add(&dhcp_server->ref_count, 1);
+
+ return dhcp_server;
+}
+
+void g_dhcp_server_stop(GDHCPServer *dhcp_server)
+{
+ /* Save leases, before stop; load them before start */
+ save_lease(dhcp_server);
+
+ if (dhcp_server->listener_watch > 0) {
+ g_source_remove(dhcp_server->listener_watch);
+ dhcp_server->listener_watch = 0;
+ }
+
+ dhcp_server->listener_channel = NULL;
+
+ dhcp_server->started = FALSE;
+}
+
+void g_dhcp_server_unref(GDHCPServer *dhcp_server)
+{
+ if (!dhcp_server)
+ return;
+
+ if (__sync_fetch_and_sub(&dhcp_server->ref_count, 1) != 1)
+ return;
+
+ g_dhcp_server_stop(dhcp_server);
+
+ g_hash_table_destroy(dhcp_server->option_hash);
+
+ destroy_lease_table(dhcp_server);
+
+ g_free(dhcp_server->interface);
+
+ g_free(dhcp_server);
+}
+
+int g_dhcp_server_set_ip_range(GDHCPServer *dhcp_server,
+ const char *start_ip, const char *end_ip)
+{
+ struct in_addr _host_addr;
+
+ if (inet_aton(start_ip, &_host_addr) == 0)
+ return -ENXIO;
+
+ dhcp_server->start_ip = ntohl(_host_addr.s_addr);
+
+ if (inet_aton(end_ip, &_host_addr) == 0)
+ return -ENXIO;
+
+ dhcp_server->end_ip = ntohl(_host_addr.s_addr);
+
+ return 0;
+}
+
+void g_dhcp_server_set_lease_time(GDHCPServer *dhcp_server,
+ unsigned int lease_time)
+{
+ if (!dhcp_server)
+ return;
+
+ dhcp_server->lease_seconds = lease_time;
+}
+
+void g_dhcp_server_set_debug(GDHCPServer *dhcp_server,
+ GDHCPDebugFunc func, gpointer user_data)
+{
+ if (!dhcp_server)
+ return;
+
+ dhcp_server->debug_func = func;
+ dhcp_server->debug_data = user_data;
+}
diff --git a/gdhcp/timer.c b/gdhcp/timer.c
new file mode 100644
index 0000000..38a3552
--- /dev/null
+++ b/gdhcp/timer.c
@@ -0,0 +1,222 @@
+/*
+ * Realtime timer with GLib integration
+ *
+ * Copyright (C) 2014 Nest Labs. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <errno.h>
+
+#include "timer.h"
+
+/*
+ * A GLib custom event source using a POSIX fd timer that becomes
+ * 'ready' on timer expiration. Timer 'advances' across a suspend but
+ * has no ability to bring system out of suspend. Timer will fire upon
+ * resume if expired.
+ */
+
+typedef struct _GRTimeoutSource GRTimeoutSource;
+
+struct _GRTimeoutSource
+{
+ GSource source;
+ GPollFD pfd;
+ guint interval;
+ gpointer tag;
+};
+
+static gboolean g_rttimeout_prepare (GSource *source, gint *timeout);
+static gboolean g_rttimeout_check (GSource *source);
+static gboolean g_rttimeout_dispatch (GSource *source, GSourceFunc callback,
+ gpointer user_data);
+
+GSourceFuncs g_rttimeout_funcs =
+{
+ g_rttimeout_prepare,
+ g_rttimeout_check,
+ g_rttimeout_dispatch,
+ NULL
+};
+
+void g_rttimeout_info(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+ vsyslog(LOG_INFO, format, ap);
+ va_end(ap);
+}
+
+static gboolean g_rttimeout_prepare (GSource *source, gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean g_rttimeout_check (GSource *source)
+{
+ GRTimeoutSource *timeout_source = (GRTimeoutSource *)source;
+
+ return timeout_source->pfd.revents & G_IO_IN;
+}
+
+static gboolean
+g_rttimeout_dispatch (GSource *source, GSourceFunc callback, gpointer user_data)
+{
+ GRTimeoutSource *timeout_source = (GRTimeoutSource *)source;
+ gboolean again;
+
+ g_rttimeout_info("DHCP: %s: fd=%d, source=%p, user_data=%p",
+ __func__, timeout_source->pfd.fd, source, user_data);
+ if (!callback) {
+ g_warning ("GR timeout source dispatched without callback\n"
+ "You must call g_source_set_callback().");
+ if (!g_source_is_destroyed (source)) {
+ g_source_remove_poll (source, &timeout_source->pfd);
+ close(timeout_source->pfd.fd);
+ }
+ return FALSE;
+ }
+
+ again = callback (user_data);
+
+ if (again) {
+ struct itimerspec timer_value;
+ int result;
+
+ /* arm the timer as a single-shot */
+ timer_value.it_value.tv_sec = timeout_source->interval;
+ timer_value.it_value.tv_nsec = 0;
+ timer_value.it_interval.tv_sec = 0;
+ timer_value.it_interval.tv_nsec = 0;
+
+ result = timerfd_settime (timeout_source->pfd.fd, 0,
+ &timer_value, NULL);
+ if (result == -1)
+ g_error ("%s: error calling timer_settime", G_STRLOC);
+ } else {
+ if (!g_source_is_destroyed (source)) {
+ g_source_remove_poll (source, &timeout_source->pfd);
+ close(timeout_source->pfd.fd);
+ }
+ }
+
+ return again;
+}
+
+/**
+ * g_rttimeout_add_seconds_full:
+ */
+guint g_rttimeout_add_seconds_full (gint type, gint priority, guint32 interval,
+ GSourceFunc function, gpointer data,
+ GDestroyNotify notify)
+{
+ return g_rttimeout_add_full(type, priority, interval * 1000,
+ function, data, notify);
+}
+
+/**
+ * g_rttimeout_add_full:
+ */
+guint g_rttimeout_add_full (gint type, gint priority, guint32 interval,
+ GSourceFunc function, gpointer data,
+ GDestroyNotify notify)
+{
+ GSource *source;
+ int fd;
+ guint id;
+ gpointer tag;
+
+ g_return_val_if_fail (function != NULL, 0);
+
+ source = g_source_new (&g_rttimeout_funcs, sizeof (GRTimeoutSource));
+ if (priority != G_PRIORITY_DEFAULT)
+ g_source_set_priority (source, priority);
+ g_source_set_callback (source, function, data, notify);
+ id = g_source_attach (source, NULL);
+ g_source_unref (source);
+
+ fd = timerfd_create(type, 0);
+ if (fd != -1) {
+ GRTimeoutSource *timeout_source = (GRTimeoutSource *)source;
+ struct itimerspec timer_value;
+ int result;
+
+ g_rttimeout_info("DHCP: %s: id=%d fd=%d, source=%p, seconds=%d",
+ __func__, id, fd, source, interval/1000);
+ memset(&timer_value, 0, sizeof(struct itimerspec));
+
+ timer_value.it_value.tv_sec = interval / 1000;
+ timer_value.it_value.tv_nsec = (interval % 1000) * 1000000;
+
+ /* arm the timer as a single-shot */
+ result = timerfd_settime (fd, 0, &timer_value,
+ NULL);
+ if (result != -1) {
+ timeout_source->interval = interval;
+ timeout_source->pfd.fd = fd;
+ timeout_source->pfd.events = G_IO_IN;
+
+ tag = g_source_add_unix_fd(source, fd, G_IO_IN);
+
+ if (tag != NULL) {
+ timeout_source->tag = tag;
+ } else {
+ g_rttimeout_info("DHCP: %s: cannot attach fd to source\n", __func__);
+ g_error ("%s: error calling g_source_add_unix_fd", G_STRLOC);
+ }
+ } else {
+ g_rttimeout_info("DHCP: %s: error timerfd_settime, err=%d\n",
+ __func__, errno);
+ g_error ("%s: error calling timerfd_settime", G_STRLOC);
+ }
+ } else {
+ g_error ("%s: error calling timerfd_create (type=%d err=%d)", G_STRLOC, type, errno);
+ }
+
+ return id;
+}
+
+gboolean g_rttimeout_source_remove(guint id)
+{
+ GSource *source;
+
+ g_return_val_if_fail (id > 0, FALSE);
+ source = g_main_context_find_source_by_id (NULL, id);
+ if (source) {
+ GRTimeoutSource *timeout_source = (GRTimeoutSource *)source;
+
+ if (!g_source_is_destroyed (source)) {
+ g_rttimeout_info("DHCP: %s: id=%d fd=%d source=%p",
+ __func__, id, timeout_source->pfd.fd,
+ source);
+ g_source_remove_unix_fd(source, timeout_source->tag);
+ close(timeout_source->pfd.fd);
+ g_source_destroy (source);
+ }
+ } else {
+ g_rttimeout_info("DHCP: %s: id=%d not found", __func__, id);
+ }
+
+ return source != NULL;
+}
diff --git a/gdhcp/timer.h b/gdhcp/timer.h
new file mode 100644
index 0000000..2c7085b
--- /dev/null
+++ b/gdhcp/timer.h
@@ -0,0 +1,36 @@
+/*
+ *
+ * Realtime timer with GLib integration
+ *
+ * Copyright (C) 2014 Nest Labs. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#include <sys/timerfd.h>
+#include <glib.h>
+
+#define G_CLOCK_REALTIME CLOCK_REALTIME
+/* if your kernel supports */
+/* #define G_CLOCK_BOOTTIME CLOCK_BOOTTIME */
+
+guint g_rttimeout_add_seconds_full (gint type, gint priority, guint32 interval,
+ GSourceFunc function, gpointer data,
+ GDestroyNotify notify);
+
+guint g_rttimeout_add_full (gint type, gint priority, guint32 interval,
+ GSourceFunc function, gpointer data,
+ GDestroyNotify notify);
+
+gboolean g_rttimeout_source_remove(guint id);
diff --git a/gdhcp/unaligned.h b/gdhcp/unaligned.h
new file mode 100644
index 0000000..ffdaae2
--- /dev/null
+++ b/gdhcp/unaligned.h
@@ -0,0 +1,163 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <endian.h>
+#include <byteswap.h>
+
+#define get_unaligned(ptr) \
+({ \
+ struct __attribute__((packed)) { \
+ typeof(*(ptr)) __v; \
+ } *__p = (typeof(__p)) (ptr); \
+ __p->__v; \
+})
+
+#define put_unaligned(val, ptr) \
+do { \
+ struct __attribute__((packed)) { \
+ typeof(*(ptr)) __v; \
+ } *__p = (typeof(__p)) (ptr); \
+ __p->__v = (val); \
+} while(0)
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+static inline uint64_t get_le64(const void *ptr)
+{
+ return get_unaligned((const uint64_t *) ptr);
+}
+
+static inline uint64_t get_be64(const void *ptr)
+{
+ return bswap_64(get_unaligned((const uint64_t *) ptr));
+}
+
+static inline uint32_t get_le32(const void *ptr)
+{
+ return get_unaligned((const uint32_t *) ptr);
+}
+
+static inline uint32_t get_be32(const void *ptr)
+{
+ return bswap_32(get_unaligned((const uint32_t *) ptr));
+}
+
+static inline uint16_t get_le16(const void *ptr)
+{
+ return get_unaligned((const uint16_t *) ptr);
+}
+
+static inline uint16_t get_be16(const void *ptr)
+{
+ return bswap_16(get_unaligned((const uint16_t *) ptr));
+}
+
+static inline void put_be16(uint16_t val, void *ptr)
+{
+ put_unaligned(bswap_16(val), (uint16_t *) ptr);
+}
+
+static inline void put_be32(uint32_t val, void *ptr)
+{
+ put_unaligned(bswap_32(val), (uint32_t *) ptr);
+}
+
+static inline void put_le16(uint16_t val, void *ptr)
+{
+ put_unaligned(val, (uint16_t *) ptr);
+}
+
+static inline void put_le32(uint32_t val, void *ptr)
+{
+ put_unaligned(val, (uint32_t *) ptr);
+}
+
+static inline void put_be64(uint64_t val, void *ptr)
+{
+ put_unaligned(bswap_64(val), (uint64_t *) ptr);
+}
+
+static inline void put_le64(uint64_t val, void *ptr)
+{
+ put_unaligned(val, (uint64_t *) ptr);
+}
+#elif __BYTE_ORDER == __BIG_ENDIAN
+static inline uint64_t get_le64(const void *ptr)
+{
+ return bswap_64(get_unaligned((const uint64_t *) ptr));
+}
+
+static inline uint64_t get_be64(const void *ptr)
+{
+ return get_unaligned((const uint64_t *) ptr);
+}
+
+static inline uint32_t get_le32(const void *ptr)
+{
+ return bswap_32(get_unaligned((const uint32_t *) ptr));
+}
+
+static inline uint32_t get_be32(const void *ptr)
+{
+ return get_unaligned((const uint32_t *) ptr);
+}
+
+static inline uint16_t get_le16(const void *ptr)
+{
+ return bswap_16(get_unaligned((const uint16_t *) ptr));
+}
+
+static inline uint16_t get_be16(const void *ptr)
+{
+ return get_unaligned((const uint16_t *) ptr);
+}
+
+static inline void put_be16(uint16_t val, void *ptr)
+{
+ put_unaligned(val, (uint16_t *) ptr);
+}
+
+static inline void put_be32(uint32_t val, void *ptr)
+{
+ put_unaligned(val, (uint32_t *) ptr);
+}
+
+static inline void put_le16(uint16_t val, void *ptr)
+{
+ put_unaligned(bswap_16(val), (uint16_t *) ptr);
+}
+
+static inline void put_le32(uint32_t val, void *ptr)
+{
+ put_unaligned(bswap_32(val), (uint32_t *) ptr);
+}
+
+static inline void put_be64(uint64_t val, void *ptr)
+{
+ put_unaligned(val, (uint64_t *) ptr);
+}
+
+static inline void put_le64(uint64_t val, void *ptr)
+{
+ put_unaligned(bswap_64(val), (uint64_t *) ptr);
+}
+#else
+#error "Unknown byte order"
+#endif
diff --git a/gsupplicant/dbus.c b/gsupplicant/dbus.c
new file mode 100644
index 0000000..cb2aace
--- /dev/null
+++ b/gsupplicant/dbus.c
@@ -0,0 +1,651 @@
+/*
+ *
+ * WPA supplicant library with GLib integration
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dbus/dbus.h>
+#include <glib.h>
+
+#include "dbus.h"
+
+#define TIMEOUT 30000
+
+static DBusConnection *connection;
+
+static GSList *method_calls;
+
+struct method_call_data {
+ gpointer caller;
+ DBusPendingCall *pending_call;
+ supplicant_dbus_result_function function;
+ void *user_data;
+};
+
+static void method_call_free(void *pointer)
+{
+ struct method_call_data *method_call = pointer;
+ method_calls = g_slist_remove(method_calls, method_call);
+ g_free(method_call);
+}
+
+static int find_method_call_by_caller(gconstpointer a, gconstpointer b)
+{
+ const struct method_call_data *method_call = a;
+ gconstpointer caller = b;
+
+ return method_call->caller != caller;
+}
+
+static GSList *property_calls;
+
+struct property_call_data {
+ gpointer caller;
+ DBusPendingCall *pending_call;
+ supplicant_dbus_property_function function;
+ void *user_data;
+};
+
+static void property_call_free(void *pointer)
+{
+ struct property_call_data *property_call = pointer;
+ property_calls = g_slist_remove(property_calls, property_call);
+ g_free(property_call);
+}
+
+static int find_property_call_by_caller(gconstpointer a, gconstpointer b)
+{
+ const struct property_call_data *property_call = a;
+ gconstpointer caller = b;
+
+ return property_call->caller != caller;
+}
+
+void supplicant_dbus_setup(DBusConnection *conn)
+{
+ connection = conn;
+ method_calls = NULL;
+ property_calls = NULL;
+}
+
+void supplicant_dbus_array_foreach(DBusMessageIter *iter,
+ supplicant_dbus_array_function function,
+ void *user_data)
+{
+ DBusMessageIter entry;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_INVALID) {
+ if (function)
+ function(&entry, user_data);
+
+ dbus_message_iter_next(&entry);
+ }
+}
+
+void supplicant_dbus_property_foreach(DBusMessageIter *iter,
+ supplicant_dbus_property_function function,
+ void *user_data)
+{
+ DBusMessageIter dict;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return;
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return;
+
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (key) {
+ if (strcmp(key, "Properties") == 0)
+ supplicant_dbus_property_foreach(&value,
+ function, user_data);
+ else if (function)
+ function(key, &value, user_data);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+}
+
+void supplicant_dbus_property_call_cancel_all(gpointer caller)
+{
+ while (property_calls) {
+ struct property_call_data *property_call;
+ GSList *elem = g_slist_find_custom(property_calls, caller,
+ find_property_call_by_caller);
+ if (!elem)
+ break;
+
+ property_call = elem->data;
+ property_calls = g_slist_delete_link(property_calls, elem);
+
+ dbus_pending_call_cancel(property_call->pending_call);
+
+ dbus_pending_call_unref(property_call->pending_call);
+ }
+}
+
+static void property_get_all_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_call_data *property_call = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ goto done;
+
+ if (!dbus_message_iter_init(reply, &iter))
+ goto done;
+
+ supplicant_dbus_property_foreach(&iter, property_call->function,
+ property_call->user_data);
+
+ if (property_call->function)
+ property_call->function(NULL, NULL, property_call->user_data);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_property_get_all(const char *path, const char *interface,
+ supplicant_dbus_property_function function,
+ void *user_data, gpointer caller)
+{
+ struct property_call_data *property_call = NULL;
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface)
+ return -EINVAL;
+
+ property_call = g_try_new0(struct property_call_data, 1);
+ if (!property_call)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ DBUS_INTERFACE_PROPERTIES, "GetAll");
+ if (!message) {
+ g_free(property_call);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &interface, NULL);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ g_free(property_call);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ g_free(property_call);
+ return -EIO;
+ }
+
+ property_call->caller = caller;
+ property_call->pending_call = call;
+ property_call->function = function;
+ property_call->user_data = user_data;
+
+ property_calls = g_slist_prepend(property_calls, property_call);
+
+ dbus_pending_call_set_notify(call, property_get_all_reply,
+ property_call, property_call_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+static void property_get_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_call_data *property_call = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ goto done;
+
+ if (!dbus_message_iter_init(reply, &iter))
+ goto done;
+
+ if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_VARIANT) {
+ DBusMessageIter variant;
+
+ dbus_message_iter_recurse(&iter, &variant);
+
+ if (property_call->function)
+ property_call->function(NULL, &variant,
+ property_call->user_data);
+ }
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_property_get(const char *path, const char *interface,
+ const char *method,
+ supplicant_dbus_property_function function,
+ void *user_data, gpointer caller)
+{
+ struct property_call_data *property_call = NULL;
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface || !method)
+ return -EINVAL;
+
+ property_call = g_try_new0(struct property_call_data, 1);
+ if (!property_call)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ DBUS_INTERFACE_PROPERTIES, "Get");
+
+ if (!message) {
+ g_free(property_call);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &method, NULL);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ g_free(property_call);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ g_free(property_call);
+ return -EIO;
+ }
+
+ property_call->caller = caller;
+ property_call->pending_call = call;
+ property_call->function = function;
+ property_call->user_data = user_data;
+
+ property_calls = g_slist_prepend(property_calls, property_call);
+
+ dbus_pending_call_set_notify(call, property_get_reply,
+ property_call, property_call_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+static void property_set_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_call_data *property_call = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ const char *error;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ error = dbus_message_get_error_name(reply);
+ else
+ error = NULL;
+
+ dbus_message_iter_init(reply, &iter);
+
+ if (property_call->function)
+ property_call->function(error, &iter, property_call->user_data);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_property_set(const char *path, const char *interface,
+ const char *key, const char *signature,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data, gpointer caller)
+{
+ struct property_call_data *property_call = NULL;
+ DBusMessage *message;
+ DBusMessageIter iter, value;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface)
+ return -EINVAL;
+
+ if (!key || !signature || !setup)
+ return -EINVAL;
+
+ property_call = g_try_new0(struct property_call_data, 1);
+ if (!property_call)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ DBUS_INTERFACE_PROPERTIES, "Set");
+ if (!message) {
+ g_free(property_call);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_iter_init_append(message, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &interface);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ signature, &value);
+ setup(&value, user_data);
+ dbus_message_iter_close_container(&iter, &value);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ g_free(property_call);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ g_free(property_call);
+ return -EIO;
+ }
+
+ property_call->caller = caller;
+ property_call->pending_call = call;
+ property_call->function = function;
+ property_call->user_data = user_data;
+
+ property_calls = g_slist_prepend(property_calls, property_call);
+
+ dbus_pending_call_set_notify(call, property_set_reply,
+ property_call, property_call_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+void supplicant_dbus_method_call_cancel_all(gpointer caller)
+{
+ while (method_calls) {
+ struct method_call_data *method_call;
+ GSList *elem = g_slist_find_custom(method_calls, caller,
+ find_method_call_by_caller);
+ if (!elem)
+ break;
+
+ method_call = elem->data;
+ method_calls = g_slist_delete_link(method_calls, elem);
+
+ dbus_pending_call_cancel(method_call->pending_call);
+
+ if (method_call->function)
+ method_call->function("net.connman.Error.OperationAborted",
+ NULL, method_call->user_data);
+
+ dbus_pending_call_unref(method_call->pending_call);
+ }
+}
+
+static void method_call_reply(DBusPendingCall *call, void *user_data)
+{
+ struct method_call_data *method_call = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ const char *error;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ error = dbus_message_get_error_name(reply);
+ else
+ error = NULL;
+
+ dbus_message_iter_init(reply, &iter);
+
+ if (method_call && method_call->function)
+ method_call->function(error, &iter, method_call->user_data);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_method_call(const char *path,
+ const char *interface, const char *method,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data,
+ gpointer caller)
+{
+ struct method_call_data *method_call = NULL;
+ DBusMessage *message;
+ DBusMessageIter iter;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface || !method)
+ return -EINVAL;
+
+ method_call = g_try_new0(struct method_call_data, 1);
+ if (!method_call)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ interface, method);
+ if (!message) {
+ g_free(method_call);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_iter_init_append(message, &iter);
+ if (setup)
+ setup(&iter, user_data);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ g_free(method_call);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ g_free(method_call);
+ return -EIO;
+ }
+
+ method_call->caller = caller;
+ method_call->pending_call = call;
+ method_call->function = function;
+ method_call->user_data = user_data;
+ method_calls = g_slist_prepend(method_calls, method_call);
+
+ dbus_pending_call_set_notify(call, method_call_reply, method_call,
+ method_call_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+
+}
+
+void supplicant_dbus_property_append_basic(DBusMessageIter *iter,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter value;
+ const char *signature;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ switch (type) {
+ case DBUS_TYPE_BOOLEAN:
+ signature = DBUS_TYPE_BOOLEAN_AS_STRING;
+ break;
+ case DBUS_TYPE_STRING:
+ signature = DBUS_TYPE_STRING_AS_STRING;
+ break;
+ case DBUS_TYPE_BYTE:
+ signature = DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT16:
+ signature = DBUS_TYPE_UINT16_AS_STRING;
+ break;
+ case DBUS_TYPE_INT16:
+ signature = DBUS_TYPE_INT16_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT32:
+ signature = DBUS_TYPE_UINT32_AS_STRING;
+ break;
+ case DBUS_TYPE_INT32:
+ signature = DBUS_TYPE_INT32_AS_STRING;
+ break;
+ case DBUS_TYPE_OBJECT_PATH:
+ signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ break;
+ default:
+ signature = DBUS_TYPE_VARIANT_AS_STRING;
+ break;
+ }
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ signature, &value);
+ dbus_message_iter_append_basic(&value, type, val);
+ dbus_message_iter_close_container(iter, &value);
+}
+
+void supplicant_dbus_property_append_fixed_array(DBusMessageIter *iter,
+ const char *key, int type, void *val, int len)
+{
+ DBusMessageIter value, array;
+ const char *variant_sig, *array_sig;
+
+ switch (type) {
+ case DBUS_TYPE_BYTE:
+ variant_sig = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_BYTE_AS_STRING;
+ array_sig = DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ default:
+ return;
+ }
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ variant_sig, &value);
+
+ dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
+ array_sig, &array);
+ dbus_message_iter_append_fixed_array(&array, type, val, len);
+ dbus_message_iter_close_container(&value, &array);
+
+ dbus_message_iter_close_container(iter, &value);
+}
+
+void supplicant_dbus_property_append_array(DBusMessageIter *iter,
+ const char *key, int type,
+ supplicant_dbus_array_function function,
+ void *user_data)
+{
+ DBusMessageIter value, array;
+ const char *variant_sig, *array_sig;
+
+ switch (type) {
+ case DBUS_TYPE_STRING:
+ case DBUS_TYPE_BYTE:
+ variant_sig = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_BYTE_AS_STRING;
+ array_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ default:
+ return;
+ }
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ variant_sig, &value);
+
+ dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
+ array_sig, &array);
+ if (function)
+ function(&array, user_data);
+
+ dbus_message_iter_close_container(&value, &array);
+
+ dbus_message_iter_close_container(iter, &value);
+}
diff --git a/gsupplicant/dbus.h b/gsupplicant/dbus.h
new file mode 100644
index 0000000..3a90406
--- /dev/null
+++ b/gsupplicant/dbus.h
@@ -0,0 +1,138 @@
+/*
+ *
+ * WPA supplicant library with GLib integration
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <dbus/dbus.h>
+
+#define SUPPLICANT_SERVICE "fi.w1.wpa_supplicant1"
+#define SUPPLICANT_INTERFACE "fi.w1.wpa_supplicant1"
+#define SUPPLICANT_PATH "/fi/w1/wpa_supplicant1"
+
+typedef void (*supplicant_dbus_array_function) (DBusMessageIter *iter,
+ void *user_data);
+
+typedef void (*supplicant_dbus_property_function) (const char *key,
+ DBusMessageIter *iter, void *user_data);
+
+typedef void (*supplicant_dbus_setup_function) (DBusMessageIter *iter,
+ void *user_data);
+
+typedef void (*supplicant_dbus_result_function) (const char *error,
+ DBusMessageIter *iter, void *user_data);
+
+void supplicant_dbus_property_append_array(DBusMessageIter *iter,
+ const char *key, int type,
+ supplicant_dbus_array_function function,
+ void *user_data);
+
+void supplicant_dbus_setup(DBusConnection *conn);
+
+void supplicant_dbus_array_foreach(DBusMessageIter *iter,
+ supplicant_dbus_array_function function,
+ void *user_data);
+
+void supplicant_dbus_property_foreach(DBusMessageIter *iter,
+ supplicant_dbus_property_function function,
+ void *user_data);
+
+int supplicant_dbus_property_get_all(const char *path, const char *interface,
+ supplicant_dbus_property_function function,
+ void *user_data, gpointer caller);
+
+int supplicant_dbus_property_get(const char *path, const char *interface,
+ const char *method,
+ supplicant_dbus_property_function function,
+ void *user_data, gpointer caller);
+
+int supplicant_dbus_property_set(const char *path, const char *interface,
+ const char *key, const char *signature,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data, gpointer caller);
+
+void supplicant_dbus_property_call_cancel_all(gpointer caller);
+
+int supplicant_dbus_method_call(const char *path,
+ const char *interface, const char *method,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data,
+ gpointer caller);
+
+void supplicant_dbus_method_call_cancel_all(gpointer caller);
+
+void supplicant_dbus_property_append_basic(DBusMessageIter *iter,
+ const char *key, int type, void *val);
+
+void supplicant_dbus_property_append_fixed_array(DBusMessageIter *iter,
+ const char *key, int type, void *val, int len);
+
+static inline void supplicant_dbus_dict_open(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, dict);
+}
+
+static inline void supplicant_dbus_dict_close(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_close_container(iter, dict);
+}
+
+static inline void supplicant_dbus_dict_append_basic(DBusMessageIter *dict,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ supplicant_dbus_property_append_basic(&entry, key, type, val);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+static inline void
+supplicant_dbus_dict_append_fixed_array(DBusMessageIter *dict,
+ const char *key, int type, void *val, int len)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ supplicant_dbus_property_append_fixed_array(&entry, key, type, val, len);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+static inline void
+supplicant_dbus_dict_append_array(DBusMessageIter *dict,
+ const char *key, int type,
+ supplicant_dbus_array_function function,
+ void *user_data)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ supplicant_dbus_property_append_array(&entry, key, type,
+ function, user_data);
+ dbus_message_iter_close_container(dict, &entry);
+}
diff --git a/gsupplicant/gsupplicant.h b/gsupplicant/gsupplicant.h
new file mode 100644
index 0000000..62585c2
--- /dev/null
+++ b/gsupplicant/gsupplicant.h
@@ -0,0 +1,376 @@
+/*
+ *
+ * WPA supplicant library with GLib integration
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#ifndef __G_SUPPLICANT_H
+#define __G_SUPPLICANT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define G_SUPPLICANT_EAP_METHOD_MD5 (1 << 0)
+#define G_SUPPLICANT_EAP_METHOD_TLS (1 << 1)
+#define G_SUPPLICANT_EAP_METHOD_MSCHAPV2 (1 << 2)
+#define G_SUPPLICANT_EAP_METHOD_PEAP (1 << 3)
+#define G_SUPPLICANT_EAP_METHOD_TTLS (1 << 4)
+#define G_SUPPLICANT_EAP_METHOD_GTC (1 << 5)
+#define G_SUPPLICANT_EAP_METHOD_OTP (1 << 6)
+#define G_SUPPLICANT_EAP_METHOD_LEAP (1 << 7)
+#define G_SUPPLICANT_EAP_METHOD_WSC (1 << 8)
+
+#define G_SUPPLICANT_CAPABILITY_AUTHALG_OPEN (1 << 0)
+#define G_SUPPLICANT_CAPABILITY_AUTHALG_SHARED (1 << 1)
+#define G_SUPPLICANT_CAPABILITY_AUTHALG_LEAP (1 << 2)
+
+#define G_SUPPLICANT_CAPABILITY_PROTO_WPA (1 << 0)
+#define G_SUPPLICANT_CAPABILITY_PROTO_RSN (1 << 1)
+
+#define G_SUPPLICANT_CAPABILITY_SCAN_ACTIVE (1 << 0)
+#define G_SUPPLICANT_CAPABILITY_SCAN_PASSIVE (1 << 1)
+#define G_SUPPLICANT_CAPABILITY_SCAN_SSID (1 << 2)
+
+#define G_SUPPLICANT_CAPABILITY_MODE_INFRA (1 << 0)
+#define G_SUPPLICANT_CAPABILITY_MODE_IBSS (1 << 1)
+#define G_SUPPLICANT_CAPABILITY_MODE_AP (1 << 2)
+#define G_SUPPLICANT_CAPABILITY_MODE_P2P (1 << 3)
+
+#define G_SUPPLICANT_KEYMGMT_NONE (1 << 0)
+#define G_SUPPLICANT_KEYMGMT_IEEE8021X (1 << 1)
+#define G_SUPPLICANT_KEYMGMT_WPA_NONE (1 << 2)
+#define G_SUPPLICANT_KEYMGMT_WPA_PSK (1 << 3)
+#define G_SUPPLICANT_KEYMGMT_WPA_PSK_256 (1 << 4)
+#define G_SUPPLICANT_KEYMGMT_WPA_FT_PSK (1 << 5)
+#define G_SUPPLICANT_KEYMGMT_WPA_FT_EAP (1 << 6)
+#define G_SUPPLICANT_KEYMGMT_WPA_EAP (1 << 7)
+#define G_SUPPLICANT_KEYMGMT_WPA_EAP_256 (1 << 8)
+#define G_SUPPLICANT_KEYMGMT_WPS (1 << 9)
+
+#define G_SUPPLICANT_PROTO_WPA (1 << 0)
+#define G_SUPPLICANT_PROTO_RSN (1 << 1)
+
+#define G_SUPPLICANT_GROUP_WEP40 (1 << 0)
+#define G_SUPPLICANT_GROUP_WEP104 (1 << 1)
+#define G_SUPPLICANT_GROUP_TKIP (1 << 2)
+#define G_SUPPLICANT_GROUP_CCMP (1 << 3)
+
+#define G_SUPPLICANT_PAIRWISE_NONE (1 << 0)
+#define G_SUPPLICANT_PAIRWISE_TKIP (1 << 1)
+#define G_SUPPLICANT_PAIRWISE_CCMP (1 << 2)
+
+#define G_SUPPLICANT_WPS_CONFIGURED (1 << 0)
+#define G_SUPPLICANT_WPS_PBC (1 << 1)
+#define G_SUPPLICANT_WPS_PIN (1 << 2)
+#define G_SUPPLICANT_WPS_REGISTRAR (1 << 3)
+
+#define G_SUPPLICANT_WPS_CONFIG_PBC 0x0080
+
+#define G_SUPPLICANT_GROUP_ROLE_CLIENT (1 << 0)
+#define G_SUPPLICANT_GROUP_ROLE_GO (1 << 1)
+
+typedef enum {
+ G_SUPPLICANT_MODE_UNKNOWN,
+ G_SUPPLICANT_MODE_INFRA,
+ G_SUPPLICANT_MODE_IBSS,
+ G_SUPPLICANT_MODE_MASTER,
+} GSupplicantMode;
+
+typedef enum {
+ G_SUPPLICANT_SECURITY_UNKNOWN,
+ G_SUPPLICANT_SECURITY_NONE,
+ G_SUPPLICANT_SECURITY_WEP,
+ G_SUPPLICANT_SECURITY_PSK,
+ G_SUPPLICANT_SECURITY_IEEE8021X,
+} GSupplicantSecurity;
+
+typedef enum {
+ G_SUPPLICANT_STATE_UNKNOWN,
+ G_SUPPLICANT_STATE_DISABLED,
+ G_SUPPLICANT_STATE_DISCONNECTED,
+ G_SUPPLICANT_STATE_INACTIVE,
+ G_SUPPLICANT_STATE_SCANNING,
+ G_SUPPLICANT_STATE_AUTHENTICATING,
+ G_SUPPLICANT_STATE_ASSOCIATING,
+ G_SUPPLICANT_STATE_ASSOCIATED,
+ G_SUPPLICANT_STATE_4WAY_HANDSHAKE,
+ G_SUPPLICANT_STATE_GROUP_HANDSHAKE,
+ G_SUPPLICANT_STATE_COMPLETED,
+} GSupplicantState;
+
+typedef enum {
+ G_SUPPLICANT_WPS_STATE_UNKNOWN,
+ G_SUPPLICANT_WPS_STATE_SUCCESS,
+ G_SUPPLICANT_WPS_STATE_FAIL,
+} GSupplicantWpsState;
+
+typedef enum {
+ G_SUPPLICANT_PEER_SERVICES_CHANGED,
+ G_SUPPLICANT_PEER_GROUP_CHANGED,
+ G_SUPPLICANT_PEER_GROUP_STARTED,
+ G_SUPPLICANT_PEER_GROUP_FINISHED,
+ G_SUPPLICANT_PEER_GROUP_JOINED,
+ G_SUPPLICANT_PEER_GROUP_DISCONNECTED,
+ G_SUPPLICANT_PEER_GROUP_FAILED,
+} GSupplicantPeerState;
+
+struct _GSupplicantSSID {
+ const void *ssid;
+ unsigned int ssid_len;
+ unsigned int scan_ssid;
+ GSupplicantMode mode;
+ GSupplicantSecurity security;
+ unsigned int protocol;
+ unsigned int pairwise_cipher;
+ unsigned int group_cipher;
+ unsigned int freq;
+ const char *eap;
+ const char *passphrase;
+ const char *identity;
+ const char *ca_cert_path;
+ const char *client_cert_path;
+ const char *private_key_path;
+ const char *private_key_passphrase;
+ const char *phase2_auth;
+ dbus_bool_t use_wps;
+ const char *pin_wps;
+ const char *bgscan;
+};
+
+typedef struct _GSupplicantSSID GSupplicantSSID;
+
+struct scan_ssid {
+ unsigned char ssid[32];
+ uint8_t ssid_len;
+};
+
+struct _GSupplicantScanParams {
+ GSList *ssids;
+
+ uint8_t num_ssids;
+
+ uint8_t num_freqs;
+ uint16_t *freqs;
+};
+
+typedef struct _GSupplicantScanParams GSupplicantScanParams;
+
+struct _GSupplicantPeerParams {
+ bool master;
+ char *wps_pin;
+ char *path;
+};
+
+typedef struct _GSupplicantPeerParams GSupplicantPeerParams;
+
+struct _GSupplicantP2PServiceParams {
+ int version;
+ char *service;
+ unsigned char *query;
+ int query_length;
+ unsigned char *response;
+ int response_length;
+ unsigned char *wfd_ies;
+ int wfd_ies_length;
+};
+
+typedef struct _GSupplicantP2PServiceParams GSupplicantP2PServiceParams;
+
+/* global API */
+typedef void (*GSupplicantCountryCallback) (int result,
+ const char *alpha2,
+ void *user_data);
+
+int g_supplicant_set_country(const char *alpha2,
+ GSupplicantCountryCallback callback,
+ const void *user_data);
+
+/* Interface API */
+struct _GSupplicantInterface;
+struct _GSupplicantPeer;
+
+typedef struct _GSupplicantInterface GSupplicantInterface;
+typedef struct _GSupplicantPeer GSupplicantPeer;
+
+typedef void (*GSupplicantInterfaceCallback) (int result,
+ GSupplicantInterface *interface,
+ void *user_data);
+
+void g_supplicant_interface_cancel(GSupplicantInterface *interface);
+
+int g_supplicant_interface_create(const char *ifname, const char *driver,
+ const char *bridge,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+int g_supplicant_interface_remove(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+int g_supplicant_interface_scan(GSupplicantInterface *interface,
+ GSupplicantScanParams *scan_data,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+
+int g_supplicant_interface_p2p_find(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+
+int g_supplicant_interface_p2p_stop_find(GSupplicantInterface *interface);
+
+int g_supplicant_interface_p2p_connect(GSupplicantInterface *interface,
+ GSupplicantPeerParams *peer_params,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+
+int g_supplicant_interface_p2p_disconnect(GSupplicantInterface *interface,
+ GSupplicantPeerParams *peer_params);
+
+int g_supplicant_interface_p2p_listen(GSupplicantInterface *interface,
+ int period, int interval);
+
+int g_supplicant_interface_p2p_add_service(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ GSupplicantP2PServiceParams *p2p_service_params,
+ void *user_data);
+
+int g_supplicant_interface_p2p_del_service(GSupplicantInterface *interface,
+ GSupplicantP2PServiceParams *p2p_service_params);
+
+int g_supplicant_set_widi_ies(GSupplicantP2PServiceParams *p2p_service_params,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+
+int g_supplicant_interface_connect(GSupplicantInterface *interface,
+ GSupplicantSSID *ssid,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+
+int g_supplicant_interface_disconnect(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ void *user_data);
+
+int g_supplicant_interface_set_apscan(GSupplicantInterface *interface,
+ unsigned int ap_scan);
+
+void g_supplicant_interface_set_data(GSupplicantInterface *interface,
+ void *data);
+void *g_supplicant_interface_get_data(GSupplicantInterface *interface);
+const char *g_supplicant_interface_get_ifname(GSupplicantInterface *interface);
+const char *g_supplicant_interface_get_driver(GSupplicantInterface *interface);
+GSupplicantState g_supplicant_interface_get_state(GSupplicantInterface *interface);
+const char *g_supplicant_interface_get_wps_key(GSupplicantInterface *interface);
+const void *g_supplicant_interface_get_wps_ssid(GSupplicantInterface *interface,
+ unsigned int *ssid_len);
+GSupplicantWpsState g_supplicant_interface_get_wps_state(GSupplicantInterface *interface);
+unsigned int g_supplicant_interface_get_mode(GSupplicantInterface *interface);
+dbus_bool_t g_supplicant_interface_get_ready(GSupplicantInterface *interface);
+unsigned int g_supplicant_interface_get_max_scan_ssids(
+ GSupplicantInterface *interface);
+
+int g_supplicant_interface_enable_selected_network(GSupplicantInterface *interface,
+ dbus_bool_t enable);
+int g_supplicant_interface_set_country(GSupplicantInterface *interface,
+ GSupplicantCountryCallback callback,
+ const char *alpha2,
+ void *user_data);
+bool g_supplicant_interface_has_p2p(GSupplicantInterface *interface);
+int g_supplicant_interface_set_p2p_device_config(GSupplicantInterface *interface,
+ const char *device_name,
+ const char *primary_dev_type);
+GSupplicantPeer *g_supplicant_interface_peer_lookup(GSupplicantInterface *interface,
+ const char *identifier);
+bool g_supplicant_interface_is_p2p_finding(GSupplicantInterface *interface);
+
+/* Network and Peer API */
+struct _GSupplicantNetwork;
+struct _GSupplicantGroup;
+
+typedef struct _GSupplicantNetwork GSupplicantNetwork;
+typedef struct _GSupplicantGroup GSupplicantGroup;
+
+GSupplicantInterface *g_supplicant_network_get_interface(GSupplicantNetwork *network);
+const char *g_supplicant_network_get_name(GSupplicantNetwork *network);
+const char *g_supplicant_network_get_identifier(GSupplicantNetwork *network);
+const char *g_supplicant_network_get_path(GSupplicantNetwork *network);
+const void *g_supplicant_network_get_ssid(GSupplicantNetwork *network,
+ unsigned int *ssid_len);
+const char *g_supplicant_network_get_mode(GSupplicantNetwork *network);
+const char *g_supplicant_network_get_security(GSupplicantNetwork *network);
+dbus_int16_t g_supplicant_network_get_signal(GSupplicantNetwork *network);
+dbus_uint16_t g_supplicant_network_get_frequency(GSupplicantNetwork *network);
+dbus_bool_t g_supplicant_network_get_wps(GSupplicantNetwork *network);
+dbus_bool_t g_supplicant_network_is_wps_active(GSupplicantNetwork *network);
+dbus_bool_t g_supplicant_network_is_wps_pbc(GSupplicantNetwork *network);
+dbus_bool_t g_supplicant_network_is_wps_advertizing(GSupplicantNetwork *network);
+
+GSupplicantInterface *g_supplicant_peer_get_interface(GSupplicantPeer *peer);
+const char *g_supplicant_peer_get_path(GSupplicantPeer *peer);
+const char *g_supplicant_peer_get_identifier(GSupplicantPeer *peer);
+const void *g_supplicant_peer_get_device_address(GSupplicantPeer *peer);
+const void *g_supplicant_peer_get_iface_address(GSupplicantPeer *peer);
+const char *g_supplicant_peer_get_name(GSupplicantPeer *peer);
+const unsigned char *g_supplicant_peer_get_widi_ies(GSupplicantPeer *peer,
+ int *length);
+bool g_supplicant_peer_is_wps_pbc(GSupplicantPeer *peer);
+bool g_supplicant_peer_is_wps_pin(GSupplicantPeer *peer);
+bool g_supplicant_peer_is_in_a_group(GSupplicantPeer *peer);
+GSupplicantInterface *g_supplicant_peer_get_group_interface(GSupplicantPeer *peer);
+bool g_supplicant_peer_is_client(GSupplicantPeer *peer);
+bool g_supplicant_peer_has_requested_connection(GSupplicantPeer *peer);
+
+struct _GSupplicantCallbacks {
+ void (*system_ready) (void);
+ void (*system_killed) (void);
+ void (*interface_added) (GSupplicantInterface *interface);
+ void (*interface_state) (GSupplicantInterface *interface);
+ void (*interface_removed) (GSupplicantInterface *interface);
+ void (*p2p_support) (GSupplicantInterface *interface);
+ void (*scan_started) (GSupplicantInterface *interface);
+ void (*scan_finished) (GSupplicantInterface *interface);
+ void (*ap_create_fail) (GSupplicantInterface *interface);
+ void (*network_added) (GSupplicantNetwork *network);
+ void (*network_removed) (GSupplicantNetwork *network);
+ void (*network_changed) (GSupplicantNetwork *network,
+ const char *property);
+ void (*peer_found) (GSupplicantPeer *peer);
+ void (*peer_lost) (GSupplicantPeer *peer);
+ void (*peer_changed) (GSupplicantPeer *peer,
+ GSupplicantPeerState state);
+ void (*peer_request) (GSupplicantPeer *peer);
+ void (*debug) (const char *str);
+ void (*update_disconnect_reasoncode)(GSupplicantInterface *interface, int reasoncode);
+ void (*update_assoc_status_code)(GSupplicantInterface *interface, int reasoncode);
+};
+
+typedef struct _GSupplicantCallbacks GSupplicantCallbacks;
+
+int g_supplicant_register(const GSupplicantCallbacks *callbacks);
+void g_supplicant_unregister(const GSupplicantCallbacks *callbacks);
+
+static inline
+void g_supplicant_free_scan_params(GSupplicantScanParams *scan_params)
+{
+ g_slist_free_full(scan_params->ssids, g_free);
+ g_free(scan_params->freqs);
+ g_free(scan_params);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __G_SUPPLICANT_H */
diff --git a/gsupplicant/supplicant.c b/gsupplicant/supplicant.c
new file mode 100644
index 0000000..9901434
--- /dev/null
+++ b/gsupplicant/supplicant.c
@@ -0,0 +1,5579 @@
+/*
+ *
+ * WPA supplicant library with GLib integration
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <syslog.h>
+#include <ctype.h>
+#include <stdbool.h>
+#include <netinet/if_ether.h>
+#include <netinet/in.h>
+
+#include <glib.h>
+#include <gdbus.h>
+
+#include "dbus.h"
+#include "gsupplicant.h"
+
+#define IEEE80211_CAP_ESS 0x0001
+#define IEEE80211_CAP_IBSS 0x0002
+#define IEEE80211_CAP_PRIVACY 0x0010
+
+#define BSS_UNKNOWN_STRENGTH -90
+
+static DBusConnection *connection;
+
+static const GSupplicantCallbacks *callbacks_pointer;
+
+static dbus_bool_t system_available = FALSE;
+static dbus_bool_t system_ready = FALSE;
+
+static dbus_int32_t debug_level;
+static dbus_bool_t debug_timestamp = FALSE;
+static dbus_bool_t debug_showkeys = FALSE;
+
+static const char *debug_strings[] = {
+ "msgdump", "debug", "info", "warning", "error", NULL
+};
+
+static unsigned int eap_methods;
+
+struct strvalmap {
+ const char *str;
+ unsigned int val;
+};
+
+static struct strvalmap eap_method_map[] = {
+ { "MD5", G_SUPPLICANT_EAP_METHOD_MD5 },
+ { "TLS", G_SUPPLICANT_EAP_METHOD_TLS },
+ { "MSCHAPV2", G_SUPPLICANT_EAP_METHOD_MSCHAPV2 },
+ { "PEAP", G_SUPPLICANT_EAP_METHOD_PEAP },
+ { "TTLS", G_SUPPLICANT_EAP_METHOD_TTLS },
+ { "GTC", G_SUPPLICANT_EAP_METHOD_GTC },
+ { "OTP", G_SUPPLICANT_EAP_METHOD_OTP },
+ { "LEAP", G_SUPPLICANT_EAP_METHOD_LEAP },
+ { "WSC", G_SUPPLICANT_EAP_METHOD_WSC },
+ { }
+};
+
+static struct strvalmap keymgmt_map[] = {
+ { "none", G_SUPPLICANT_KEYMGMT_NONE },
+ { "ieee8021x", G_SUPPLICANT_KEYMGMT_IEEE8021X },
+ { "wpa-none", G_SUPPLICANT_KEYMGMT_WPA_NONE },
+ { "wpa-psk", G_SUPPLICANT_KEYMGMT_WPA_PSK },
+ { "wpa-psk-sha256", G_SUPPLICANT_KEYMGMT_WPA_PSK_256 },
+ { "wpa-ft-psk", G_SUPPLICANT_KEYMGMT_WPA_FT_PSK },
+ { "wpa-ft-eap", G_SUPPLICANT_KEYMGMT_WPA_FT_EAP },
+ { "wpa-eap", G_SUPPLICANT_KEYMGMT_WPA_EAP },
+ { "wpa-eap-sha256", G_SUPPLICANT_KEYMGMT_WPA_EAP_256 },
+ { "wps", G_SUPPLICANT_KEYMGMT_WPS },
+ { }
+};
+
+static struct strvalmap authalg_capa_map[] = {
+ { "open", G_SUPPLICANT_CAPABILITY_AUTHALG_OPEN },
+ { "shared", G_SUPPLICANT_CAPABILITY_AUTHALG_SHARED },
+ { "leap", G_SUPPLICANT_CAPABILITY_AUTHALG_LEAP },
+ { }
+};
+
+static struct strvalmap proto_capa_map[] = {
+ { "wpa", G_SUPPLICANT_CAPABILITY_PROTO_WPA },
+ { "rsn", G_SUPPLICANT_CAPABILITY_PROTO_RSN },
+ { }
+};
+
+static struct strvalmap group_map[] = {
+ { "wep40", G_SUPPLICANT_GROUP_WEP40 },
+ { "wep104", G_SUPPLICANT_GROUP_WEP104 },
+ { "tkip", G_SUPPLICANT_GROUP_TKIP },
+ { "ccmp", G_SUPPLICANT_GROUP_CCMP },
+ { }
+};
+
+static struct strvalmap pairwise_map[] = {
+ { "none", G_SUPPLICANT_PAIRWISE_NONE },
+ { "tkip", G_SUPPLICANT_PAIRWISE_TKIP },
+ { "ccmp", G_SUPPLICANT_PAIRWISE_CCMP },
+ { }
+};
+
+static struct strvalmap scan_capa_map[] = {
+ { "active", G_SUPPLICANT_CAPABILITY_SCAN_ACTIVE },
+ { "passive", G_SUPPLICANT_CAPABILITY_SCAN_PASSIVE },
+ { "ssid", G_SUPPLICANT_CAPABILITY_SCAN_SSID },
+ { }
+};
+
+static struct strvalmap mode_capa_map[] = {
+ { "infrastructure", G_SUPPLICANT_CAPABILITY_MODE_INFRA },
+ { "ad-hoc", G_SUPPLICANT_CAPABILITY_MODE_IBSS },
+ { "ap", G_SUPPLICANT_CAPABILITY_MODE_AP },
+ { }
+};
+
+static GHashTable *interface_table;
+static GHashTable *bss_mapping;
+static GHashTable *peer_mapping;
+static GHashTable *group_mapping;
+static GHashTable *pending_peer_connection;
+
+struct _GSupplicantWpsCredentials {
+ unsigned char ssid[32];
+ unsigned int ssid_len;
+ char *key;
+};
+
+struct added_network_information {
+ char * ssid;
+ GSupplicantSecurity security;
+ char * passphrase;
+ char * private_passphrase;
+};
+
+struct _GSupplicantInterface {
+ char *path;
+ char *network_path;
+ unsigned int keymgmt_capa;
+ unsigned int authalg_capa;
+ unsigned int proto_capa;
+ unsigned int group_capa;
+ unsigned int pairwise_capa;
+ unsigned int scan_capa;
+ unsigned int mode_capa;
+ unsigned int max_scan_ssids;
+ bool p2p_support;
+ bool p2p_finding;
+ bool ap_create_in_progress;
+ dbus_bool_t ready;
+ GSupplicantState state;
+ dbus_bool_t scanning;
+ GSupplicantInterfaceCallback scan_callback;
+ void *scan_data;
+ int apscan;
+ char *ifname;
+ char *driver;
+ char *bridge;
+ struct _GSupplicantWpsCredentials wps_cred;
+ GSupplicantWpsState wps_state;
+ GHashTable *network_table;
+ GHashTable *peer_table;
+ GHashTable *group_table;
+ GHashTable *net_mapping;
+ GHashTable *bss_mapping;
+ void *data;
+ const char *pending_peer_path;
+ struct added_network_information network_info;
+};
+
+struct g_supplicant_bss {
+ GSupplicantInterface *interface;
+ char *path;
+ unsigned char bssid[6];
+ unsigned char ssid[32];
+ unsigned int ssid_len;
+ dbus_uint16_t frequency;
+ dbus_uint32_t maxrate;
+ dbus_int16_t signal;
+ GSupplicantMode mode;
+ GSupplicantSecurity security;
+ dbus_bool_t rsn_selected;
+ unsigned int wpa_keymgmt;
+ unsigned int wpa_pairwise;
+ unsigned int wpa_group;
+ unsigned int rsn_keymgmt;
+ unsigned int rsn_pairwise;
+ unsigned int rsn_group;
+ unsigned int keymgmt;
+ dbus_bool_t privacy;
+ dbus_bool_t psk;
+ dbus_bool_t ieee8021x;
+ unsigned int wps_capabilities;
+};
+
+struct _GSupplicantNetwork {
+ GSupplicantInterface *interface;
+ char *path;
+ char *group;
+ char *name;
+ unsigned char ssid[32];
+ unsigned int ssid_len;
+ dbus_int16_t signal;
+ dbus_uint16_t frequency;
+ struct g_supplicant_bss *best_bss;
+ GSupplicantMode mode;
+ GSupplicantSecurity security;
+ dbus_bool_t wps;
+ unsigned int wps_capabilities;
+ GHashTable *bss_table;
+ GHashTable *config_table;
+};
+
+struct _GSupplicantPeer {
+ GSupplicantInterface *interface;
+ char *path;
+ unsigned char device_address[ETH_ALEN];
+ unsigned char iface_address[ETH_ALEN];
+ char *name;
+ unsigned char *widi_ies;
+ int widi_ies_length;
+ char *identifier;
+ unsigned int wps_capabilities;
+ GSList *groups;
+ const GSupplicantInterface *current_group_iface;
+ bool connection_requested;
+};
+
+struct _GSupplicantGroup {
+ GSupplicantInterface *interface;
+ GSupplicantInterface *orig_interface;
+ char *path;
+ int role;
+ GSList *members;
+};
+
+struct interface_data {
+ GSupplicantInterface *interface;
+ char *path; /* Interface path cannot be taken from interface (above) as
+ * it might have been freed already.
+ */
+ GSupplicantInterfaceCallback callback;
+ void *user_data;
+ bool network_remove_in_progress;
+ GSupplicantSSID *ssid;
+};
+
+struct interface_create_data {
+ char *ifname;
+ char *driver;
+ char *bridge;
+ GSupplicantInterface *interface;
+ GSupplicantInterfaceCallback callback;
+ void *user_data;
+};
+
+struct interface_connect_data {
+ GSupplicantInterface *interface;
+ char *path;
+ GSupplicantInterfaceCallback callback;
+ void *user_data;
+ union {
+ GSupplicantSSID *ssid;
+ GSupplicantPeerParams *peer;
+ };
+};
+
+struct interface_scan_data {
+ GSupplicantInterface *interface;
+ char *path;
+ GSupplicantInterfaceCallback callback;
+ GSupplicantScanParams *scan_params;
+ void *user_data;
+};
+
+static int network_remove(struct interface_data *data);
+
+static inline void debug(const char *format, ...)
+{
+ char str[256];
+ va_list ap;
+
+ if (!callbacks_pointer->debug)
+ return;
+
+ va_start(ap, format);
+
+ if (vsnprintf(str, sizeof(str), format, ap) > 0)
+ callbacks_pointer->debug(str);
+
+ va_end(ap);
+}
+
+#define SUPPLICANT_DBG(fmt, arg...) \
+ debug("%s:%s() " fmt, __FILE__, __FUNCTION__ , ## arg);
+
+static GSupplicantMode string2mode(const char *mode)
+{
+ if (!mode)
+ return G_SUPPLICANT_MODE_UNKNOWN;
+
+ if (g_str_equal(mode, "infrastructure"))
+ return G_SUPPLICANT_MODE_INFRA;
+ else if (g_str_equal(mode, "ad-hoc"))
+ return G_SUPPLICANT_MODE_IBSS;
+
+ return G_SUPPLICANT_MODE_UNKNOWN;
+}
+
+static const char *mode2string(GSupplicantMode mode)
+{
+ switch (mode) {
+ case G_SUPPLICANT_MODE_UNKNOWN:
+ break;
+ case G_SUPPLICANT_MODE_INFRA:
+ return "managed";
+ case G_SUPPLICANT_MODE_IBSS:
+ return "adhoc";
+ case G_SUPPLICANT_MODE_MASTER:
+ return "ap";
+ }
+
+ return NULL;
+}
+
+static const char *security2string(GSupplicantSecurity security)
+{
+ switch (security) {
+ case G_SUPPLICANT_SECURITY_UNKNOWN:
+ break;
+ case G_SUPPLICANT_SECURITY_NONE:
+ return "none";
+ case G_SUPPLICANT_SECURITY_WEP:
+ return "wep";
+ case G_SUPPLICANT_SECURITY_PSK:
+ return "psk";
+ case G_SUPPLICANT_SECURITY_IEEE8021X:
+ return "ieee8021x";
+ }
+
+ return NULL;
+}
+
+static GSupplicantState string2state(const char *state)
+{
+ if (!state)
+ return G_SUPPLICANT_STATE_UNKNOWN;
+
+ if (g_str_equal(state, "unknown"))
+ return G_SUPPLICANT_STATE_UNKNOWN;
+ else if (g_str_equal(state, "interface_disabled"))
+ return G_SUPPLICANT_STATE_DISABLED;
+ else if (g_str_equal(state, "disconnected"))
+ return G_SUPPLICANT_STATE_DISCONNECTED;
+ else if (g_str_equal(state, "inactive"))
+ return G_SUPPLICANT_STATE_INACTIVE;
+ else if (g_str_equal(state, "scanning"))
+ return G_SUPPLICANT_STATE_SCANNING;
+ else if (g_str_equal(state, "authenticating"))
+ return G_SUPPLICANT_STATE_AUTHENTICATING;
+ else if (g_str_equal(state, "associating"))
+ return G_SUPPLICANT_STATE_ASSOCIATING;
+ else if (g_str_equal(state, "associated"))
+ return G_SUPPLICANT_STATE_ASSOCIATED;
+ else if (g_str_equal(state, "group_handshake"))
+ return G_SUPPLICANT_STATE_GROUP_HANDSHAKE;
+ else if (g_str_equal(state, "4way_handshake"))
+ return G_SUPPLICANT_STATE_4WAY_HANDSHAKE;
+ else if (g_str_equal(state, "completed"))
+ return G_SUPPLICANT_STATE_COMPLETED;
+
+ return G_SUPPLICANT_STATE_UNKNOWN;
+}
+
+static bool compare_network_parameters(GSupplicantInterface *interface, GSupplicantSSID *ssid)
+{
+ if (memcmp(interface->network_info.ssid, ssid->ssid, ssid->ssid_len))
+ return FALSE;
+
+ if (interface->network_info.security != ssid->security)
+ return FALSE;
+
+ if (interface->network_info.passphrase &&
+ g_strcmp0(interface->network_info.passphrase, ssid->passphrase) != 0) {
+ return FALSE;
+ }
+
+ if (interface->network_info.private_passphrase &&
+ g_strcmp0(interface->network_info.private_passphrase, ssid->private_key_passphrase) != 0) {
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void remove_network_information(GSupplicantInterface * interface)
+{
+ g_free(interface->network_info.ssid);
+ g_free(interface->network_info.passphrase);
+ g_free(interface->network_info.private_passphrase);
+ interface->network_info.ssid = NULL;
+ interface->network_info.passphrase = NULL;
+ interface->network_info.private_passphrase = NULL;
+}
+
+static int store_network_information(GSupplicantInterface * interface, GSupplicantSSID *ssid)
+{
+ interface->network_info.ssid = g_malloc(ssid->ssid_len + 1);
+ if (interface->network_info.ssid != NULL) {
+ memcpy(interface->network_info.ssid, ssid->ssid, ssid->ssid_len);
+ interface->network_info.ssid[ssid->ssid_len] = '\0';
+ } else {
+ return -ENOMEM;
+ }
+
+ interface->network_info.security = ssid->security;
+
+ if ((ssid->security == G_SUPPLICANT_SECURITY_WEP ||
+ ssid->security == G_SUPPLICANT_SECURITY_PSK ||
+ ssid->security == G_SUPPLICANT_SECURITY_NONE) &&
+ ssid->passphrase) {
+ interface->network_info.passphrase = g_strdup(ssid->passphrase);
+ }
+
+ if (ssid->security == G_SUPPLICANT_SECURITY_IEEE8021X && ssid->private_key_passphrase) {
+ interface->network_info.private_passphrase = g_strdup(ssid->private_key_passphrase);
+ }
+
+ return 0;
+}
+
+static void callback_system_ready(void)
+{
+ if (system_ready)
+ return;
+
+ system_ready = TRUE;
+
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->system_ready)
+ return;
+
+ callbacks_pointer->system_ready();
+}
+
+static void callback_system_killed(void)
+{
+ system_ready = FALSE;
+
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->system_killed)
+ return;
+
+ callbacks_pointer->system_killed();
+}
+
+static void callback_interface_added(GSupplicantInterface *interface)
+{
+ SUPPLICANT_DBG("");
+
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->interface_added)
+ return;
+
+ callbacks_pointer->interface_added(interface);
+}
+
+static void callback_interface_state(GSupplicantInterface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->interface_state)
+ return;
+
+ callbacks_pointer->interface_state(interface);
+}
+
+static void callback_interface_removed(GSupplicantInterface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->interface_removed)
+ return;
+
+ callbacks_pointer->interface_removed(interface);
+}
+
+static void callback_p2p_support(GSupplicantInterface *interface)
+{
+ SUPPLICANT_DBG("");
+
+ return;
+
+ if (!interface->p2p_support)
+ return;
+
+ if (callbacks_pointer && callbacks_pointer->p2p_support)
+ callbacks_pointer->p2p_support(interface);
+}
+
+static void callback_scan_started(GSupplicantInterface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->scan_started)
+ return;
+
+ callbacks_pointer->scan_started(interface);
+}
+
+static void callback_ap_create_fail(GSupplicantInterface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->scan_started)
+ return;
+
+ callbacks_pointer->ap_create_fail(interface);
+}
+
+static void callback_scan_finished(GSupplicantInterface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->scan_finished)
+ return;
+
+ callbacks_pointer->scan_finished(interface);
+}
+
+static void callback_network_added(GSupplicantNetwork *network)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->network_added)
+ return;
+
+ callbacks_pointer->network_added(network);
+}
+
+static void callback_network_removed(GSupplicantNetwork *network)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->network_removed)
+ return;
+
+ callbacks_pointer->network_removed(network);
+}
+
+static void callback_network_changed(GSupplicantNetwork *network,
+ const char *property)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->network_changed)
+ return;
+
+ callbacks_pointer->network_changed(network, property);
+}
+
+static void callback_peer_found(GSupplicantPeer *peer)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->peer_found)
+ return;
+
+ callbacks_pointer->peer_found(peer);
+}
+
+static void callback_peer_lost(GSupplicantPeer *peer)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->peer_lost)
+ return;
+
+ callbacks_pointer->peer_lost(peer);
+}
+
+static void callback_peer_changed(GSupplicantPeer *peer,
+ GSupplicantPeerState state)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->peer_changed)
+ return;
+
+ callbacks_pointer->peer_changed(peer, state);
+}
+
+static void callback_peer_request(GSupplicantPeer *peer)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->peer_request)
+ return;
+
+ peer->connection_requested = true;
+
+ callbacks_pointer->peer_request(peer);
+}
+
+static void remove_group(gpointer data)
+{
+ GSupplicantGroup *group = data;
+
+ if (group->members)
+ g_slist_free_full(group->members, g_free);
+
+ g_free(group->path);
+ g_free(group);
+}
+
+static void remove_interface(gpointer data)
+{
+ GSupplicantInterface *interface = data;
+
+ g_hash_table_destroy(interface->bss_mapping);
+ g_hash_table_destroy(interface->net_mapping);
+ g_hash_table_destroy(interface->network_table);
+ g_hash_table_destroy(interface->peer_table);
+ g_hash_table_destroy(interface->group_table);
+
+ if (interface->scan_callback) {
+ SUPPLICANT_DBG("call interface %p callback %p scanning %d",
+ interface, interface->scan_callback,
+ interface->scanning);
+
+ interface->scan_callback(-EIO, interface, interface->scan_data);
+ interface->scan_callback = NULL;
+ interface->scan_data = NULL;
+
+ if (interface->scanning) {
+ interface->scanning = FALSE;
+ callback_scan_finished(interface);
+ }
+ }
+
+ callback_interface_removed(interface);
+
+ g_free(interface->wps_cred.key);
+ g_free(interface->path);
+ g_free(interface->network_path);
+ g_free(interface->ifname);
+ g_free(interface->driver);
+ g_free(interface->bridge);
+ remove_network_information(interface);
+ g_free(interface);
+}
+
+static void remove_network(gpointer data)
+{
+ GSupplicantNetwork *network = data;
+
+ g_hash_table_destroy(network->bss_table);
+
+ callback_network_removed(network);
+
+ g_hash_table_destroy(network->config_table);
+
+ g_free(network->path);
+ g_free(network->group);
+ g_free(network->name);
+ g_free(network);
+}
+
+static void remove_bss(gpointer data)
+{
+ struct g_supplicant_bss *bss = data;
+
+ g_free(bss->path);
+ g_free(bss);
+}
+
+static void remove_peer(gpointer data)
+{
+ GSupplicantPeer *peer = data;
+
+ callback_peer_lost(peer);
+
+ if (peer->groups)
+ g_slist_free_full(peer->groups, g_free);
+
+ if (peer_mapping)
+ g_hash_table_remove(peer_mapping, peer->path);
+
+ if (pending_peer_connection)
+ g_hash_table_remove(pending_peer_connection, peer->path);
+
+ g_free(peer->path);
+ g_free(peer->name);
+ g_free(peer->identifier);
+
+ g_free(peer);
+}
+
+static void debug_strvalmap(const char *label, struct strvalmap *map,
+ unsigned int val)
+{
+ int i;
+
+ for (i = 0; map[i].str; i++) {
+ if (val & map[i].val)
+ SUPPLICANT_DBG("%s: %s", label, map[i].str);
+ }
+}
+
+static void interface_capability_keymgmt(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; keymgmt_map[i].str; i++)
+ if (strcmp(str, keymgmt_map[i].str) == 0) {
+ interface->keymgmt_capa |= keymgmt_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_authalg(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; authalg_capa_map[i].str; i++)
+ if (strcmp(str, authalg_capa_map[i].str) == 0) {
+ interface->authalg_capa |= authalg_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_proto(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; proto_capa_map[i].str; i++)
+ if (strcmp(str, proto_capa_map[i].str) == 0) {
+ interface->proto_capa |= proto_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_pairwise(DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; pairwise_map[i].str; i++)
+ if (strcmp(str, pairwise_map[i].str) == 0) {
+ interface->pairwise_capa |= pairwise_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_group(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; group_map[i].str; i++)
+ if (strcmp(str, group_map[i].str) == 0) {
+ interface->group_capa |= group_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; scan_capa_map[i].str; i++)
+ if (strcmp(str, scan_capa_map[i].str) == 0) {
+ interface->scan_capa |= scan_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_mode(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; mode_capa_map[i].str; i++)
+ if (strcmp(str, mode_capa_map[i].str) == 0) {
+ interface->mode_capa |= mode_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+
+ if (!key)
+ return;
+
+ if (g_strcmp0(key, "KeyMgmt") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_keymgmt, interface);
+ else if (g_strcmp0(key, "AuthAlg") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_authalg, interface);
+ else if (g_strcmp0(key, "Protocol") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_proto, interface);
+ else if (g_strcmp0(key, "Pairwise") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_pairwise, interface);
+ else if (g_strcmp0(key, "Group") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_group, interface);
+ else if (g_strcmp0(key, "Scan") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_scan, interface);
+ else if (g_strcmp0(key, "Modes") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_mode, interface);
+ else if (g_strcmp0(key, "MaxScanSSID") == 0) {
+ dbus_int32_t max_scan_ssid;
+
+ dbus_message_iter_get_basic(iter, &max_scan_ssid);
+ if (max_scan_ssid < 2)
+ max_scan_ssid = 0;
+ interface->max_scan_ssids = max_scan_ssid;
+
+ } else
+ SUPPLICANT_DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+struct set_apscan_data
+{
+ unsigned int ap_scan;
+ GSupplicantInterface *interface;
+};
+
+static void set_apscan(DBusMessageIter *iter, void *user_data)
+{
+ struct set_apscan_data *data = user_data;
+ unsigned int ap_scan = data->ap_scan;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &ap_scan);
+}
+
+static void set_apscan_complete(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct set_apscan_data *data = user_data;
+ GSupplicantInterface *interface = data->interface;
+
+ if (error) {
+ interface->ap_create_in_progress = false;
+ SUPPLICANT_DBG("Set AP scan error %s", error);
+ goto error;
+ }
+
+ interface->ap_create_in_progress = true;
+error:
+ dbus_free(data);
+}
+
+int g_supplicant_interface_set_apscan(GSupplicantInterface *interface,
+ unsigned int ap_scan)
+{
+ struct set_apscan_data *data;
+ int ret;
+
+ data = dbus_malloc0(sizeof(*data));
+
+ if (!data)
+ return -ENOMEM;
+
+ data->ap_scan = ap_scan;
+ data->interface = interface;
+
+ ret = supplicant_dbus_property_set(interface->path,
+ SUPPLICANT_INTERFACE ".Interface",
+ "ApScan", DBUS_TYPE_UINT32_AS_STRING,
+ set_apscan, set_apscan_complete, data, NULL);
+ if (ret < 0)
+ dbus_free(data);
+
+ return ret;
+}
+
+void g_supplicant_interface_set_data(GSupplicantInterface *interface,
+ void *data)
+{
+ if (!interface)
+ return;
+
+ interface->data = data;
+
+ if (!data)
+ interface->scan_callback = NULL;
+}
+
+void *g_supplicant_interface_get_data(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return NULL;
+
+ return interface->data;
+}
+
+const char *g_supplicant_interface_get_ifname(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return NULL;
+
+ return interface->ifname;
+}
+
+const char *g_supplicant_interface_get_driver(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return NULL;
+
+ return interface->driver;
+}
+
+GSupplicantState g_supplicant_interface_get_state(
+ GSupplicantInterface *interface)
+{
+ if (!interface)
+ return G_SUPPLICANT_STATE_UNKNOWN;
+
+ return interface->state;
+}
+
+const char *g_supplicant_interface_get_wps_key(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return NULL;
+
+ return (const char *)interface->wps_cred.key;
+}
+
+const void *g_supplicant_interface_get_wps_ssid(GSupplicantInterface *interface,
+ unsigned int *ssid_len)
+{
+ if (!ssid_len)
+ return NULL;
+
+ if (!interface || interface->wps_cred.ssid_len == 0) {
+ *ssid_len = 0;
+ return NULL;
+ }
+
+ *ssid_len = interface->wps_cred.ssid_len;
+ return interface->wps_cred.ssid;
+}
+
+GSupplicantWpsState g_supplicant_interface_get_wps_state(
+ GSupplicantInterface *interface)
+{
+ if (!interface)
+ return G_SUPPLICANT_WPS_STATE_UNKNOWN;
+
+ return interface->wps_state;
+}
+
+unsigned int g_supplicant_interface_get_mode(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return 0;
+
+ return interface->mode_capa;
+}
+
+unsigned int g_supplicant_interface_get_max_scan_ssids(
+ GSupplicantInterface *interface)
+{
+ if (!interface)
+ return 0;
+
+ return interface->max_scan_ssids;
+}
+
+static void set_network_enabled(DBusMessageIter *iter, void *user_data)
+{
+ dbus_bool_t enable = *(dbus_bool_t *)user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &enable);
+}
+
+int g_supplicant_interface_enable_selected_network(GSupplicantInterface *interface,
+ dbus_bool_t enable)
+{
+ if (!interface)
+ return -1;
+
+ if (!interface->network_path)
+ return -1;
+
+ SUPPLICANT_DBG(" ");
+ return supplicant_dbus_property_set(interface->network_path,
+ SUPPLICANT_INTERFACE ".Network",
+ "Enabled", DBUS_TYPE_BOOLEAN_AS_STRING,
+ set_network_enabled, NULL, &enable, NULL);
+}
+
+dbus_bool_t g_supplicant_interface_get_ready(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return FALSE;
+
+ return interface->ready;
+}
+
+GSupplicantInterface *g_supplicant_network_get_interface(
+ GSupplicantNetwork *network)
+{
+ if (!network)
+ return NULL;
+
+ return network->interface;
+}
+
+const char *g_supplicant_network_get_name(GSupplicantNetwork *network)
+{
+ if (!network || !network->name)
+ return "";
+
+ return network->name;
+}
+
+const char *g_supplicant_network_get_identifier(GSupplicantNetwork *network)
+{
+ if (!network || !network->group)
+ return "";
+
+ return network->group;
+}
+
+const char *g_supplicant_network_get_path(GSupplicantNetwork *network)
+{
+ if (!network || !network->path)
+ return NULL;
+
+ return network->path;
+}
+
+const char *g_supplicant_network_get_mode(GSupplicantNetwork *network)
+{
+ if (!network)
+ return G_SUPPLICANT_MODE_UNKNOWN;
+
+ return mode2string(network->mode);
+}
+
+const char *g_supplicant_network_get_security(GSupplicantNetwork *network)
+{
+ if (!network)
+ return G_SUPPLICANT_SECURITY_UNKNOWN;
+
+ return security2string(network->security);
+}
+
+const void *g_supplicant_network_get_ssid(GSupplicantNetwork *network,
+ unsigned int *ssid_len)
+{
+ if (!network) {
+ *ssid_len = 0;
+ return NULL;
+ }
+
+ *ssid_len = network->ssid_len;
+ return network->ssid;
+}
+
+dbus_int16_t g_supplicant_network_get_signal(GSupplicantNetwork *network)
+{
+ if (!network)
+ return 0;
+
+ return network->signal;
+}
+
+dbus_uint16_t g_supplicant_network_get_frequency(GSupplicantNetwork *network)
+{
+ if (!network)
+ return 0;
+
+ return network->frequency;
+}
+
+dbus_bool_t g_supplicant_network_get_wps(GSupplicantNetwork *network)
+{
+ if (!network)
+ return FALSE;
+
+ return network->wps;
+}
+
+dbus_bool_t g_supplicant_network_is_wps_active(GSupplicantNetwork *network)
+{
+ if (!network)
+ return FALSE;
+
+ if (network->wps_capabilities & G_SUPPLICANT_WPS_CONFIGURED)
+ return TRUE;
+
+ return FALSE;
+}
+
+dbus_bool_t g_supplicant_network_is_wps_pbc(GSupplicantNetwork *network)
+{
+ if (!network)
+ return FALSE;
+
+ if (network->wps_capabilities & G_SUPPLICANT_WPS_PBC)
+ return TRUE;
+
+ return FALSE;
+}
+
+dbus_bool_t g_supplicant_network_is_wps_advertizing(GSupplicantNetwork *network)
+{
+ if (!network)
+ return FALSE;
+
+ if (network->wps_capabilities & G_SUPPLICANT_WPS_REGISTRAR)
+ return TRUE;
+
+ return FALSE;
+}
+
+GSupplicantInterface *g_supplicant_peer_get_interface(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->interface;
+}
+
+const char *g_supplicant_peer_get_path(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->path;
+}
+
+const char *g_supplicant_peer_get_identifier(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->identifier;
+}
+
+const void *g_supplicant_peer_get_device_address(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->device_address;
+}
+
+const void *g_supplicant_peer_get_iface_address(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->iface_address;
+}
+
+const char *g_supplicant_peer_get_name(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->name;
+}
+
+const unsigned char *g_supplicant_peer_get_widi_ies(GSupplicantPeer *peer,
+ int *length)
+{
+ if (!peer || !length)
+ return NULL;
+
+ *length = peer->widi_ies_length;
+ return peer->widi_ies;
+}
+
+bool g_supplicant_peer_is_wps_pbc(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return false;
+
+ if (peer->wps_capabilities & G_SUPPLICANT_WPS_PBC)
+ return true;
+
+ return false;
+}
+
+bool g_supplicant_peer_is_wps_pin(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return false;
+
+ if (peer->wps_capabilities & G_SUPPLICANT_WPS_PIN)
+ return true;
+
+ return false;
+}
+
+bool g_supplicant_peer_is_in_a_group(GSupplicantPeer *peer)
+{
+ if (!peer || !peer->groups)
+ return false;
+
+ return true;
+}
+
+GSupplicantInterface *g_supplicant_peer_get_group_interface(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return (GSupplicantInterface *) peer->current_group_iface;
+}
+
+bool g_supplicant_peer_is_client(GSupplicantPeer *peer)
+{
+ GSupplicantGroup *group;
+ GSList *list;
+
+ if (!peer)
+ return false;
+
+ for (list = peer->groups; list; list = list->next) {
+ const char *path = list->data;
+
+ group = g_hash_table_lookup(group_mapping, path);
+ if (!group)
+ continue;
+
+ if (group->role != G_SUPPLICANT_GROUP_ROLE_CLIENT ||
+ group->orig_interface != peer->interface)
+ continue;
+
+ if (group->interface == peer->current_group_iface)
+ return true;
+ }
+
+ return false;
+}
+
+bool g_supplicant_peer_has_requested_connection(GSupplicantPeer *peer)
+{
+ if (!peer)
+ return false;
+
+ return peer->connection_requested;
+}
+
+static void merge_network(GSupplicantNetwork *network)
+{
+ GString *str;
+ const char *ssid, *mode, *key_mgmt;
+ unsigned int i, ssid_len;
+ char *group;
+
+ ssid = g_hash_table_lookup(network->config_table, "ssid");
+ mode = g_hash_table_lookup(network->config_table, "mode");
+ key_mgmt = g_hash_table_lookup(network->config_table, "key_mgmt");
+
+ SUPPLICANT_DBG("ssid %s mode %s", ssid, mode);
+
+ if (ssid)
+ ssid_len = strlen(ssid);
+ else
+ ssid_len = 0;
+
+ str = g_string_sized_new((ssid_len * 2) + 24);
+ if (!str)
+ return;
+
+ for (i = 0; i < ssid_len; i++)
+ g_string_append_printf(str, "%02x", ssid[i]);
+
+ if (g_strcmp0(mode, "0") == 0)
+ g_string_append_printf(str, "_managed");
+ else if (g_strcmp0(mode, "1") == 0)
+ g_string_append_printf(str, "_adhoc");
+
+ if (g_strcmp0(key_mgmt, "WPA-PSK") == 0)
+ g_string_append_printf(str, "_psk");
+
+ group = g_string_free(str, FALSE);
+
+ SUPPLICANT_DBG("%s", group);
+
+ g_free(group);
+
+ g_hash_table_destroy(network->config_table);
+
+ g_free(network->path);
+ g_free(network);
+}
+
+static void network_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantNetwork *network = user_data;
+
+ if (!network->interface)
+ return;
+
+ if (!key) {
+ merge_network(network);
+ return;
+ }
+
+ if (g_strcmp0(key, "Enabled") == 0) {
+ dbus_bool_t enabled = FALSE;
+
+ dbus_message_iter_get_basic(iter, &enabled);
+ } else if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str) {
+ g_hash_table_replace(network->config_table,
+ g_strdup(key), g_strdup(str));
+ }
+ } else
+ SUPPLICANT_DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static void interface_network_added(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ GSupplicantNetwork *network;
+ const char *path = NULL;
+
+ SUPPLICANT_DBG("");
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ if (g_strcmp0(path, "/") == 0)
+ return;
+
+ network = g_hash_table_lookup(interface->net_mapping, path);
+ if (network)
+ return;
+
+ network = g_try_new0(GSupplicantNetwork, 1);
+ if (!network)
+ return;
+
+ network->interface = interface;
+ network->path = g_strdup(path);
+
+ network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ supplicant_dbus_property_foreach(iter, network_property,
+ network);
+ network_property(NULL, NULL, network);
+ return;
+ }
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Network",
+ network_property, network, NULL);
+}
+
+static void interface_network_removed(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ GSupplicantNetwork *network;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ network = g_hash_table_lookup(interface->net_mapping, path);
+ if (!network)
+ return;
+
+ g_hash_table_remove(interface->net_mapping, path);
+}
+
+static char *create_name(unsigned char *ssid, int ssid_len)
+{
+ GString *string;
+ const gchar *remainder, *invalid;
+ int valid_bytes, remaining_bytes;
+
+ if (ssid_len < 1 || ssid[0] == '\0')
+ return g_strdup("");
+
+ string = NULL;
+ remainder = (const gchar *)ssid;
+ remaining_bytes = ssid_len;
+
+ while (remaining_bytes != 0) {
+ if (g_utf8_validate(remainder, remaining_bytes,
+ &invalid)) {
+ break;
+ }
+
+ valid_bytes = invalid - remainder;
+
+ if (!string)
+ string = g_string_sized_new(remaining_bytes);
+
+ g_string_append_len(string, remainder, valid_bytes);
+
+ /* append U+FFFD REPLACEMENT CHARACTER */
+ g_string_append(string, "\357\277\275");
+
+ remaining_bytes -= valid_bytes + 1;
+ remainder = invalid + 1;
+ }
+
+ if (!string)
+ return g_strndup((const gchar *)ssid, ssid_len + 1);
+
+ g_string_append(string, remainder);
+
+ return g_string_free(string, FALSE);
+}
+
+static char *create_group(struct g_supplicant_bss *bss)
+{
+ GString *str;
+ unsigned int i;
+ const char *mode, *security;
+
+ str = g_string_sized_new((bss->ssid_len * 2) + 24);
+ if (!str)
+ return NULL;
+
+ if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
+ for (i = 0; i < bss->ssid_len; i++)
+ g_string_append_printf(str, "%02x", bss->ssid[i]);
+ } else
+ g_string_append_printf(str, "hidden");
+
+ mode = mode2string(bss->mode);
+ if (mode)
+ g_string_append_printf(str, "_%s", mode);
+
+ security = security2string(bss->security);
+ if (security)
+ g_string_append_printf(str, "_%s", security);
+
+ return g_string_free(str, FALSE);
+}
+
+static void add_or_replace_bss_to_network(struct g_supplicant_bss *bss)
+{
+ GSupplicantInterface *interface = bss->interface;
+ GSupplicantNetwork *network;
+ char *group;
+
+ group = create_group(bss);
+ SUPPLICANT_DBG("New group created: %s", group);
+
+ if (!group)
+ return;
+
+ network = g_hash_table_lookup(interface->network_table, group);
+ if (network) {
+ g_free(group);
+ SUPPLICANT_DBG("Network %s already exist", network->name);
+
+ goto done;
+ }
+
+ network = g_try_new0(GSupplicantNetwork, 1);
+ if (!network) {
+ g_free(group);
+ return;
+ }
+
+ network->interface = interface;
+ if (!network->path)
+ network->path = g_strdup(bss->path);
+ network->group = group;
+ network->name = create_name(bss->ssid, bss->ssid_len);
+ network->mode = bss->mode;
+ network->security = bss->security;
+ network->ssid_len = bss->ssid_len;
+ memcpy(network->ssid, bss->ssid, bss->ssid_len);
+ network->signal = bss->signal;
+ network->frequency = bss->frequency;
+ network->best_bss = bss;
+
+ SUPPLICANT_DBG("New network %s created", network->name);
+
+ network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_bss);
+
+ network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+
+ g_hash_table_replace(interface->network_table,
+ network->group, network);
+
+ callback_network_added(network);
+
+done:
+ /* We update network's WPS properties if only bss provides WPS. */
+ if ((bss->keymgmt & G_SUPPLICANT_KEYMGMT_WPS) != 0) {
+ network->wps = TRUE;
+ network->wps_capabilities |= bss->wps_capabilities;
+ }
+
+ if (bss->signal > network->signal) {
+ network->signal = bss->signal;
+ network->best_bss = bss;
+ callback_network_changed(network, "Signal");
+ }
+
+ g_hash_table_replace(interface->bss_mapping, bss->path, network);
+ g_hash_table_replace(network->bss_table, bss->path, bss);
+
+ g_hash_table_replace(bss_mapping, bss->path, interface);
+}
+
+static void bss_rates(DBusMessageIter *iter, void *user_data)
+{
+ struct g_supplicant_bss *bss = user_data;
+ dbus_uint32_t rate = 0;
+
+ dbus_message_iter_get_basic(iter, &rate);
+ if (rate == 0)
+ return;
+
+ if (rate > bss->maxrate)
+ bss->maxrate = rate;
+}
+
+static void bss_keymgmt(DBusMessageIter *iter, void *user_data)
+{
+ unsigned int *keymgmt = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; keymgmt_map[i].str; i++)
+ if (strcmp(str, keymgmt_map[i].str) == 0) {
+ SUPPLICANT_DBG("Keymgmt: %s", str);
+ *keymgmt |= keymgmt_map[i].val;
+ break;
+ }
+}
+
+static void bss_group(DBusMessageIter *iter, void *user_data)
+{
+ unsigned int *group = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; group_map[i].str; i++)
+ if (strcmp(str, group_map[i].str) == 0) {
+ SUPPLICANT_DBG("Group: %s", str);
+ *group |= group_map[i].val;
+ break;
+ }
+}
+
+static void bss_pairwise(DBusMessageIter *iter, void *user_data)
+{
+ unsigned int *pairwise = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; pairwise_map[i].str; i++)
+ if (strcmp(str, pairwise_map[i].str) == 0) {
+ SUPPLICANT_DBG("Pairwise: %s", str);
+ *pairwise |= pairwise_map[i].val;
+ break;
+ }
+}
+
+static void bss_wpa(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct g_supplicant_bss *bss = user_data;
+ unsigned int value = 0;
+
+ SUPPLICANT_DBG("Key: %s", key);
+
+ if (g_strcmp0(key, "KeyMgmt") == 0) {
+ supplicant_dbus_array_foreach(iter, bss_keymgmt, &value);
+
+ if (bss->rsn_selected)
+ bss->rsn_keymgmt = value;
+ else
+ bss->wpa_keymgmt = value;
+ } else if (g_strcmp0(key, "Group") == 0) {
+ supplicant_dbus_array_foreach(iter, bss_group, &value);
+
+ if (bss->rsn_selected)
+ bss->rsn_group = value;
+ else
+ bss->wpa_group = value;
+ } else if (g_strcmp0(key, "Pairwise") == 0) {
+ supplicant_dbus_array_foreach(iter, bss_pairwise, &value);
+
+ if (bss->rsn_selected)
+ bss->rsn_pairwise = value;
+ else
+ bss->wpa_pairwise = value;
+ }
+}
+
+static unsigned int get_tlv(unsigned char *ie, unsigned int ie_size,
+ unsigned int type)
+{
+ unsigned int len = 0;
+
+ while (len + 4 < ie_size) {
+ unsigned int hi = ie[len];
+ unsigned int lo = ie[len + 1];
+ unsigned int tmp_type = (hi << 8) + lo;
+ unsigned int v_len = 0;
+
+ /* hi and lo are used to recreate an unsigned int
+ * based on 2 8bits length unsigned int. */
+
+ hi = ie[len + 2];
+ lo = ie[len + 3];
+ v_len = (hi << 8) + lo;
+
+ if (tmp_type == type) {
+ unsigned int ret_value = 0;
+ unsigned char *value = (unsigned char *)&ret_value;
+
+ SUPPLICANT_DBG("IE: match type 0x%x", type);
+
+ /* Verifying length relevance */
+ if (v_len > sizeof(unsigned int) ||
+ len + 4 + v_len > ie_size)
+ break;
+
+ memcpy(value, ie + len + 4, v_len);
+
+ SUPPLICANT_DBG("returning 0x%x", ret_value);
+ return ret_value;
+ }
+
+ len += v_len + 4;
+ }
+
+ SUPPLICANT_DBG("returning 0");
+ return 0;
+}
+
+static void bss_process_ies(DBusMessageIter *iter, void *user_data)
+{
+ struct g_supplicant_bss *bss = user_data;
+ const unsigned char WPS_OUI[] = { 0x00, 0x50, 0xf2, 0x04 };
+ unsigned char *ie, *ie_end;
+ DBusMessageIter array;
+ unsigned int value;
+ int ie_len;
+
+#define WMM_WPA1_WPS_INFO 221
+#define WPS_INFO_MIN_LEN 6
+#define WPS_VERSION_TLV 0x104A
+#define WPS_STATE_TLV 0x1044
+#define WPS_METHODS_TLV 0x1012
+#define WPS_REGISTRAR_TLV 0x1041
+#define WPS_VERSION 0x10
+#define WPS_PBC 0x04
+#define WPS_PIN 0x00
+#define WPS_CONFIGURED 0x02
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+
+ if (!ie || ie_len < 2)
+ return;
+
+ bss->wps_capabilities = 0;
+ bss->keymgmt = 0;
+
+ for (ie_end = ie + ie_len; ie < ie_end && ie + ie[1] + 1 <= ie_end;
+ ie += ie[1] + 2) {
+
+ if (ie[0] != WMM_WPA1_WPS_INFO || ie[1] < WPS_INFO_MIN_LEN ||
+ memcmp(ie+2, WPS_OUI, sizeof(WPS_OUI)) != 0)
+ continue;
+
+ SUPPLICANT_DBG("IE: match WPS_OUI");
+
+ value = get_tlv(&ie[6], ie[1], WPS_STATE_TLV);
+ if (get_tlv(&ie[6], ie[1], WPS_VERSION_TLV) == WPS_VERSION &&
+ value != 0) {
+ bss->keymgmt |= G_SUPPLICANT_KEYMGMT_WPS;
+
+ if (value == WPS_CONFIGURED)
+ bss->wps_capabilities |=
+ G_SUPPLICANT_WPS_CONFIGURED;
+ }
+
+ value = get_tlv(&ie[6], ie[1], WPS_METHODS_TLV);
+ if (value != 0) {
+ if (GUINT16_FROM_BE(value) == WPS_PBC)
+ bss->wps_capabilities |= G_SUPPLICANT_WPS_PBC;
+ if (GUINT16_FROM_BE(value) == WPS_PIN)
+ bss->wps_capabilities |= G_SUPPLICANT_WPS_PIN;
+ } else
+ bss->wps_capabilities |=
+ G_SUPPLICANT_WPS_PBC | G_SUPPLICANT_WPS_PIN;
+
+ /* If the AP sends this it means it's advertizing
+ * as a registrar and the WPS process is launched
+ * on its side */
+ if (get_tlv(&ie[6], ie[1], WPS_REGISTRAR_TLV) != 0)
+ bss->wps_capabilities |= G_SUPPLICANT_WPS_REGISTRAR;
+
+ SUPPLICANT_DBG("WPS Methods 0x%x", bss->wps_capabilities);
+ }
+}
+
+static void bss_compute_security(struct g_supplicant_bss *bss)
+{
+ /*
+ * Combining RSN and WPA keymgmt
+ * We combine it since parsing IEs might have set something for WPS. */
+ bss->keymgmt |= bss->rsn_keymgmt | bss->wpa_keymgmt;
+
+ bss->ieee8021x = FALSE;
+ bss->psk = FALSE;
+
+ if (bss->keymgmt &
+ (G_SUPPLICANT_KEYMGMT_WPA_EAP |
+ G_SUPPLICANT_KEYMGMT_WPA_FT_EAP |
+ G_SUPPLICANT_KEYMGMT_WPA_EAP_256))
+ bss->ieee8021x = TRUE;
+
+ if (bss->keymgmt &
+ (G_SUPPLICANT_KEYMGMT_WPA_PSK |
+ G_SUPPLICANT_KEYMGMT_WPA_FT_PSK |
+ G_SUPPLICANT_KEYMGMT_WPA_PSK_256))
+ bss->psk = TRUE;
+
+ if (bss->ieee8021x)
+ bss->security = G_SUPPLICANT_SECURITY_IEEE8021X;
+ else if (bss->psk)
+ bss->security = G_SUPPLICANT_SECURITY_PSK;
+ else if (bss->privacy)
+ bss->security = G_SUPPLICANT_SECURITY_WEP;
+ else
+ bss->security = G_SUPPLICANT_SECURITY_NONE;
+}
+
+
+static void bss_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct g_supplicant_bss *bss = user_data;
+
+ if (!bss->interface)
+ return;
+
+ SUPPLICANT_DBG("key %s", key);
+
+ if (!key)
+ return;
+
+ if (g_strcmp0(key, "BSSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *addr;
+ int addr_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
+
+ if (addr_len == 6)
+ memcpy(bss->bssid, addr, addr_len);
+ } else if (g_strcmp0(key, "SSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *ssid;
+ int ssid_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
+
+ if (ssid_len > 0 && ssid_len < 33) {
+ memcpy(bss->ssid, ssid, ssid_len);
+ bss->ssid_len = ssid_len;
+ } else {
+ memset(bss->ssid, 0, sizeof(bss->ssid));
+ bss->ssid_len = 0;
+ }
+ } else if (g_strcmp0(key, "Capabilities") == 0) {
+ dbus_uint16_t capabilities = 0x0000;
+
+ dbus_message_iter_get_basic(iter, &capabilities);
+
+ if (capabilities & IEEE80211_CAP_ESS)
+ bss->mode = G_SUPPLICANT_MODE_INFRA;
+ else if (capabilities & IEEE80211_CAP_IBSS)
+ bss->mode = G_SUPPLICANT_MODE_IBSS;
+
+ if (capabilities & IEEE80211_CAP_PRIVACY)
+ bss->privacy = TRUE;
+ } else if (g_strcmp0(key, "Mode") == 0) {
+ const char *mode = NULL;
+
+ dbus_message_iter_get_basic(iter, &mode);
+ bss->mode = string2mode(mode);
+ } else if (g_strcmp0(key, "Frequency") == 0) {
+ dbus_uint16_t frequency = 0;
+
+ dbus_message_iter_get_basic(iter, &frequency);
+ bss->frequency = frequency;
+ } else if (g_strcmp0(key, "Signal") == 0) {
+ dbus_int16_t signal = 0;
+
+ dbus_message_iter_get_basic(iter, &signal);
+
+ bss->signal = signal;
+ if (!bss->signal)
+ bss->signal = BSS_UNKNOWN_STRENGTH;
+
+ } else if (g_strcmp0(key, "Level") == 0) {
+ dbus_int32_t level = 0;
+
+ dbus_message_iter_get_basic(iter, &level);
+ } else if (g_strcmp0(key, "Rates") == 0) {
+ supplicant_dbus_array_foreach(iter, bss_rates, bss);
+ } else if (g_strcmp0(key, "MaxRate") == 0) {
+ dbus_uint32_t maxrate = 0;
+
+ dbus_message_iter_get_basic(iter, &maxrate);
+ if (maxrate != 0)
+ bss->maxrate = maxrate;
+ } else if (g_strcmp0(key, "Privacy") == 0) {
+ dbus_bool_t privacy = FALSE;
+
+ dbus_message_iter_get_basic(iter, &privacy);
+ bss->privacy = privacy;
+ } else if (g_strcmp0(key, "RSN") == 0) {
+ bss->rsn_selected = TRUE;
+
+ supplicant_dbus_property_foreach(iter, bss_wpa, bss);
+ } else if (g_strcmp0(key, "WPA") == 0) {
+ bss->rsn_selected = FALSE;
+
+ supplicant_dbus_property_foreach(iter, bss_wpa, bss);
+ } else if (g_strcmp0(key, "IEs") == 0)
+ bss_process_ies(iter, bss);
+ else
+ SUPPLICANT_DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static struct g_supplicant_bss *interface_bss_added(DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ GSupplicantNetwork *network;
+ struct g_supplicant_bss *bss;
+ const char *path = NULL;
+
+ SUPPLICANT_DBG("");
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return NULL;
+
+ if (g_strcmp0(path, "/") == 0)
+ return NULL;
+
+ SUPPLICANT_DBG("%s", path);
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (network) {
+ bss = g_hash_table_lookup(network->bss_table, path);
+ if (bss)
+ return NULL;
+ }
+
+ bss = g_try_new0(struct g_supplicant_bss, 1);
+ if (!bss)
+ return NULL;
+
+ bss->interface = interface;
+ bss->path = g_strdup(path);
+ bss->signal = BSS_UNKNOWN_STRENGTH;
+
+ return bss;
+}
+
+static void interface_bss_added_with_keys(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct g_supplicant_bss *bss;
+
+ SUPPLICANT_DBG("");
+
+ bss = interface_bss_added(iter, user_data);
+ if (!bss)
+ return;
+
+ dbus_message_iter_next(iter);
+
+ if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_INVALID)
+ return;
+
+ supplicant_dbus_property_foreach(iter, bss_property, bss);
+
+ bss_compute_security(bss);
+ add_or_replace_bss_to_network(bss);
+}
+
+static void interface_bss_added_without_keys(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct g_supplicant_bss *bss;
+
+ SUPPLICANT_DBG("");
+
+ bss = interface_bss_added(iter, user_data);
+ if (!bss)
+ return;
+
+ supplicant_dbus_property_get_all(bss->path,
+ SUPPLICANT_INTERFACE ".BSS",
+ bss_property, bss, NULL);
+
+ bss_compute_security(bss);
+ add_or_replace_bss_to_network(bss);
+}
+
+static void update_signal(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct g_supplicant_bss *bss = value;
+ GSupplicantNetwork *network = user_data;
+
+ if (bss->signal > network->signal) {
+ network->signal = bss->signal;
+ network->best_bss = bss;
+ }
+}
+
+static void update_network_signal(GSupplicantNetwork *network)
+{
+ if (g_hash_table_size(network->bss_table) <= 1 && network->best_bss)
+ return;
+
+ g_hash_table_foreach(network->bss_table,
+ update_signal, network);
+
+ SUPPLICANT_DBG("New network signal %d", network->signal);
+}
+
+static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ GSupplicantNetwork *network;
+ struct g_supplicant_bss *bss = NULL;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (!network)
+ return;
+
+ bss = g_hash_table_lookup(network->bss_table, path);
+ if (network->best_bss == bss) {
+ network->best_bss = NULL;
+ network->signal = BSS_UNKNOWN_STRENGTH;
+ }
+
+ g_hash_table_remove(bss_mapping, path);
+
+ g_hash_table_remove(interface->bss_mapping, path);
+ g_hash_table_remove(network->bss_table, path);
+
+ update_network_signal(network);
+
+ if (g_hash_table_size(network->bss_table) == 0)
+ g_hash_table_remove(interface->network_table, network->group);
+}
+
+static void set_config_methods(DBusMessageIter *iter, void *user_data)
+{
+ const char *config_methods = "push_button";
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &config_methods);
+}
+
+static void interface_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+
+ if (!interface)
+ return;
+
+ SUPPLICANT_DBG("%s", key);
+
+ if (!key) {
+ debug_strvalmap("KeyMgmt capability", keymgmt_map,
+ interface->keymgmt_capa);
+ debug_strvalmap("AuthAlg capability", authalg_capa_map,
+ interface->authalg_capa);
+ debug_strvalmap("Protocol capability", proto_capa_map,
+ interface->proto_capa);
+ debug_strvalmap("Pairwise capability", pairwise_map,
+ interface->pairwise_capa);
+ debug_strvalmap("Group capability", group_map,
+ interface->group_capa);
+ debug_strvalmap("Scan capability", scan_capa_map,
+ interface->scan_capa);
+ debug_strvalmap("Mode capability", mode_capa_map,
+ interface->mode_capa);
+
+
+ supplicant_dbus_property_set(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.WPS",
+ "ConfigMethods", DBUS_TYPE_STRING_AS_STRING,
+ set_config_methods, NULL, NULL, NULL);
+
+ if (interface->ready)
+ callback_interface_added(interface);
+
+ return;
+ }
+
+ if (g_strcmp0(key, "Capabilities") == 0) {
+ supplicant_dbus_property_foreach(iter, interface_capability,
+ interface);
+ if (interface->mode_capa & G_SUPPLICANT_CAPABILITY_MODE_P2P)
+ interface->p2p_support = true;
+ } else if (g_strcmp0(key, "State") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ if (string2state(str) != interface->state) {
+ interface->state = string2state(str);
+ callback_interface_state(interface);
+ }
+
+ if (interface->ap_create_in_progress) {
+ if (interface->state == G_SUPPLICANT_STATE_DISCONNECTED)
+ callback_ap_create_fail(interface);
+
+ interface->ap_create_in_progress = false;
+ }
+
+ if (interface->state == G_SUPPLICANT_STATE_DISABLED)
+ interface->ready = FALSE;
+ else
+ interface->ready = TRUE;
+
+ SUPPLICANT_DBG("state %s (%d)", str, interface->state);
+ } else if (g_strcmp0(key, "Scanning") == 0) {
+ dbus_bool_t scanning = FALSE;
+
+ dbus_message_iter_get_basic(iter, &scanning);
+ interface->scanning = scanning;
+
+ if (interface->ready) {
+ if (interface->scanning)
+ callback_scan_started(interface);
+ else
+ callback_scan_finished(interface);
+ }
+ } else if (g_strcmp0(key, "ApScan") == 0) {
+ int apscan = 1;
+
+ dbus_message_iter_get_basic(iter, &apscan);
+ interface->apscan = apscan;
+ } else if (g_strcmp0(key, "Ifname") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str) {
+ g_free(interface->ifname);
+ interface->ifname = g_strdup(str);
+ }
+ } else if (g_strcmp0(key, "Driver") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str) {
+ g_free(interface->driver);
+ interface->driver = g_strdup(str);
+ }
+ } else if (g_strcmp0(key, "BridgeIfname") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str) {
+ g_free(interface->bridge);
+ interface->bridge = g_strdup(str);
+ }
+ } else if (g_strcmp0(key, "CurrentBSS") == 0) {
+ interface_bss_added_without_keys(iter, interface);
+ } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
+ interface_network_added(iter, interface);
+ } else if (g_strcmp0(key, "BSSs") == 0) {
+ supplicant_dbus_array_foreach(iter,
+ interface_bss_added_without_keys,
+ interface);
+ } else if (g_strcmp0(key, "Blobs") == 0) {
+ /* Nothing */
+ } else if (g_strcmp0(key, "Networks") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_network_added,
+ interface);
+ } else if (g_strcmp0(key, "DisconnectReason") == 0) {
+ int reason;
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ dbus_message_iter_get_basic(iter, &reason);
+ if (callbacks_pointer && callbacks_pointer->update_disconnect_reasoncode && reason != 0) {
+ callbacks_pointer->update_disconnect_reasoncode(interface, reason);
+ }
+ }
+ } else if (g_strcmp0(key, "AssocStatusCode") == 0) {
+ int status_code;
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ dbus_message_iter_get_basic(iter, &status_code);
+ if (callbacks_pointer && callbacks_pointer->update_assoc_status_code) {
+ callbacks_pointer->update_assoc_status_code(interface, status_code);
+ }
+ }
+ } else {
+ SUPPLICANT_DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+ }
+}
+
+static void scan_network_update(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+ GSupplicantNetwork *network;
+ char *path;
+
+ if (!iter)
+ return;
+
+ dbus_message_iter_get_basic(iter, &path);
+
+ if (!path)
+ return;
+
+ if (g_strcmp0(path, "/") == 0)
+ return;
+
+ /* Update the network details based on scan BSS data */
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (network)
+ callback_network_added(network);
+}
+
+static void scan_bss_data(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+
+ if (iter)
+ supplicant_dbus_array_foreach(iter, scan_network_update,
+ interface);
+
+ if (interface->scan_callback)
+ interface->scan_callback(0, interface, interface->scan_data);
+
+ interface->scan_callback = NULL;
+ interface->scan_data = NULL;
+}
+
+static GSupplicantInterface *interface_alloc(const char *path)
+{
+ GSupplicantInterface *interface;
+
+ interface = g_try_new0(GSupplicantInterface, 1);
+ if (!interface)
+ return NULL;
+
+ interface->path = g_strdup(path);
+
+ interface->network_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, NULL, remove_network);
+ interface->peer_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, NULL, remove_peer);
+ interface->group_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, NULL, remove_group);
+ interface->net_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ g_hash_table_replace(interface_table, interface->path, interface);
+
+ return interface;
+}
+
+static void interface_added(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantInterface *interface;
+ const char *path = NULL;
+
+ SUPPLICANT_DBG("");
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ if (g_strcmp0(path, "/") == 0)
+ return;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (interface)
+ return;
+
+ interface = interface_alloc(path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ supplicant_dbus_property_foreach(iter, interface_property,
+ interface);
+ interface_property(NULL, NULL, interface);
+ return;
+ }
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface",
+ interface_property, interface,
+ interface);
+}
+
+static void interface_removed(DBusMessageIter *iter, void *user_data)
+{
+ const char *path = NULL;
+ GSupplicantInterface *interface = user_data;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ g_supplicant_interface_cancel(interface);
+
+ g_hash_table_remove(interface_table, path);
+}
+
+static void eap_method(DBusMessageIter *iter, void *user_data)
+{
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; eap_method_map[i].str; i++)
+ if (strcmp(str, eap_method_map[i].str) == 0) {
+ eap_methods |= eap_method_map[i].val;
+ break;
+ }
+}
+
+static void service_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ if (!key) {
+ callback_system_ready();
+ return;
+ }
+
+ if (g_strcmp0(key, "DebugLevel") == 0) {
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ for (i = 0; debug_strings[i]; i++)
+ if (g_strcmp0(debug_strings[i], str) == 0) {
+ debug_level = i;
+ break;
+ }
+ SUPPLICANT_DBG("Debug level %d", debug_level);
+ } else if (g_strcmp0(key, "DebugTimestamp") == 0) {
+ dbus_message_iter_get_basic(iter, &debug_timestamp);
+ SUPPLICANT_DBG("Debug timestamp %u", debug_timestamp);
+ } else if (g_strcmp0(key, "DebugShowKeys") == 0) {
+ dbus_message_iter_get_basic(iter, &debug_showkeys);
+ SUPPLICANT_DBG("Debug show keys %u", debug_showkeys);
+ } else if (g_strcmp0(key, "Interfaces") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_added, NULL);
+ } else if (g_strcmp0(key, "EapMethods") == 0) {
+ supplicant_dbus_array_foreach(iter, eap_method, NULL);
+ debug_strvalmap("EAP method", eap_method_map, eap_methods);
+ } else if (g_strcmp0(key, "Country") == 0) {
+ const char *country = NULL;
+
+ dbus_message_iter_get_basic(iter, &country);
+ SUPPLICANT_DBG("Country %s", country);
+ } else
+ SUPPLICANT_DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static void signal_name_owner_changed(const char *path, DBusMessageIter *iter)
+{
+ const char *name = NULL, *old = NULL, *new = NULL;
+
+ SUPPLICANT_DBG("");
+
+ if (g_strcmp0(path, DBUS_PATH_DBUS) != 0)
+ return;
+
+ dbus_message_iter_get_basic(iter, &name);
+ if (!name)
+ return;
+
+ if (g_strcmp0(name, SUPPLICANT_SERVICE) != 0)
+ return;
+
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &old);
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &new);
+
+ if (!old || !new)
+ return;
+
+ if (strlen(old) > 0 && strlen(new) == 0) {
+ system_available = FALSE;
+ g_hash_table_remove_all(bss_mapping);
+ g_hash_table_remove_all(peer_mapping);
+ g_hash_table_remove_all(group_mapping);
+ g_hash_table_remove_all(interface_table);
+ callback_system_killed();
+ }
+
+ if (strlen(new) > 0 && strlen(old) == 0) {
+ system_available = TRUE;
+ supplicant_dbus_property_get_all(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ service_property, NULL, NULL);
+ }
+}
+
+static void signal_properties_changed(const char *path, DBusMessageIter *iter)
+{
+ SUPPLICANT_DBG("");
+
+ if (g_strcmp0(path, SUPPLICANT_PATH) != 0)
+ return;
+
+ supplicant_dbus_property_foreach(iter, service_property, NULL);
+}
+
+static void signal_interface_added(const char *path, DBusMessageIter *iter)
+{
+ SUPPLICANT_DBG("path %s %s", path, SUPPLICANT_PATH);
+
+ if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
+ interface_added(iter, NULL);
+}
+
+static void signal_interface_removed(const char *path, DBusMessageIter *iter)
+{
+ SUPPLICANT_DBG("");
+
+ if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
+ interface_removed(iter, NULL);
+}
+
+static void signal_interface_changed(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, interface_property, interface);
+}
+
+static void signal_scan_done(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ dbus_bool_t success = FALSE;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_get_basic(iter, &success);
+
+ if (interface->scanning) {
+ callback_scan_finished(interface);
+ interface->scanning = FALSE;
+ }
+
+ /*
+ * If scan is unsuccessful return -EIO else get the scanned BSSs
+ * and update the network details accordingly
+ */
+ if (!success) {
+ if (interface->scan_callback)
+ interface->scan_callback(-EIO, interface,
+ interface->scan_data);
+
+ interface->scan_callback = NULL;
+ interface->scan_data = NULL;
+
+ return;
+ }
+
+ supplicant_dbus_property_get(path, SUPPLICANT_INTERFACE ".Interface",
+ "BSSs", scan_bss_data, interface, interface);
+}
+
+static void signal_bss_added(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_bss_added_with_keys(iter, interface);
+}
+
+static void signal_bss_removed(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_bss_removed(iter, interface);
+}
+
+static void signal_network_added(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_network_added(iter, interface);
+}
+
+static void signal_network_removed(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_network_removed(iter, interface);
+}
+
+static void signal_bss_changed(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ GSupplicantNetwork *network;
+ GSupplicantSecurity old_security;
+ struct g_supplicant_bss *bss;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(bss_mapping, path);
+ if (!interface)
+ return;
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (!network)
+ return;
+
+ bss = g_hash_table_lookup(network->bss_table, path);
+ if (!bss)
+ return;
+
+ supplicant_dbus_property_foreach(iter, bss_property, bss);
+
+ old_security = network->security;
+ bss_compute_security(bss);
+
+ if (old_security != bss->security) {
+ struct g_supplicant_bss *new_bss;
+
+ SUPPLICANT_DBG("New network security for %s", bss->ssid);
+
+ /* Security change policy:
+ * - we first copy the current bss into a new one with
+ * its own pointer (path)
+ * - we remove the current bss related network which will
+ * tell the plugin about such removal. This is done due
+ * to the fact that a security change means a group change
+ * so a complete network change.
+ * (current bss becomes invalid as well)
+ * - we add the new bss: it adds new network and tell the
+ * plugin about it. */
+
+ new_bss = g_try_new0(struct g_supplicant_bss, 1);
+ if (!new_bss)
+ return;
+
+ memcpy(new_bss, bss, sizeof(struct g_supplicant_bss));
+ new_bss->path = g_strdup(bss->path);
+
+ g_hash_table_remove(interface->network_table, network->group);
+
+ add_or_replace_bss_to_network(new_bss);
+
+ return;
+ }
+
+ if (bss->signal == network->signal)
+ return;
+
+ /*
+ * If the new signal is lower than the SSID signal, we need
+ * to check for the new maximum.
+ */
+ if (bss->signal < network->signal) {
+ if (bss != network->best_bss)
+ return;
+ network->signal = bss->signal;
+ update_network_signal(network);
+ } else {
+ network->signal = bss->signal;
+ network->best_bss = bss;
+ }
+
+ SUPPLICANT_DBG("New network signal for %s %d dBm", network->ssid,
+ network->signal);
+
+ callback_network_changed(network, "Signal");
+}
+
+static void wps_credentials(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+
+ if (!key)
+ return;
+
+ SUPPLICANT_DBG("key %s", key);
+
+ if (g_strcmp0(key, "Key") == 0) {
+ DBusMessageIter array;
+ unsigned char *key_val;
+ int key_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &key_val, &key_len);
+
+ g_free(interface->wps_cred.key);
+ interface->wps_cred.key = g_try_malloc0(
+ sizeof(char) * key_len + 1);
+
+ if (!interface->wps_cred.key)
+ return;
+
+ memcpy(interface->wps_cred.key, key_val,
+ sizeof(char) * key_len);
+
+ SUPPLICANT_DBG("WPS key present");
+ } else if (g_strcmp0(key, "SSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *ssid;
+ int ssid_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
+
+ if (ssid_len > 0 && ssid_len < 33) {
+ memcpy(interface->wps_cred.ssid, ssid, ssid_len);
+ interface->wps_cred.ssid_len = ssid_len;
+ } else {
+ memset(interface->wps_cred.ssid, 0, 32);
+ interface->wps_cred.ssid_len = 0;
+ }
+ }
+}
+
+static void signal_wps_credentials(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, wps_credentials, interface);
+}
+
+static void wps_event_args(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantInterface *interface = user_data;
+
+ if (!key || !interface)
+ return;
+
+ SUPPLICANT_DBG("Arg Key %s", key);
+}
+
+static void signal_wps_event(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ const char *name = NULL;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_get_basic(iter, &name);
+
+ SUPPLICANT_DBG("Name: %s", name);
+
+ if (g_strcmp0(name, "success") == 0)
+ interface->wps_state = G_SUPPLICANT_WPS_STATE_SUCCESS;
+ else if (g_strcmp0(name, "fail") == 0)
+ interface->wps_state = G_SUPPLICANT_WPS_STATE_FAIL;
+ else
+ interface->wps_state = G_SUPPLICANT_WPS_STATE_UNKNOWN;
+
+ if (!dbus_message_iter_has_next(iter))
+ return;
+
+ dbus_message_iter_next(iter);
+
+ supplicant_dbus_property_foreach(iter, wps_event_args, interface);
+}
+
+static void create_peer_identifier(GSupplicantPeer *peer)
+{
+ const unsigned char test[ETH_ALEN] = {};
+
+ if (!peer)
+ return;
+
+ if (!memcmp(peer->device_address, test, ETH_ALEN)) {
+ peer->identifier = g_strdup(peer->name);
+ return;
+ }
+
+ peer->identifier = g_malloc0(19);
+ snprintf(peer->identifier, 19, "%02x%02x%02x%02x%02x%02x",
+ peer->device_address[0],
+ peer->device_address[1],
+ peer->device_address[2],
+ peer->device_address[3],
+ peer->device_address[4],
+ peer->device_address[5]);
+}
+
+struct peer_property_data {
+ GSupplicantPeer *peer;
+ GSList *old_groups;
+ bool groups_changed;
+ bool services_changed;
+};
+
+static void peer_groups_relation(DBusMessageIter *iter, void *user_data)
+{
+ struct peer_property_data *data = user_data;
+ GSupplicantPeer *peer = data->peer;
+ GSupplicantGroup *group;
+ const char *str = NULL;
+ GSList *elem;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ group = g_hash_table_lookup(group_mapping, str);
+ if (!group)
+ return;
+
+ elem = g_slist_find_custom(data->old_groups, str, (GCompareFunc)g_strcmp0);
+ if (elem) {
+ data->old_groups = g_slist_remove_link(data->old_groups, elem);
+ peer->groups = g_slist_concat(elem, peer->groups);
+ } else {
+ peer->groups = g_slist_prepend(peer->groups, g_strdup(str));
+ data->groups_changed = true;
+ }
+}
+
+static void peer_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantPeer *pending_peer;
+ struct peer_property_data *data = user_data;
+ GSupplicantPeer *peer = data->peer;
+
+ SUPPLICANT_DBG("key: %s", key);
+
+ if (!peer->interface)
+ return;
+
+ if (!key) {
+ if (peer->name) {
+ create_peer_identifier(peer);
+ callback_peer_found(peer);
+ pending_peer = g_hash_table_lookup(
+ pending_peer_connection, peer->path);
+
+ if (pending_peer && pending_peer == peer) {
+ callback_peer_request(peer);
+ g_hash_table_remove(pending_peer_connection,
+ peer->path);
+ }
+
+ dbus_free(data);
+ }
+
+ return;
+ }
+
+ if (g_strcmp0(key, "DeviceAddress") == 0) {
+ unsigned char *dev_addr;
+ DBusMessageIter array;
+ int len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &dev_addr, &len);
+
+ if (len == ETH_ALEN)
+ memcpy(peer->device_address, dev_addr, len);
+ } else if (g_strcmp0(key, "DeviceName") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ peer->name = g_strdup(str);
+ } else if (g_strcmp0(key, "config_method") == 0) {
+ uint16_t wps_config;
+
+ dbus_message_iter_get_basic(iter, &wps_config);
+
+ if (wps_config & G_SUPPLICANT_WPS_CONFIG_PBC)
+ peer->wps_capabilities |= G_SUPPLICANT_WPS_PBC;
+ if (wps_config & ~G_SUPPLICANT_WPS_CONFIG_PBC)
+ peer->wps_capabilities |= G_SUPPLICANT_WPS_PIN;
+ } else if (g_strcmp0(key, "Groups") == 0) {
+ data->old_groups = peer->groups;
+ peer->groups = NULL;
+
+ supplicant_dbus_array_foreach(iter,
+ peer_groups_relation, data);
+ if (g_slist_length(data->old_groups) > 0) {
+ g_slist_free_full(data->old_groups, g_free);
+ data->groups_changed = true;
+ }
+ } else if (g_strcmp0(key, "IEs") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+
+ if (!ie || ie_len < 2)
+ return;
+
+ if (peer->widi_ies) {
+ if (memcmp(peer->widi_ies, ie, ie_len) == 0)
+ return;
+
+ g_free(peer->widi_ies);
+ peer->widi_ies_length = 0;
+ }
+
+ peer->widi_ies = g_malloc0(ie_len * sizeof(unsigned char));
+
+ memcpy(peer->widi_ies, ie, ie_len);
+ peer->widi_ies_length = ie_len;
+ data->services_changed = true;
+ }
+}
+
+static void signal_peer_found(const char *path, DBusMessageIter *iter)
+{
+ struct peer_property_data *property_data;
+ GSupplicantInterface *interface;
+ const char *obj_path = NULL;
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_get_basic(iter, &obj_path);
+ if (!obj_path || g_strcmp0(obj_path, "/") == 0)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, obj_path);
+ if (peer)
+ return;
+
+ peer = g_try_new0(GSupplicantPeer, 1);
+ if (!peer)
+ return;
+
+ peer->interface = interface;
+ peer->path = g_strdup(obj_path);
+ g_hash_table_insert(interface->peer_table, peer->path, peer);
+ g_hash_table_replace(peer_mapping, peer->path, interface);
+
+ property_data = dbus_malloc0(sizeof(struct peer_property_data));
+ property_data->peer = peer;
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ supplicant_dbus_property_foreach(iter, peer_property,
+ property_data);
+ peer_property(NULL, NULL, property_data);
+ return;
+ }
+
+ supplicant_dbus_property_get_all(obj_path,
+ SUPPLICANT_INTERFACE ".Peer",
+ peer_property, property_data, NULL);
+}
+
+static void signal_peer_lost(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ const char *obj_path = NULL;
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_get_basic(iter, &obj_path);
+ if (!obj_path || g_strcmp0(obj_path, "/") == 0)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, obj_path);
+ if (!peer)
+ return;
+
+ g_hash_table_remove(interface->peer_table, obj_path);
+}
+
+static void signal_peer_changed(const char *path, DBusMessageIter *iter)
+{
+ struct peer_property_data *property_data;
+ GSupplicantInterface *interface;
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(peer_mapping, path);
+ if (!interface)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, path);
+ if (!peer) {
+ g_hash_table_remove(peer_mapping, path);
+ return;
+ }
+
+ property_data = dbus_malloc0(sizeof(struct peer_property_data));
+ property_data->peer = peer;
+
+ supplicant_dbus_property_foreach(iter, peer_property, property_data);
+ if (property_data->services_changed)
+ callback_peer_changed(peer,
+ G_SUPPLICANT_PEER_SERVICES_CHANGED);
+
+ if (property_data->groups_changed)
+ callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_CHANGED);
+
+ dbus_free(property_data);
+
+ if (!g_supplicant_peer_is_in_a_group(peer))
+ peer->connection_requested = false;
+}
+
+struct group_sig_data {
+ const char *peer_obj_path;
+ unsigned char iface_address[ETH_ALEN];
+ const char *interface_obj_path;
+ const char *group_obj_path;
+ int role;
+};
+
+static void group_sig_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct group_sig_data *data = user_data;
+
+ if (!key)
+ return;
+
+ if (g_strcmp0(key, "peer_interface_addr") == 0) {
+ unsigned char *dev_addr;
+ DBusMessageIter array;
+ int len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &dev_addr, &len);
+
+ if (len == ETH_ALEN)
+ memcpy(data->iface_address, dev_addr, len);
+ } else if (g_strcmp0(key, "role") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (g_strcmp0(str, "GO") == 0)
+ data->role = G_SUPPLICANT_GROUP_ROLE_GO;
+ else
+ data->role = G_SUPPLICANT_GROUP_ROLE_CLIENT;
+ } else if (g_strcmp0(key, "peer_object") == 0)
+ dbus_message_iter_get_basic(iter, &data->peer_obj_path);
+ else if (g_strcmp0(key, "interface_object") == 0)
+ dbus_message_iter_get_basic(iter, &data->interface_obj_path);
+ else if (g_strcmp0(key, "group_object") == 0)
+ dbus_message_iter_get_basic(iter, &data->group_obj_path);
+
+}
+
+static void signal_group_success(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ struct group_sig_data data = {};
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, group_sig_property, &data);
+ if (!data.peer_obj_path)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, data.peer_obj_path);
+ if (!peer)
+ return;
+
+ memcpy(peer->iface_address, data.iface_address, ETH_ALEN);
+ interface->pending_peer_path = peer->path;
+}
+
+static void signal_group_failure(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ struct group_sig_data data = {};
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, group_sig_property, &data);
+ if (!data.peer_obj_path)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, data.peer_obj_path);
+ if (!peer)
+ return;
+
+ callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_FAILED);
+ peer->connection_requested = false;
+}
+
+static void signal_group_started(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface, *g_interface;
+ struct group_sig_data data = {};
+ GSupplicantGroup *group;
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, group_sig_property, &data);
+ if (!data.interface_obj_path || !data.group_obj_path)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table,
+ interface->pending_peer_path);
+ interface->pending_peer_path = NULL;
+ if (!peer)
+ return;
+
+ g_interface = g_hash_table_lookup(interface_table,
+ data.interface_obj_path);
+ if (!g_interface)
+ return;
+
+ group = g_hash_table_lookup(interface->group_table,
+ data.group_obj_path);
+ if (group)
+ return;
+
+ group = g_try_new0(GSupplicantGroup, 1);
+ if (!group)
+ return;
+
+ group->interface = g_interface;
+ group->orig_interface = interface;
+ group->path = g_strdup(data.group_obj_path);
+ group->role = data.role;
+
+ g_hash_table_insert(interface->group_table, group->path, group);
+ g_hash_table_replace(group_mapping, group->path, group);
+
+ peer->current_group_iface = g_interface;
+ callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_STARTED);
+}
+
+static void remove_peer_group_interface(GHashTable *group_table,
+ const char* path)
+{
+ GSupplicantGroup *group;
+ GHashTableIter iter;
+ gpointer value, key;
+
+ if (!group_table)
+ return;
+
+ group = g_hash_table_lookup(group_table, path);
+
+ if (!group || !group->orig_interface)
+ return;
+
+ g_hash_table_iter_init(&iter, group->orig_interface->peer_table);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ GSupplicantPeer *peer = value;
+
+ if (peer->current_group_iface == group->interface)
+ peer->current_group_iface = NULL;
+ }
+}
+
+static void signal_group_finished(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ struct group_sig_data data = {};
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, group_sig_property, &data);
+ if (!data.interface_obj_path || !data.group_obj_path)
+ return;
+
+ remove_peer_group_interface(interface->group_table, data.group_obj_path);
+
+ g_hash_table_remove(group_mapping, data.group_obj_path);
+
+ g_hash_table_remove(interface->group_table, data.group_obj_path);
+}
+
+static void signal_group_request(const char *path, DBusMessageIter *iter)
+{
+ GSupplicantInterface *interface;
+ GSupplicantPeer *peer;
+ const char *obj_path;
+
+ SUPPLICANT_DBG("");
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_get_basic(iter, &obj_path);
+ if (!obj_path || !g_strcmp0(obj_path, "/"))
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, obj_path);
+ if (!peer)
+ return;
+
+ /*
+ * Peer has been previously found and property set,
+ * otherwise, defer connection to when peer property
+ * is set.
+ */
+ if (peer->identifier)
+ callback_peer_request(peer);
+ else
+ g_hash_table_replace(pending_peer_connection, peer->path, peer);
+}
+
+static void signal_group_peer_joined(const char *path, DBusMessageIter *iter)
+{
+ const char *peer_path = NULL;
+ GSupplicantInterface *interface;
+ GSupplicantGroup *group;
+ GSupplicantPeer *peer;
+
+ SUPPLICANT_DBG("");
+
+ group = g_hash_table_lookup(group_mapping, path);
+ if (!group)
+ return;
+
+ dbus_message_iter_get_basic(iter, &peer_path);
+ if (!peer_path)
+ return;
+
+ interface = g_hash_table_lookup(peer_mapping, peer_path);
+ if (!interface)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, peer_path);
+ if (!peer)
+ return;
+
+ group->members = g_slist_prepend(group->members, g_strdup(peer_path));
+
+ callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_JOINED);
+}
+
+static void signal_group_peer_disconnected(const char *path, DBusMessageIter *iter)
+{
+ const char *peer_path = NULL;
+ GSupplicantInterface *interface;
+ GSupplicantGroup *group;
+ GSupplicantPeer *peer;
+ GSList *elem;
+
+ SUPPLICANT_DBG("");
+
+ group = g_hash_table_lookup(group_mapping, path);
+ if (!group)
+ return;
+
+ dbus_message_iter_get_basic(iter, &peer_path);
+ if (!peer_path)
+ return;
+
+ for (elem = group->members; elem; elem = elem->next) {
+ if (!g_strcmp0(elem->data, peer_path))
+ break;
+ }
+
+ if (!elem)
+ return;
+
+ g_free(elem->data);
+ group->members = g_slist_delete_link(group->members, elem);
+
+ interface = g_hash_table_lookup(peer_mapping, peer_path);
+ if (!interface)
+ return;
+
+ peer = g_hash_table_lookup(interface->peer_table, peer_path);
+ if (!peer)
+ return;
+
+ callback_peer_changed(peer, G_SUPPLICANT_PEER_GROUP_DISCONNECTED);
+ peer->connection_requested = false;
+}
+
+static struct {
+ const char *interface;
+ const char *member;
+ void (*function) (const char *path, DBusMessageIter *iter);
+} signal_map[] = {
+ { DBUS_INTERFACE_DBUS, "NameOwnerChanged", signal_name_owner_changed },
+
+ { SUPPLICANT_INTERFACE, "PropertiesChanged", signal_properties_changed },
+ { SUPPLICANT_INTERFACE, "InterfaceAdded", signal_interface_added },
+ { SUPPLICANT_INTERFACE, "InterfaceCreated", signal_interface_added },
+ { SUPPLICANT_INTERFACE, "InterfaceRemoved", signal_interface_removed },
+
+ { SUPPLICANT_INTERFACE ".Interface", "PropertiesChanged", signal_interface_changed },
+ { SUPPLICANT_INTERFACE ".Interface", "ScanDone", signal_scan_done },
+ { SUPPLICANT_INTERFACE ".Interface", "BSSAdded", signal_bss_added },
+ { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved", signal_bss_removed },
+ { SUPPLICANT_INTERFACE ".Interface", "NetworkAdded", signal_network_added },
+ { SUPPLICANT_INTERFACE ".Interface", "NetworkRemoved", signal_network_removed },
+
+ { SUPPLICANT_INTERFACE ".BSS", "PropertiesChanged", signal_bss_changed },
+
+ { SUPPLICANT_INTERFACE ".Interface.WPS", "Credentials", signal_wps_credentials },
+ { SUPPLICANT_INTERFACE ".Interface.WPS", "Event", signal_wps_event },
+
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeviceFound", signal_peer_found },
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeviceLost", signal_peer_lost },
+
+ { SUPPLICANT_INTERFACE ".Peer", "PropertiesChanged", signal_peer_changed },
+
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationSuccess", signal_group_success },
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationFailure", signal_group_failure },
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GroupStarted", signal_group_started },
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GroupFinished", signal_group_finished },
+ { SUPPLICANT_INTERFACE ".Interface.P2PDevice", "GONegotiationRequest", signal_group_request },
+
+ { SUPPLICANT_INTERFACE ".Group", "PeerJoined", signal_group_peer_joined },
+ { SUPPLICANT_INTERFACE ".Group", "PeerDisconnected", signal_group_peer_disconnected },
+
+ { }
+};
+
+static DBusHandlerResult g_supplicant_filter(DBusConnection *conn,
+ DBusMessage *message, void *data)
+{
+ DBusMessageIter iter;
+ const char *path;
+ int i;
+
+ path = dbus_message_get_path(message);
+ if (!path)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ for (i = 0; signal_map[i].interface; i++) {
+ if (!dbus_message_has_interface(message, signal_map[i].interface))
+ continue;
+
+ if (!dbus_message_has_member(message, signal_map[i].member))
+ continue;
+
+ signal_map[i].function(path, &iter);
+ break;
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+void g_supplicant_interface_cancel(GSupplicantInterface *interface)
+{
+ SUPPLICANT_DBG("Cancelling any pending DBus calls");
+ supplicant_dbus_method_call_cancel_all(interface);
+ supplicant_dbus_property_call_cancel_all(interface);
+}
+
+struct supplicant_regdom {
+ GSupplicantCountryCallback callback;
+ const char *alpha2;
+ const void *user_data;
+};
+
+static void country_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_regdom *regdom = user_data;
+ int result = 0;
+
+ SUPPLICANT_DBG("Country setting result");
+
+ if (!user_data)
+ return;
+
+ if (error) {
+ SUPPLICANT_DBG("Country setting failure %s", error);
+ result = -EINVAL;
+ }
+
+ if (regdom->callback)
+ regdom->callback(result, regdom->alpha2,
+ (void *) regdom->user_data);
+
+ g_free(regdom);
+}
+
+static void country_params(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_regdom *regdom = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ ®dom->alpha2);
+}
+
+int g_supplicant_set_country(const char *alpha2,
+ GSupplicantCountryCallback callback,
+ const void *user_data)
+{
+ struct supplicant_regdom *regdom;
+
+ SUPPLICANT_DBG("Country setting %s", alpha2);
+
+ if (!system_available)
+ return -EFAULT;
+
+ regdom = dbus_malloc0(sizeof(*regdom));
+ if (!regdom)
+ return -ENOMEM;
+
+ regdom->callback = callback;
+ regdom->alpha2 = alpha2;
+ regdom->user_data = user_data;
+
+ return supplicant_dbus_property_set(SUPPLICANT_PATH, SUPPLICANT_INTERFACE,
+ "Country", DBUS_TYPE_STRING_AS_STRING,
+ country_params, country_result,
+ regdom, NULL);
+}
+
+int g_supplicant_interface_set_country(GSupplicantInterface *interface,
+ GSupplicantCountryCallback callback,
+ const char *alpha2,
+ void *user_data)
+{
+ struct supplicant_regdom *regdom;
+
+ regdom = dbus_malloc0(sizeof(*regdom));
+ if (!regdom)
+ return -ENOMEM;
+
+ regdom->callback = callback;
+ regdom->alpha2 = alpha2;
+ regdom->user_data = user_data;
+
+ return supplicant_dbus_property_set(interface->path,
+ SUPPLICANT_INTERFACE ".Interface",
+ "Country", DBUS_TYPE_STRING_AS_STRING,
+ country_params, country_result,
+ regdom, NULL);
+}
+
+bool g_supplicant_interface_has_p2p(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return false;
+
+ return interface->p2p_support;
+}
+
+struct supplicant_p2p_dev_config {
+ char *device_name;
+ char *dev_type;
+};
+
+static void p2p_device_config_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_p2p_dev_config *config = user_data;
+
+ if (error)
+ SUPPLICANT_DBG("Unable to set P2P Device configuration: %s",
+ error);
+
+ g_free(config->device_name);
+ g_free(config->dev_type);
+ dbus_free(config);
+}
+
+static int dev_type_str2bin(const char *type, unsigned char dev_type[8])
+{
+ int length, pos, end;
+ char b[3] = {};
+ char *e = NULL;
+
+ end = strlen(type);
+ for (length = pos = 0; type[pos] != '\0' && length < 8; length++) {
+ if (pos+2 > end)
+ return 0;
+
+ b[0] = type[pos];
+ b[1] = type[pos+1];
+
+ dev_type[length] = strtol(b, &e, 16);
+ if (e && *e != '\0')
+ return 0;
+
+ pos += 2;
+ }
+
+ return 8;
+}
+
+static void p2p_device_config_params(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_p2p_dev_config *config = user_data;
+ DBusMessageIter dict;
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ supplicant_dbus_dict_append_basic(&dict, "DeviceName",
+ DBUS_TYPE_STRING, &config->device_name);
+
+ if (config->dev_type) {
+ unsigned char dev_type[8] = {}, *type;
+ int len;
+
+ len = dev_type_str2bin(config->dev_type, dev_type);
+ if (len) {
+ type = dev_type;
+ supplicant_dbus_dict_append_fixed_array(&dict,
+ "PrimaryDeviceType",
+ DBUS_TYPE_BYTE, &type, len);
+ }
+ }
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+int g_supplicant_interface_set_p2p_device_config(GSupplicantInterface *interface,
+ const char *device_name,
+ const char *primary_dev_type)
+{
+ struct supplicant_p2p_dev_config *config;
+ int ret;
+
+ SUPPLICANT_DBG("P2P Device settings %s/%s",
+ device_name, primary_dev_type);
+
+ config = dbus_malloc0(sizeof(*config));
+ if (!config)
+ return -ENOMEM;
+
+ config->device_name = g_strdup(device_name);
+ config->dev_type = g_strdup(primary_dev_type);
+
+ ret = supplicant_dbus_property_set(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice",
+ "P2PDeviceConfig",
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ p2p_device_config_params,
+ p2p_device_config_result, config, NULL);
+ if (ret < 0) {
+ g_free(config->device_name);
+ g_free(config->dev_type);
+ dbus_free(config);
+ SUPPLICANT_DBG("Unable to set P2P Device configuration");
+ }
+
+ return ret;
+}
+
+static gboolean peer_lookup_by_identifier(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ const GSupplicantPeer *peer = value;
+ const char *identifier = user_data;
+
+ if (!g_strcmp0(identifier, peer->identifier))
+ return TRUE;
+
+ return FALSE;
+}
+
+GSupplicantPeer *g_supplicant_interface_peer_lookup(GSupplicantInterface *interface,
+ const char *identifier)
+{
+ GSupplicantPeer *peer;
+
+ peer = g_hash_table_find(interface->peer_table,
+ peer_lookup_by_identifier,
+ (void *) identifier);
+ return peer;
+}
+
+static void interface_create_data_free(struct interface_create_data *data)
+{
+ g_free(data->ifname);
+ g_free(data->driver);
+ g_free(data->bridge);
+ dbus_free(data);
+}
+
+static bool interface_exists(GSupplicantInterface *interface,
+ const char *path)
+{
+ GSupplicantInterface *tmp;
+
+ tmp = g_hash_table_lookup(interface_table, path);
+ if (tmp && tmp == interface)
+ return true;
+
+ return false;
+}
+
+static void interface_create_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ GSupplicantInterface *interface = data->interface;
+
+ if (!key) {
+ if (data->callback) {
+ data->callback(0, data->interface, data->user_data);
+ callback_p2p_support(interface);
+ }
+
+ interface_create_data_free(data);
+ }
+
+ interface_property(key, iter, interface);
+}
+
+static void interface_create_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ const char *path = NULL;
+ int err;
+
+ SUPPLICANT_DBG("");
+
+ if (error) {
+ g_warning("error %s", error);
+ err = -EIO;
+ goto done;
+ }
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ if (!system_available) {
+ err = -EFAULT;
+ goto done;
+ }
+
+ data->interface = g_hash_table_lookup(interface_table, path);
+ if (!data->interface) {
+ data->interface = interface_alloc(path);
+ if (!data->interface) {
+ err = -ENOMEM;
+ goto done;
+ }
+ }
+
+ err = supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface",
+ interface_create_property, data,
+ NULL);
+ if (err == 0)
+ return;
+
+done:
+ if (data->callback)
+ data->callback(err, NULL, data->user_data);
+
+ interface_create_data_free(data);
+}
+
+static void interface_create_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ DBusMessageIter dict;
+
+ SUPPLICANT_DBG("");
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ supplicant_dbus_dict_append_basic(&dict, "Ifname",
+ DBUS_TYPE_STRING, &data->ifname);
+
+ if (data->driver)
+ supplicant_dbus_dict_append_basic(&dict, "Driver",
+ DBUS_TYPE_STRING, &data->driver);
+
+ if (data->bridge)
+ supplicant_dbus_dict_append_basic(&dict, "BridgeIfname",
+ DBUS_TYPE_STRING, &data->bridge);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+static void interface_get_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ GSupplicantInterface *interface;
+ const char *path = NULL;
+ int err;
+
+ SUPPLICANT_DBG("");
+
+ if (error) {
+ SUPPLICANT_DBG("Interface not created yet");
+ goto create;
+ }
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface) {
+ err = -ENOENT;
+ goto done;
+ }
+
+ if (data->callback) {
+ data->callback(0, interface, data->user_data);
+ callback_p2p_support(interface);
+ }
+
+ interface_create_data_free(data);
+
+ return;
+
+create:
+ if (!system_available) {
+ err = -EFAULT;
+ goto done;
+ }
+
+ SUPPLICANT_DBG("Creating interface");
+
+ err = supplicant_dbus_method_call(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ "CreateInterface",
+ interface_create_params,
+ interface_create_result, data,
+ NULL);
+ if (err == 0)
+ return;
+
+done:
+ if (data->callback)
+ data->callback(err, NULL, data->user_data);
+
+ interface_create_data_free(data);
+}
+
+static void interface_get_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+
+ SUPPLICANT_DBG("");
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->ifname);
+}
+
+int g_supplicant_interface_create(const char *ifname, const char *driver,
+ const char *bridge,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_create_data *data;
+ int ret;
+
+ SUPPLICANT_DBG("ifname %s", ifname);
+
+ if (!ifname)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->ifname = g_strdup(ifname);
+ data->driver = g_strdup(driver);
+ data->bridge = g_strdup(bridge);
+ data->callback = callback;
+ data->user_data = user_data;
+
+ ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ "GetInterface",
+ interface_get_params,
+ interface_get_result, data,
+ NULL);
+ if (ret < 0)
+ interface_create_data_free(data);
+
+ return ret;
+}
+
+static void interface_remove_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_data *data = user_data;
+ int err;
+
+ if (error) {
+ err = -EIO;
+ goto done;
+ }
+
+ if (!system_available) {
+ err = -EFAULT;
+ goto done;
+ }
+
+ /*
+ * The gsupplicant interface is already freed by the InterfaceRemoved
+ * signal callback. Simply invoke the interface_data callback.
+ */
+ err = 0;
+
+done:
+ g_free(data->path);
+
+ if (data->callback)
+ data->callback(err, NULL, data->user_data);
+
+ dbus_free(data);
+}
+
+
+static void interface_remove_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_data *data = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+ &data->interface->path);
+}
+
+
+int g_supplicant_interface_remove(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_data *data;
+ int ret;
+
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ g_supplicant_interface_cancel(interface);
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->interface = interface;
+ data->path = g_strdup(interface->path);
+ data->callback = callback;
+ data->user_data = user_data;
+
+ ret = supplicant_dbus_method_call(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ "RemoveInterface",
+ interface_remove_params,
+ interface_remove_result, data,
+ NULL);
+ if (ret < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ }
+ return ret;
+}
+
+static void interface_scan_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_scan_data *data = user_data;
+ int err = 0;
+
+ if (error) {
+ SUPPLICANT_DBG("error %s", error);
+ err = -EIO;
+ }
+
+ /* A non ready interface cannot send/receive anything */
+ if (interface_exists(data->interface, data->path)) {
+ if (!data->interface->ready)
+ err = -ENOLINK;
+ }
+
+ g_free(data->path);
+
+ if (err != 0) {
+ if (data->callback)
+ data->callback(err, data->interface, data->user_data);
+ } else {
+ data->interface->scan_callback = data->callback;
+ data->interface->scan_data = data->user_data;
+ }
+
+ if (data->scan_params)
+ g_supplicant_free_scan_params(data->scan_params);
+
+ dbus_free(data);
+}
+
+static void add_scan_frequency(DBusMessageIter *iter, unsigned int freq)
+{
+ DBusMessageIter data;
+ unsigned int width = 0; /* Not used by wpa_supplicant atm */
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &data);
+
+ dbus_message_iter_append_basic(&data, DBUS_TYPE_UINT32, &freq);
+ dbus_message_iter_append_basic(&data, DBUS_TYPE_UINT32, &width);
+
+ dbus_message_iter_close_container(iter, &data);
+}
+
+static void add_scan_frequencies(DBusMessageIter *iter,
+ void *user_data)
+{
+ GSupplicantScanParams *scan_data = user_data;
+ unsigned int freq;
+ int i;
+
+ for (i = 0; i < scan_data->num_freqs; i++) {
+ freq = scan_data->freqs[i];
+ if (!freq)
+ break;
+
+ add_scan_frequency(iter, freq);
+ }
+}
+
+static void append_ssid(DBusMessageIter *iter,
+ const void *ssid, unsigned int len)
+{
+ DBusMessageIter array;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_BYTE_AS_STRING, &array);
+
+ dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
+ &ssid, len);
+ dbus_message_iter_close_container(iter, &array);
+}
+
+static void append_ssids(DBusMessageIter *iter, void *user_data)
+{
+ GSupplicantScanParams *scan_data = user_data;
+ GSList *list;
+
+ for (list = scan_data->ssids; list; list = list->next) {
+ struct scan_ssid *scan_ssid = list->data;
+
+ append_ssid(iter, scan_ssid->ssid, scan_ssid->ssid_len);
+ }
+}
+
+static void supplicant_add_scan_frequency(DBusMessageIter *dict,
+ supplicant_dbus_array_function function,
+ void *user_data)
+{
+ GSupplicantScanParams *scan_params = user_data;
+ DBusMessageIter entry, value, array;
+ const char *key = "Channels";
+
+ if (scan_params->freqs && scan_params->freqs[0] != 0) {
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_UINT32_AS_STRING
+ DBUS_TYPE_UINT32_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING,
+ &value);
+
+ dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_UINT32_AS_STRING
+ DBUS_TYPE_UINT32_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING,
+ &array);
+
+ if (function)
+ function(&array, user_data);
+
+ dbus_message_iter_close_container(&value, &array);
+ dbus_message_iter_close_container(&entry, &value);
+ dbus_message_iter_close_container(dict, &entry);
+ }
+}
+
+static void interface_scan_params(DBusMessageIter *iter, void *user_data)
+{
+ DBusMessageIter dict;
+ const char *type = "passive";
+ struct interface_scan_data *data = user_data;
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ if (data && data->scan_params) {
+ type = "active";
+
+ supplicant_dbus_dict_append_basic(&dict, "Type",
+ DBUS_TYPE_STRING, &type);
+
+ supplicant_dbus_dict_append_array(&dict, "SSIDs",
+ DBUS_TYPE_STRING,
+ append_ssids,
+ data->scan_params);
+
+ supplicant_add_scan_frequency(&dict, add_scan_frequencies,
+ data->scan_params);
+ } else
+ supplicant_dbus_dict_append_basic(&dict, "Type",
+ DBUS_TYPE_STRING, &type);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+static int interface_ready_to_scan(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ if (interface->scanning)
+ return -EALREADY;
+
+ switch (interface->state) {
+ case G_SUPPLICANT_STATE_AUTHENTICATING:
+ case G_SUPPLICANT_STATE_ASSOCIATING:
+ case G_SUPPLICANT_STATE_ASSOCIATED:
+ case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
+ case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
+ return -EBUSY;
+ case G_SUPPLICANT_STATE_UNKNOWN:
+ case G_SUPPLICANT_STATE_DISABLED:
+ case G_SUPPLICANT_STATE_DISCONNECTED:
+ case G_SUPPLICANT_STATE_INACTIVE:
+ case G_SUPPLICANT_STATE_SCANNING:
+ case G_SUPPLICANT_STATE_COMPLETED:
+ break;
+ }
+
+ return 0;
+}
+
+int g_supplicant_interface_scan(GSupplicantInterface *interface,
+ GSupplicantScanParams *scan_data,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_scan_data *data;
+ int ret;
+
+ ret = interface_ready_to_scan(interface);
+ if (ret)
+ return ret;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->interface = interface;
+ data->path = g_strdup(interface->path);
+ data->callback = callback;
+ data->user_data = user_data;
+ data->scan_params = scan_data;
+
+ interface->scan_callback = callback;
+ interface->scan_data = user_data;
+
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "Scan",
+ interface_scan_params, interface_scan_result, data,
+ interface);
+
+ if (ret < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ }
+
+ return ret;
+}
+
+static int parse_supplicant_error(DBusMessageIter *iter)
+{
+ int err = -ECANCELED;
+ char *key;
+
+ if (!iter)
+ return err;
+
+ /* If the given passphrase is malformed wpa_s returns
+ * "invalid message format" but this error should be interpreted as
+ * invalid-key.
+ */
+ while (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
+ dbus_message_iter_get_basic(iter, &key);
+ if (strncmp(key, "psk", 3) == 0 ||
+ strncmp(key, "wep_key", 7) == 0 ||
+ strcmp(key, "invalid message format") == 0) {
+ err = -ENOKEY;
+ break;
+ }
+ dbus_message_iter_next(iter);
+ }
+
+ return err;
+}
+
+static void interface_select_network_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ int err;
+
+ SUPPLICANT_DBG("");
+
+ err = 0;
+ if (error) {
+ SUPPLICANT_DBG("SelectNetwork error %s", error);
+ err = parse_supplicant_error(iter);
+ }
+
+ g_free(data->path);
+
+ if (data->callback)
+ data->callback(err, data->interface, data->user_data);
+
+ g_free(data->ssid);
+ dbus_free(data);
+}
+
+static void interface_select_network_params(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ GSupplicantInterface *interface = data->interface;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+ &interface->network_path);
+}
+
+static void interface_add_network_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ GSupplicantInterface *interface = data->interface;
+ const char *path;
+ int err;
+
+ if (error)
+ goto error;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ goto error;
+
+ SUPPLICANT_DBG("PATH: %s", path);
+
+ interface->network_path = g_strdup(path);
+
+ store_network_information(interface, data->ssid);
+
+ supplicant_dbus_method_call(data->interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "SelectNetwork",
+ interface_select_network_params,
+ interface_select_network_result, data,
+ interface);
+
+ return;
+
+error:
+ SUPPLICANT_DBG("AddNetwork error %s", error);
+
+ if (interface_exists(data->interface, data->interface->path)) {
+ err = parse_supplicant_error(iter);
+ if (data->callback)
+ data->callback(err, data->interface, data->user_data);
+
+ g_free(interface->network_path);
+ interface->network_path = NULL;
+ }
+
+ g_free(data->path);
+ g_free(data->ssid);
+ g_free(data);
+}
+
+static void add_network_security_none(DBusMessageIter *dict)
+{
+ const char *auth_alg = "OPEN";
+
+ supplicant_dbus_dict_append_basic(dict, "auth_alg",
+ DBUS_TYPE_STRING, &auth_alg);
+}
+
+static void add_network_security_wep(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ const char *auth_alg = "OPEN SHARED";
+ dbus_uint32_t key_index = 0;
+
+ supplicant_dbus_dict_append_basic(dict, "auth_alg",
+ DBUS_TYPE_STRING, &auth_alg);
+
+ if (ssid->passphrase) {
+ int size = strlen(ssid->passphrase);
+ if (size == 10 || size == 26) {
+ unsigned char *key = g_try_malloc(13);
+ char tmp[3];
+ int i;
+
+ memset(tmp, 0, sizeof(tmp));
+ if (!key)
+ size = 0;
+
+ for (i = 0; i < size / 2; i++) {
+ memcpy(tmp, ssid->passphrase + (i * 2), 2);
+ key[i] = (unsigned char) strtol(tmp, NULL, 16);
+ }
+
+ supplicant_dbus_dict_append_fixed_array(dict,
+ "wep_key0",
+ DBUS_TYPE_BYTE,
+ &key, size / 2);
+ g_free(key);
+ } else if (size == 5 || size == 13) {
+ unsigned char *key = g_try_malloc(13);
+ int i;
+
+ if (!key)
+ size = 0;
+
+ for (i = 0; i < size; i++)
+ key[i] = (unsigned char) ssid->passphrase[i];
+
+ supplicant_dbus_dict_append_fixed_array(dict,
+ "wep_key0",
+ DBUS_TYPE_BYTE,
+ &key, size);
+ g_free(key);
+ } else
+ supplicant_dbus_dict_append_basic(dict,
+ "wep_key0",
+ DBUS_TYPE_STRING,
+ &ssid->passphrase);
+
+ supplicant_dbus_dict_append_basic(dict, "wep_tx_keyidx",
+ DBUS_TYPE_UINT32, &key_index);
+ }
+}
+
+static dbus_bool_t is_psk_raw_key(const char *psk)
+{
+ int i;
+
+ /* A raw key is always 64 bytes length... */
+ if (strlen(psk) != 64)
+ return FALSE;
+
+ /* ... and its content is in hex representation */
+ for (i = 0; i < 64; i++)
+ if (!isxdigit((unsigned char) psk[i]))
+ return FALSE;
+
+ return TRUE;
+}
+
+static unsigned char hexchar2bin(char c)
+{
+ if ((c >= '0') && (c <= '9'))
+ return c - '0';
+ else if ((c >= 'A') && (c <= 'F'))
+ return c - 'A' + 10;
+ else if ((c >= 'a') && (c <= 'f'))
+ return c - 'a' + 10;
+ else
+ return c;
+}
+
+static void hexstring2bin(const char *string, unsigned char *data,
+ size_t data_len)
+{
+ size_t i;
+
+ for (i = 0; i < data_len; i++)
+ data[i] = (hexchar2bin(string[i * 2 + 0]) << 4 |
+ hexchar2bin(string[i * 2 + 1]) << 0);
+}
+
+static void add_network_security_psk(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ if (ssid->passphrase && strlen(ssid->passphrase) > 0) {
+ const char *key = "psk";
+
+ if (is_psk_raw_key(ssid->passphrase)) {
+ unsigned char data[32];
+ unsigned char *datap = data;
+
+ /* The above pointer alias is required by D-Bus because
+ * with D-Bus and GCC, non-heap-allocated arrays cannot
+ * be passed directly by their base pointer. */
+
+ hexstring2bin(ssid->passphrase, datap, sizeof(data));
+
+ supplicant_dbus_dict_append_fixed_array(dict,
+ key, DBUS_TYPE_BYTE,
+ &datap, sizeof(data));
+ } else
+ supplicant_dbus_dict_append_basic(dict,
+ key, DBUS_TYPE_STRING,
+ &ssid->passphrase);
+ }
+}
+
+static void add_network_security_tls(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ /*
+ * For TLS, we at least need:
+ * The client certificate
+ * The client private key file
+ * The client private key file password
+ *
+ * The Authority certificate is optional.
+ */
+ if (!ssid->client_cert_path)
+ return;
+
+ if (!ssid->private_key_path)
+ return;
+
+ if (!ssid->private_key_passphrase)
+ return;
+
+ if (ssid->ca_cert_path)
+ supplicant_dbus_dict_append_basic(dict, "ca_cert",
+ DBUS_TYPE_STRING, &ssid->ca_cert_path);
+
+ supplicant_dbus_dict_append_basic(dict, "private_key",
+ DBUS_TYPE_STRING,
+ &ssid->private_key_path);
+ supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
+ DBUS_TYPE_STRING,
+ &ssid->private_key_passphrase);
+ supplicant_dbus_dict_append_basic(dict, "client_cert",
+ DBUS_TYPE_STRING,
+ &ssid->client_cert_path);
+}
+
+static void add_network_security_peap(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ char *phase2_auth;
+
+ /*
+ * For PEAP/TTLS, we at least need
+ * The authority certificate
+ * The 2nd phase authentication method
+ * The 2nd phase passphrase
+ *
+ * The Client certificate is optional although strongly recommended
+ * When setting it, we need in addition
+ * The Client private key file
+ * The Client private key file password
+ */
+ if (!ssid->passphrase)
+ return;
+
+ if (!ssid->phase2_auth)
+ return;
+
+ if (ssid->client_cert_path) {
+ if (!ssid->private_key_path)
+ return;
+
+ if (!ssid->private_key_passphrase)
+ return;
+
+ supplicant_dbus_dict_append_basic(dict, "client_cert",
+ DBUS_TYPE_STRING,
+ &ssid->client_cert_path);
+
+ supplicant_dbus_dict_append_basic(dict, "private_key",
+ DBUS_TYPE_STRING,
+ &ssid->private_key_path);
+
+ supplicant_dbus_dict_append_basic(dict, "private_key_passwd",
+ DBUS_TYPE_STRING,
+ &ssid->private_key_passphrase);
+
+ }
+
+ if (g_str_has_prefix(ssid->phase2_auth, "EAP-")) {
+ phase2_auth = g_strdup_printf("autheap=%s",
+ ssid->phase2_auth + strlen("EAP-"));
+ } else
+ phase2_auth = g_strdup_printf("auth=%s", ssid->phase2_auth);
+
+ supplicant_dbus_dict_append_basic(dict, "password",
+ DBUS_TYPE_STRING,
+ &ssid->passphrase);
+
+ if (ssid->ca_cert_path)
+ supplicant_dbus_dict_append_basic(dict, "ca_cert",
+ DBUS_TYPE_STRING,
+ &ssid->ca_cert_path);
+
+ supplicant_dbus_dict_append_basic(dict, "phase2",
+ DBUS_TYPE_STRING,
+ &phase2_auth);
+
+ g_free(phase2_auth);
+}
+
+static void add_network_security_eap(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ char *eap_value;
+
+ if (!ssid->eap || !ssid->identity)
+ return;
+
+ if (g_strcmp0(ssid->eap, "tls") == 0) {
+ add_network_security_tls(dict, ssid);
+ } else if (g_strcmp0(ssid->eap, "peap") == 0 ||
+ g_strcmp0(ssid->eap, "ttls") == 0) {
+ add_network_security_peap(dict, ssid);
+ } else
+ return;
+
+ eap_value = g_ascii_strup(ssid->eap, -1);
+
+ supplicant_dbus_dict_append_basic(dict, "eap",
+ DBUS_TYPE_STRING,
+ &eap_value);
+ supplicant_dbus_dict_append_basic(dict, "identity",
+ DBUS_TYPE_STRING,
+ &ssid->identity);
+
+ g_free(eap_value);
+}
+
+static void add_network_security_ciphers(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ unsigned int p_cipher, g_cipher, i;
+ char *pairwise, *group;
+ char *pair_ciphers[4];
+ char *group_ciphers[5];
+
+ p_cipher = ssid->pairwise_cipher;
+ g_cipher = ssid->group_cipher;
+
+ if (p_cipher == 0 && g_cipher == 0)
+ return;
+
+ i = 0;
+
+ if (p_cipher & G_SUPPLICANT_PAIRWISE_CCMP)
+ pair_ciphers[i++] = "CCMP";
+
+ if (p_cipher & G_SUPPLICANT_PAIRWISE_TKIP)
+ pair_ciphers[i++] = "TKIP";
+
+ if (p_cipher & G_SUPPLICANT_PAIRWISE_NONE)
+ pair_ciphers[i++] = "NONE";
+
+ pair_ciphers[i] = NULL;
+
+ i = 0;
+
+ if (g_cipher & G_SUPPLICANT_GROUP_CCMP)
+ group_ciphers[i++] = "CCMP";
+
+ if (g_cipher & G_SUPPLICANT_GROUP_TKIP)
+ group_ciphers[i++] = "TKIP";
+
+ if (g_cipher & G_SUPPLICANT_GROUP_WEP104)
+ group_ciphers[i++] = "WEP104";
+
+ if (g_cipher & G_SUPPLICANT_GROUP_WEP40)
+ group_ciphers[i++] = "WEP40";
+
+ group_ciphers[i] = NULL;
+
+ pairwise = g_strjoinv(" ", pair_ciphers);
+ group = g_strjoinv(" ", group_ciphers);
+
+ SUPPLICANT_DBG("cipher %s %s", pairwise, group);
+
+ supplicant_dbus_dict_append_basic(dict, "pairwise",
+ DBUS_TYPE_STRING,
+ &pairwise);
+ supplicant_dbus_dict_append_basic(dict, "group",
+ DBUS_TYPE_STRING,
+ &group);
+
+ g_free(pairwise);
+ g_free(group);
+}
+
+static void add_network_security_proto(DBusMessageIter *dict,
+ GSupplicantSSID *ssid)
+{
+ unsigned int protocol, i;
+ char *proto;
+ char *protos[3];
+
+ protocol = ssid->protocol;
+
+ if (protocol == 0)
+ return;
+
+ i = 0;
+
+ if (protocol & G_SUPPLICANT_PROTO_RSN)
+ protos[i++] = "RSN";
+
+ if (protocol & G_SUPPLICANT_PROTO_WPA)
+ protos[i++] = "WPA";
+
+ protos[i] = NULL;
+
+ proto = g_strjoinv(" ", protos);
+
+ SUPPLICANT_DBG("proto %s", proto);
+
+ supplicant_dbus_dict_append_basic(dict, "proto",
+ DBUS_TYPE_STRING,
+ &proto);
+
+ g_free(proto);
+}
+
+static void add_network_security(DBusMessageIter *dict, GSupplicantSSID *ssid)
+{
+ char *key_mgmt;
+
+ switch (ssid->security) {
+ case G_SUPPLICANT_SECURITY_NONE:
+ key_mgmt = "NONE";
+ add_network_security_none(dict);
+ add_network_security_ciphers(dict, ssid);
+ break;
+ case G_SUPPLICANT_SECURITY_UNKNOWN:
+ case G_SUPPLICANT_SECURITY_WEP:
+ key_mgmt = "NONE";
+ add_network_security_wep(dict, ssid);
+ add_network_security_ciphers(dict, ssid);
+ break;
+ case G_SUPPLICANT_SECURITY_PSK:
+ key_mgmt = "WPA-PSK";
+ add_network_security_psk(dict, ssid);
+ add_network_security_ciphers(dict, ssid);
+ add_network_security_proto(dict, ssid);
+ break;
+ case G_SUPPLICANT_SECURITY_IEEE8021X:
+ key_mgmt = "WPA-EAP";
+ add_network_security_eap(dict, ssid);
+ add_network_security_ciphers(dict, ssid);
+ add_network_security_proto(dict, ssid);
+ break;
+ }
+
+ supplicant_dbus_dict_append_basic(dict, "key_mgmt",
+ DBUS_TYPE_STRING, &key_mgmt);
+}
+
+static void add_network_mode(DBusMessageIter *dict, GSupplicantSSID *ssid)
+{
+ dbus_uint32_t mode;
+
+ switch (ssid->mode) {
+ case G_SUPPLICANT_MODE_UNKNOWN:
+ case G_SUPPLICANT_MODE_INFRA:
+ mode = 0;
+ break;
+ case G_SUPPLICANT_MODE_IBSS:
+ mode = 1;
+ break;
+ case G_SUPPLICANT_MODE_MASTER:
+ mode = 2;
+ break;
+ }
+
+ supplicant_dbus_dict_append_basic(dict, "mode",
+ DBUS_TYPE_UINT32, &mode);
+}
+
+static void interface_add_network_params(DBusMessageIter *iter, void *user_data)
+{
+ DBusMessageIter dict;
+ struct interface_connect_data *data = user_data;
+ GSupplicantSSID *ssid = data->ssid;
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ if (ssid->scan_ssid)
+ supplicant_dbus_dict_append_basic(&dict, "scan_ssid",
+ DBUS_TYPE_UINT32, &ssid->scan_ssid);
+
+ if (ssid->freq)
+ supplicant_dbus_dict_append_basic(&dict, "frequency",
+ DBUS_TYPE_UINT32, &ssid->freq);
+
+ if (ssid->bgscan)
+ supplicant_dbus_dict_append_basic(&dict, "bgscan",
+ DBUS_TYPE_STRING, &ssid->bgscan);
+
+ add_network_mode(&dict, ssid);
+
+ add_network_security(&dict, ssid);
+
+ supplicant_dbus_dict_append_fixed_array(&dict, "ssid",
+ DBUS_TYPE_BYTE, &ssid->ssid,
+ ssid->ssid_len);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+static void interface_wps_start_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ int err;
+
+ SUPPLICANT_DBG("");
+
+ err = 0;
+ if (error) {
+ SUPPLICANT_DBG("error: %s", error);
+ err = parse_supplicant_error(iter);
+ }
+
+ if(data->callback)
+ data->callback(err, data->interface, data->user_data);
+
+ g_free(data->path);
+ g_free(data->ssid);
+ dbus_free(data);
+}
+
+static void interface_add_wps_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ GSupplicantSSID *ssid = data->ssid;
+ const char *role = "enrollee", *type;
+ DBusMessageIter dict;
+
+ SUPPLICANT_DBG("");
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ supplicant_dbus_dict_append_basic(&dict, "Role",
+ DBUS_TYPE_STRING, &role);
+
+ type = "pbc";
+ if (ssid->pin_wps) {
+ type = "pin";
+ supplicant_dbus_dict_append_basic(&dict, "Pin",
+ DBUS_TYPE_STRING, &ssid->pin_wps);
+ }
+
+ supplicant_dbus_dict_append_basic(&dict, "Type",
+ DBUS_TYPE_STRING, &type);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+static void wps_start(const char *error, DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+
+ SUPPLICANT_DBG("");
+
+ if (error) {
+ SUPPLICANT_DBG("error: %s", error);
+ g_free(data->path);
+ g_free(data->ssid);
+ dbus_free(data);
+ return;
+ }
+
+ supplicant_dbus_method_call(data->interface->path,
+ SUPPLICANT_INTERFACE ".Interface.WPS", "Start",
+ interface_add_wps_params,
+ interface_wps_start_result, data, NULL);
+}
+
+static void wps_process_credentials(DBusMessageIter *iter, void *user_data)
+{
+ dbus_bool_t credentials = TRUE;
+
+ SUPPLICANT_DBG("");
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_BOOLEAN, &credentials);
+}
+
+int g_supplicant_interface_connect(GSupplicantInterface *interface,
+ GSupplicantSSID *ssid,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_connect_data *data;
+ struct interface_data *intf_data;
+ int ret = 0;
+
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ /* TODO: Check if we're already connected and switch */
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->interface = interface;
+ data->path = g_strdup(interface->path);
+ data->callback = callback;
+ data->ssid = ssid;
+ data->user_data = user_data;
+
+ if (ssid->use_wps) {
+ g_free(interface->wps_cred.key);
+ memset(&interface->wps_cred, 0,
+ sizeof(struct _GSupplicantWpsCredentials));
+
+ ret = supplicant_dbus_property_set(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.WPS",
+ "ProcessCredentials", DBUS_TYPE_BOOLEAN_AS_STRING,
+ wps_process_credentials, wps_start, data, interface);
+ } else {
+ /* By the time there is a request for connect and the network
+ * path is not NULL it means that connman has not removed the
+ * previous network pointer. This can happen in the case AP
+ * deauthenticated client and connman does not remove the
+ * previously connected network pointer. This causes supplicant
+ * to reallocate the memory for struct wpa_ssid again even if it
+ * is the same SSID. This causes memory usage of wpa_supplicnat
+ * to go high. The idea here is that if the previously connected
+ * network is not removed at the time of next connection attempt
+ * check if the network path is not NULL. In case it is non-NULL
+ * first remove the network and then once removal is successful, add
+ * the network.
+ */
+
+ if (interface->network_path != NULL) {
+ g_free(data->path);
+ dbus_free(data);
+
+ /*
+ * If this add network is for the same network for which
+ * wpa_supplicant already has a profile then do not need
+ * to add another profile. Only if the profile that needs
+ * to get added is different from what is there in wpa_s
+ * delete the current one. A network is identified by its
+ * SSID, security_type and passphrase (private passphrase)
+ * in case security type is (802.11x).
+ */
+ if (compare_network_parameters(interface, ssid)) {
+ return -EALREADY;
+ }
+
+ intf_data = dbus_malloc0(sizeof(*intf_data));
+ if (!intf_data)
+ return -ENOMEM;
+ intf_data->interface = interface;
+ intf_data->path = g_strdup(interface->path);
+ intf_data->callback = callback;
+ intf_data->ssid = ssid;
+ intf_data->user_data = user_data;
+ intf_data->network_remove_in_progress = TRUE;
+ network_remove(intf_data);
+ } else {
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
+ interface_add_network_params,
+ interface_add_network_result, data,
+ interface);
+ }
+ }
+
+ if (ret < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ return ret;
+ }
+
+ return -EINPROGRESS;
+}
+
+static void network_remove_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_data *data = user_data;
+ struct interface_connect_data *connect_data;
+ int result = 0;
+
+ SUPPLICANT_DBG("");
+
+ if (error) {
+ result = -EIO;
+ if (g_strcmp0("org.freedesktop.DBus.Error.UnknownMethod",
+ error) == 0)
+ result = -ECONNABORTED;
+ }
+
+ g_free(data->interface->network_path);
+ data->interface->network_path = NULL;
+
+ remove_network_information(data->interface);
+
+ if (data->network_remove_in_progress == TRUE) {
+ data->network_remove_in_progress = FALSE;
+ connect_data = dbus_malloc0(sizeof(*connect_data));
+ if (!connect_data)
+ return;
+
+ connect_data->interface = data->interface;
+ connect_data->path = g_strdup(data->path);
+ connect_data->callback = data->callback;
+ connect_data->ssid = data->ssid;
+ connect_data->user_data = data->user_data;
+
+ supplicant_dbus_method_call(data->interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "AddNetwork",
+ interface_add_network_params,
+ interface_add_network_result, connect_data,
+ connect_data->interface);
+ } else {
+ if (data->callback)
+ data->callback(result, data->interface, data->user_data);
+ }
+ g_free(data->path);
+ dbus_free(data);
+}
+
+static void network_remove_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_data *data = user_data;
+ const char *path = data->interface->network_path;
+
+ SUPPLICANT_DBG("path %s", path);
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &path);
+}
+
+static int network_remove(struct interface_data *data)
+{
+ GSupplicantInterface *interface = data->interface;
+
+ SUPPLICANT_DBG("");
+
+ return supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "RemoveNetwork",
+ network_remove_params, network_remove_result, data,
+ interface);
+}
+
+static void interface_disconnect_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_data *data = user_data;
+ int result = 0;
+
+ SUPPLICANT_DBG("");
+
+ if (error) {
+ result = -EIO;
+ if (g_strcmp0("org.freedesktop.DBus.Error.UnknownMethod",
+ error) == 0)
+ result = -ECONNABORTED;
+ }
+
+ if (result < 0 && data->callback) {
+ data->callback(result, data->interface, data->user_data);
+ data->callback = NULL;
+ }
+
+ /* If we are disconnecting from previous WPS successful
+ * association. i.e.: it did not went through AddNetwork,
+ * and interface->network_path was never set. */
+ if (!data->interface->network_path) {
+ g_free(data->path);
+ dbus_free(data);
+ return;
+ }
+
+ if (result != -ECONNABORTED) {
+ if (network_remove(data) < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ }
+ } else {
+ g_free(data->path);
+ dbus_free(data);
+ }
+}
+
+int g_supplicant_interface_disconnect(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_data *data;
+ int ret;
+
+ SUPPLICANT_DBG("");
+
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->interface = interface;
+ data->path = g_strdup(interface->path);
+ data->callback = callback;
+ data->user_data = user_data;
+
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "Disconnect",
+ NULL, interface_disconnect_result, data,
+ interface);
+
+ if (ret < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ }
+
+ return ret;
+}
+
+static void interface_p2p_find_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_scan_data *data = user_data;
+ int err = 0;
+
+ SUPPLICANT_DBG("error %s", error);
+
+ if (error)
+ err = -EIO;
+
+ if (interface_exists(data->interface, data->path)) {
+ if (!data->interface->ready)
+ err = -ENOLINK;
+ if (!err)
+ data->interface->p2p_finding = true;
+ }
+
+ if (data->callback)
+ data->callback(err, data->interface, data->user_data);
+
+ g_free(data->path);
+ dbus_free(data);
+}
+
+static void interface_p2p_find_params(DBusMessageIter *iter, void *user_data)
+{
+ DBusMessageIter dict;
+
+ supplicant_dbus_dict_open(iter, &dict);
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+int g_supplicant_interface_p2p_find(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_scan_data *data;
+ int ret;
+
+ if (!interface->p2p_support)
+ return -ENOTSUP;
+
+ ret = interface_ready_to_scan(interface);
+ if (ret && ret != -EALREADY)
+ return ret;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->interface = interface;
+ data->path = g_strdup(interface->path);
+ data->callback = callback;
+ data->user_data = user_data;
+
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice", "Find",
+ interface_p2p_find_params, interface_p2p_find_result,
+ data, interface);
+ if (ret < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ }
+
+ return ret;
+}
+
+bool g_supplicant_interface_is_p2p_finding(GSupplicantInterface *interface)
+{
+ if (!interface)
+ return false;
+
+ return interface->p2p_finding;
+}
+
+int g_supplicant_interface_p2p_stop_find(GSupplicantInterface *interface)
+{
+ if (!interface->p2p_finding)
+ return 0;
+
+ SUPPLICANT_DBG("");
+
+ interface->p2p_finding = false;
+
+ return supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice", "StopFind",
+ NULL, NULL, NULL, NULL);
+}
+
+static void interface_p2p_connect_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ int err = 0;
+
+ SUPPLICANT_DBG("");
+
+ if (error)
+ err = parse_supplicant_error(iter);
+
+ if (data->callback)
+ data->callback(err, data->interface, data->user_data);
+
+ g_free(data->path);
+ g_free(data->peer->wps_pin);
+ g_free(data->peer->path);
+ g_free(data->peer);
+ g_free(data);
+}
+
+static void interface_p2p_connect_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_connect_data *data = user_data;
+ const char *wps = "pbc";
+ DBusMessageIter dict;
+ int go_intent = 7;
+
+ SUPPLICANT_DBG("");
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ if (data->peer->master)
+ go_intent = 15;
+
+ if (data->peer->wps_pin)
+ wps = "pin";
+
+ supplicant_dbus_dict_append_basic(&dict, "peer",
+ DBUS_TYPE_OBJECT_PATH, &data->peer->path);
+ supplicant_dbus_dict_append_basic(&dict, "wps_method",
+ DBUS_TYPE_STRING, &wps);
+ if (data->peer->wps_pin) {
+ supplicant_dbus_dict_append_basic(&dict, "pin",
+ DBUS_TYPE_STRING, &data->peer->wps_pin);
+ }
+
+ supplicant_dbus_dict_append_basic(&dict, "go_intent",
+ DBUS_TYPE_INT32, &go_intent);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+int g_supplicant_interface_p2p_connect(GSupplicantInterface *interface,
+ GSupplicantPeerParams *peer_params,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct interface_connect_data *data;
+ int ret;
+
+ SUPPLICANT_DBG("");
+
+ if (!interface->p2p_support)
+ return -ENOTSUP;
+
+ data = dbus_malloc0(sizeof(*data));
+ data->interface = interface;
+ data->path = g_strdup(interface->path);
+ data->peer = peer_params;
+ data->callback = callback;
+ data->user_data = user_data;
+
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice", "Connect",
+ interface_p2p_connect_params, interface_p2p_connect_result,
+ data, interface);
+ if (ret < 0) {
+ g_free(data->path);
+ dbus_free(data);
+ return ret;
+ }
+
+ return -EINPROGRESS;
+}
+
+int g_supplicant_interface_p2p_disconnect(GSupplicantInterface *interface,
+ GSupplicantPeerParams *peer_params)
+{
+ GSupplicantPeer *peer;
+ int count = 0;
+ GSList *list;
+
+ SUPPLICANT_DBG("");
+
+ if (!interface->p2p_support)
+ return -ENOTSUP;
+
+ peer = g_hash_table_lookup(interface->peer_table, peer_params->path);
+ if (!peer)
+ return -ENODEV;
+
+ for (list = peer->groups; list; list = list->next, count++) {
+ const char *group_obj_path = list->data;
+ GSupplicantInterface *g_interface;
+ GSupplicantGroup *group;
+
+ group = g_hash_table_lookup(group_mapping, group_obj_path);
+ if (!group || !group->interface)
+ continue;
+
+ g_interface = group->interface;
+ supplicant_dbus_method_call(g_interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice",
+ "Disconnect", NULL, NULL, NULL, g_interface);
+ }
+
+ if (count == 0 && peer->current_group_iface) {
+ supplicant_dbus_method_call(peer->current_group_iface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice",
+ "Disconnect", NULL, NULL, NULL,
+ peer->current_group_iface->path);
+ }
+
+ peer->current_group_iface = NULL;
+
+ return -EINPROGRESS;
+}
+
+struct p2p_service_data {
+ bool registration;
+ GSupplicantInterface *interface;
+ GSupplicantP2PServiceParams *service;
+ GSupplicantInterfaceCallback callback;
+ void *user_data;
+};
+
+static void interface_p2p_service_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct p2p_service_data *data = user_data;
+ int result = 0;
+
+ SUPPLICANT_DBG("%s result - %s", data->registration ?
+ "Registration" : "Deletion",
+ error ? error : "Success");
+ if (error)
+ result = -EINVAL;
+
+ if (data->callback)
+ data->callback(result, data->interface, data->user_data);
+
+ g_free(data->service->query);
+ g_free(data->service->response);
+ g_free(data->service->service);
+ g_free(data->service->wfd_ies);
+ g_free(data->service);
+ dbus_free(data);
+}
+
+static void interface_p2p_service_params(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct p2p_service_data *data = user_data;
+ GSupplicantP2PServiceParams *service;
+ DBusMessageIter dict;
+ const char *type;
+
+ SUPPLICANT_DBG("");
+
+ service = data->service;
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ if (service->query && service->response) {
+ type = "bonjour";
+ supplicant_dbus_dict_append_basic(&dict, "service_type",
+ DBUS_TYPE_STRING, &type);
+ supplicant_dbus_dict_append_fixed_array(&dict, "query",
+ DBUS_TYPE_BYTE, &service->query,
+ service->query_length);
+ supplicant_dbus_dict_append_fixed_array(&dict, "response",
+ DBUS_TYPE_BYTE, &service->response,
+ service->response_length);
+ } else if (service->version && service->service) {
+ type = "upnp";
+ supplicant_dbus_dict_append_basic(&dict, "service_type",
+ DBUS_TYPE_STRING, &type);
+ supplicant_dbus_dict_append_basic(&dict, "version",
+ DBUS_TYPE_INT32, &service->version);
+ supplicant_dbus_dict_append_basic(&dict, "service",
+ DBUS_TYPE_STRING, &service->service);
+ }
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+int g_supplicant_interface_p2p_add_service(GSupplicantInterface *interface,
+ GSupplicantInterfaceCallback callback,
+ GSupplicantP2PServiceParams *p2p_service_params,
+ void *user_data)
+{
+ struct p2p_service_data *data;
+ int ret;
+
+ SUPPLICANT_DBG("");
+
+ if (!interface->p2p_support)
+ return -ENOTSUP;
+
+ data = dbus_malloc0(sizeof(*data));
+ data->registration = true;
+ data->interface = interface;
+ data->service = p2p_service_params;
+ data->callback = callback;
+ data->user_data = user_data;
+
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice", "AddService",
+ interface_p2p_service_params, interface_p2p_service_result,
+ data, interface);
+ if (ret < 0) {
+ dbus_free(data);
+ return ret;
+ }
+
+ return -EINPROGRESS;
+}
+
+int g_supplicant_interface_p2p_del_service(GSupplicantInterface *interface,
+ GSupplicantP2PServiceParams *p2p_service_params)
+{
+ struct p2p_service_data *data;
+ int ret;
+
+ SUPPLICANT_DBG("");
+
+ if (!interface->p2p_support)
+ return -ENOTSUP;
+
+ data = dbus_malloc0(sizeof(*data));
+ data->interface = interface;
+ data->service = p2p_service_params;
+
+ ret = supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice", "DeleteService",
+ interface_p2p_service_params, interface_p2p_service_result,
+ data, interface);
+ if (ret < 0) {
+ dbus_free(data);
+ return ret;
+ }
+
+ return -EINPROGRESS;
+}
+
+struct p2p_listen_data {
+ int period;
+ int interval;
+};
+
+static void interface_p2p_listen_params(DBusMessageIter *iter, void *user_data)
+{
+ struct p2p_listen_data *params = user_data;
+ DBusMessageIter dict;
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ supplicant_dbus_dict_append_basic(&dict, "period",
+ DBUS_TYPE_INT32, ¶ms->period);
+ supplicant_dbus_dict_append_basic(&dict, "interval",
+ DBUS_TYPE_INT32, ¶ms->interval);
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+int g_supplicant_interface_p2p_listen(GSupplicantInterface *interface,
+ int period, int interval)
+{
+ struct p2p_listen_data params;
+
+ SUPPLICANT_DBG("");
+
+ if (!interface->p2p_support)
+ return -ENOTSUP;
+
+ params.period = period;
+ params.interval = interval;
+
+ return supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface.P2PDevice",
+ "ExtendedListen", interface_p2p_listen_params,
+ NULL, ¶ms, NULL);
+}
+
+static void widi_ies_params(DBusMessageIter *iter, void *user_data)
+{
+ struct p2p_service_data *data = user_data;
+ GSupplicantP2PServiceParams *service = data->service;
+ DBusMessageIter array;
+
+ SUPPLICANT_DBG("%p - %d", service->wfd_ies, service->wfd_ies_length);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_BYTE_AS_STRING, &array);
+
+ if (service->wfd_ies && service->wfd_ies_length > 0) {
+ dbus_message_iter_append_fixed_array(&array, DBUS_TYPE_BYTE,
+ &service->wfd_ies, service->wfd_ies_length);
+ }
+
+ dbus_message_iter_close_container(iter, &array);
+}
+
+int g_supplicant_set_widi_ies(GSupplicantP2PServiceParams *p2p_service_params,
+ GSupplicantInterfaceCallback callback,
+ void *user_data)
+{
+ struct p2p_service_data *data;
+ int ret;
+
+ SUPPLICANT_DBG("");
+
+ if (!system_available)
+ return -EFAULT;
+
+ data = dbus_malloc0(sizeof(*data));
+ data->service = p2p_service_params;
+ data->callback = callback;
+ data->user_data = user_data;
+
+ if (p2p_service_params->wfd_ies)
+ data->registration = true;
+
+ ret = supplicant_dbus_property_set(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE, "WFDIEs",
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_BYTE_AS_STRING,
+ widi_ies_params,
+ interface_p2p_service_result,
+ data, NULL);
+ if (ret < 0 && ret != -EINPROGRESS) {
+ dbus_free(data);
+ return ret;
+ }
+
+ return -EINPROGRESS;
+}
+
+
+static const char *g_supplicant_rule0 = "type=signal,"
+ "path=" DBUS_PATH_DBUS ","
+ "sender=" DBUS_SERVICE_DBUS ","
+ "interface=" DBUS_INTERFACE_DBUS ","
+ "member=NameOwnerChanged,"
+ "arg0=" SUPPLICANT_SERVICE;
+static const char *g_supplicant_rule1 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE;
+static const char *g_supplicant_rule2 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface";
+static const char *g_supplicant_rule3 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface.WPS";
+static const char *g_supplicant_rule4 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".BSS";
+static const char *g_supplicant_rule5 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Network";
+static const char *g_supplicant_rule6 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface.P2PDevice";
+static const char *g_supplicant_rule7 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Peer";
+static const char *g_supplicant_rule8 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Group";
+
+static void invoke_introspect_method(void)
+{
+ DBusMessage *message;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE,
+ SUPPLICANT_PATH,
+ DBUS_INTERFACE_INTROSPECTABLE,
+ "Introspect");
+
+ if (!message)
+ return;
+
+ dbus_message_set_no_reply(message, TRUE);
+ dbus_connection_send(connection, message, NULL);
+ dbus_message_unref(message);
+}
+
+int g_supplicant_register(const GSupplicantCallbacks *callbacks)
+{
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (!connection)
+ return -EIO;
+
+ if (!dbus_connection_add_filter(connection, g_supplicant_filter,
+ NULL, NULL)) {
+ dbus_connection_unref(connection);
+ connection = NULL;
+ return -EIO;
+ }
+
+ callbacks_pointer = callbacks;
+ eap_methods = 0;
+
+ interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_interface);
+
+ bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ peer_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ group_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ pending_peer_connection = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ supplicant_dbus_setup(connection);
+
+ dbus_bus_add_match(connection, g_supplicant_rule0, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule1, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule2, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule3, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule4, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule5, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule6, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule7, NULL);
+ dbus_bus_add_match(connection, g_supplicant_rule8, NULL);
+ dbus_connection_flush(connection);
+
+ if (dbus_bus_name_has_owner(connection,
+ SUPPLICANT_SERVICE, NULL)) {
+ system_available = TRUE;
+ supplicant_dbus_property_get_all(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ service_property, NULL, NULL);
+ } else
+ invoke_introspect_method();
+
+ return 0;
+}
+
+static void unregister_interface_remove_params(DBusMessageIter *iter,
+ void *user_data)
+{
+ const char *path = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH,
+ &path);
+}
+
+
+static void unregister_remove_interface(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ GSupplicantInterface *interface = value;
+
+ supplicant_dbus_method_call(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ "RemoveInterface",
+ unregister_interface_remove_params,
+ NULL, interface->path, NULL);
+}
+
+void g_supplicant_unregister(const GSupplicantCallbacks *callbacks)
+{
+ SUPPLICANT_DBG("");
+
+ if (connection) {
+ dbus_bus_remove_match(connection, g_supplicant_rule8, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule7, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule6, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule5, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule4, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule3, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule2, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule1, NULL);
+ dbus_bus_remove_match(connection, g_supplicant_rule0, NULL);
+ dbus_connection_flush(connection);
+
+ dbus_connection_remove_filter(connection,
+ g_supplicant_filter, NULL);
+ }
+
+ if (bss_mapping) {
+ g_hash_table_destroy(bss_mapping);
+ bss_mapping = NULL;
+ }
+
+ if (peer_mapping) {
+ g_hash_table_destroy(peer_mapping);
+ peer_mapping = NULL;
+ }
+
+ if (group_mapping) {
+ g_hash_table_destroy(group_mapping);
+ group_mapping = NULL;
+ }
+
+ if (interface_table) {
+ g_hash_table_foreach(interface_table,
+ unregister_remove_interface, NULL);
+ g_hash_table_destroy(interface_table);
+ interface_table = NULL;
+ }
+
+ if (system_available)
+ callback_system_killed();
+
+ if (connection) {
+ dbus_connection_unref(connection);
+ connection = NULL;
+ }
+
+ callbacks_pointer = NULL;
+ eap_methods = 0;
+}
diff --git a/gweb/giognutls.c b/gweb/giognutls.c
new file mode 100644
index 0000000..09dc9e7
--- /dev/null
+++ b/gweb/giognutls.c
@@ -0,0 +1,469 @@
+/*
+ *
+ * Web service library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <gnutls/gnutls.h>
+
+#include "giognutls.h"
+
+//#define DBG(fmt, arg...) printf("%s: " fmt "\n" , __func__ , ## arg)
+#define DBG(fmt, arg...)
+
+typedef struct _GIOGnuTLSChannel GIOGnuTLSChannel;
+typedef struct _GIOGnuTLSWatch GIOGnuTLSWatch;
+
+struct _GIOGnuTLSChannel {
+ GIOChannel channel;
+ gint fd;
+ gnutls_certificate_credentials_t cred;
+ gnutls_session_t session;
+ bool established;
+ bool again;
+};
+
+struct _GIOGnuTLSWatch {
+ GSource source;
+ GPollFD pollfd;
+ GIOChannel *channel;
+ GIOCondition condition;
+};
+
+static volatile int global_init_done = 0;
+
+static inline void g_io_gnutls_global_init(void)
+{
+ if (__sync_bool_compare_and_swap(&global_init_done, 0, 1))
+ gnutls_global_init();
+}
+
+static GIOStatus check_handshake(GIOChannel *channel, GError **err)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+ int result;
+
+ DBG("channel %p", channel);
+
+ if (gnutls_channel->established)
+ return G_IO_STATUS_NORMAL;
+
+again:
+ result = gnutls_handshake(gnutls_channel->session);
+
+ if (result == GNUTLS_E_INTERRUPTED || result == GNUTLS_E_AGAIN) {
+ GIOFlags flags = g_io_channel_get_flags(channel);
+
+ if (gnutls_channel->again)
+ return G_IO_STATUS_AGAIN;
+
+ if (flags & G_IO_FLAG_NONBLOCK)
+ return G_IO_STATUS_AGAIN;
+
+ goto again;
+ }
+
+ if (result < 0) {
+ g_set_error(err, G_IO_CHANNEL_ERROR,
+ G_IO_CHANNEL_ERROR_FAILED, "Handshake failed");
+ return G_IO_STATUS_ERROR;
+ }
+
+ gnutls_channel->established = true;
+
+ DBG("handshake done");
+
+ return G_IO_STATUS_NORMAL;
+}
+
+static GIOStatus g_io_gnutls_read(GIOChannel *channel, gchar *buf,
+ gsize count, gsize *bytes_read, GError **err)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+ GIOStatus status;
+ ssize_t result;
+
+ DBG("channel %p count %zu", channel, count);
+
+ *bytes_read = 0;
+
+again:
+ status = check_handshake(channel, err);
+ if (status != G_IO_STATUS_NORMAL)
+ return status;
+
+ result = gnutls_record_recv(gnutls_channel->session, buf, count);
+
+ DBG("result %zd", result);
+
+ if (result == GNUTLS_E_REHANDSHAKE) {
+ gnutls_channel->established = false;
+ goto again;
+ }
+
+ if (result == GNUTLS_E_INTERRUPTED || result == GNUTLS_E_AGAIN) {
+ GIOFlags flags = g_io_channel_get_flags(channel);
+
+ if (gnutls_channel->again)
+ return G_IO_STATUS_AGAIN;
+
+ if (flags & G_IO_FLAG_NONBLOCK)
+ return G_IO_STATUS_AGAIN;
+
+ goto again;
+ }
+
+ if (result == GNUTLS_E_UNEXPECTED_PACKET_LENGTH)
+ return G_IO_STATUS_EOF;
+
+ if (result < 0) {
+ g_set_error(err, G_IO_CHANNEL_ERROR,
+ G_IO_CHANNEL_ERROR_FAILED, "Stream corrupted");
+ return G_IO_STATUS_ERROR;
+ }
+
+ *bytes_read = result;
+
+ return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
+}
+
+static GIOStatus g_io_gnutls_write(GIOChannel *channel, const gchar *buf,
+ gsize count, gsize *bytes_written, GError **err)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+ GIOStatus status;
+ ssize_t result;
+
+ DBG("channel %p count %zu", channel, count);
+
+ *bytes_written = 0;
+
+again:
+ status = check_handshake(channel, err);
+ if (status != G_IO_STATUS_NORMAL)
+ return status;
+
+ result = gnutls_record_send(gnutls_channel->session, buf, count);
+
+ DBG("result %zd", result);
+
+ if (result == GNUTLS_E_REHANDSHAKE) {
+ gnutls_channel->established = false;
+ goto again;
+ }
+
+ if (result == GNUTLS_E_INTERRUPTED || result == GNUTLS_E_AGAIN) {
+ GIOFlags flags = g_io_channel_get_flags(channel);
+
+ if (gnutls_channel->again)
+ return G_IO_STATUS_AGAIN;
+
+ if (flags & G_IO_FLAG_NONBLOCK)
+ return G_IO_STATUS_AGAIN;
+
+ goto again;
+ }
+
+ if (result < 0) {
+ g_set_error(err, G_IO_CHANNEL_ERROR,
+ G_IO_CHANNEL_ERROR_FAILED, "Stream corrupted");
+ return G_IO_STATUS_ERROR;
+ }
+
+ *bytes_written = result;
+
+ return (result > 0) ? G_IO_STATUS_NORMAL : G_IO_STATUS_EOF;
+}
+
+static GIOStatus g_io_gnutls_seek(GIOChannel *channel, gint64 offset,
+ GSeekType type, GError **err)
+{
+ DBG("channel %p", channel);
+
+ g_set_error_literal(err, G_IO_CHANNEL_ERROR,
+ G_IO_CHANNEL_ERROR_FAILED, "Not supported");
+ return G_IO_STATUS_ERROR;
+}
+
+static GIOStatus g_io_gnutls_close(GIOChannel *channel, GError **err)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+
+ DBG("channel %p", channel);
+
+ if (gnutls_channel->established)
+ gnutls_bye(gnutls_channel->session, GNUTLS_SHUT_RDWR);
+
+ if (close(gnutls_channel->fd) < 0) {
+ g_set_error_literal(err, G_IO_CHANNEL_ERROR,
+ G_IO_CHANNEL_ERROR_FAILED, "Closing failed");
+ return G_IO_STATUS_ERROR;
+ }
+
+ return G_IO_STATUS_NORMAL;
+}
+
+static void g_io_gnutls_free(GIOChannel *channel)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+
+ DBG("channel %p", channel);
+
+ gnutls_deinit(gnutls_channel->session);
+
+ gnutls_certificate_free_credentials(gnutls_channel->cred);
+
+ g_free(gnutls_channel);
+}
+
+static GIOStatus g_io_gnutls_set_flags(GIOChannel *channel,
+ GIOFlags flags, GError **err)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+ glong fcntl_flags = 0;
+
+ DBG("channel %p flags %u", channel, flags);
+
+ if (flags & G_IO_FLAG_NONBLOCK)
+ fcntl_flags |= O_NONBLOCK;
+
+ if (fcntl(gnutls_channel->fd, F_SETFL, fcntl_flags) < 0) {
+ g_set_error_literal(err, G_IO_CHANNEL_ERROR,
+ G_IO_CHANNEL_ERROR_FAILED, "Setting flags failed");
+ return G_IO_STATUS_ERROR;
+ }
+
+ return G_IO_STATUS_NORMAL;
+}
+
+static GIOFlags g_io_gnutls_get_flags(GIOChannel *channel)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+ GIOFlags flags = 0;
+ glong fcntl_flags;
+
+ DBG("channel %p", channel);
+
+ fcntl_flags = fcntl(gnutls_channel->fd, F_GETFL);
+ if (fcntl_flags < 0)
+ return 0;
+
+ if (fcntl_flags & O_NONBLOCK)
+ flags |= G_IO_FLAG_NONBLOCK;
+
+ return flags;
+}
+
+static gboolean g_io_gnutls_prepare(GSource *source, gint *timeout)
+{
+ DBG("source %p", source);
+
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean g_io_gnutls_check(GSource *source)
+{
+ GIOGnuTLSWatch *watch = (GIOGnuTLSWatch *) source;
+ GIOCondition condition = watch->pollfd.revents;
+
+ DBG("source %p condition %u", source, condition);
+
+ if (condition & watch->condition)
+ return TRUE;
+
+ return FALSE;
+}
+
+static gboolean g_io_gnutls_dispatch(GSource *source, GSourceFunc callback,
+ gpointer user_data)
+{
+ GIOGnuTLSWatch *watch = (GIOGnuTLSWatch *) source;
+ GIOFunc func = (GIOFunc) callback;
+ GIOCondition condition = watch->pollfd.revents;
+
+ DBG("source %p condition %u", source, condition);
+
+ if (!func)
+ return FALSE;
+
+ return func(watch->channel, condition & watch->condition, user_data);
+}
+
+static void g_io_gnutls_finalize(GSource *source)
+{
+ GIOGnuTLSWatch *watch = (GIOGnuTLSWatch *) source;
+
+ DBG("source %p", source);
+
+ g_io_channel_unref(watch->channel);
+}
+
+static GSourceFuncs gnutls_watch_funcs = {
+ g_io_gnutls_prepare,
+ g_io_gnutls_check,
+ g_io_gnutls_dispatch,
+ g_io_gnutls_finalize,
+};
+
+static GSource *g_io_gnutls_create_watch(GIOChannel *channel,
+ GIOCondition condition)
+{
+ GIOGnuTLSChannel *gnutls_channel = (GIOGnuTLSChannel *) channel;
+ GIOGnuTLSWatch *watch;
+ GSource *source;
+
+ DBG("channel %p condition %u", channel, condition);
+
+ source = g_source_new(&gnutls_watch_funcs, sizeof(GIOGnuTLSWatch));
+
+ watch = (GIOGnuTLSWatch *) source;
+
+ watch->channel = channel;
+ g_io_channel_ref(channel);
+
+ watch->condition = condition;
+
+ watch->pollfd.fd = gnutls_channel->fd;
+ watch->pollfd.events = condition;
+
+ g_source_add_poll(source, &watch->pollfd);
+
+ return source;
+}
+
+static GIOFuncs gnutls_channel_funcs = {
+ g_io_gnutls_read,
+ g_io_gnutls_write,
+ g_io_gnutls_seek,
+ g_io_gnutls_close,
+ g_io_gnutls_create_watch,
+ g_io_gnutls_free,
+ g_io_gnutls_set_flags,
+ g_io_gnutls_get_flags,
+};
+
+static ssize_t g_io_gnutls_push_func(gnutls_transport_ptr_t transport_data,
+ const void *buf, size_t count)
+{
+ GIOGnuTLSChannel *gnutls_channel = transport_data;
+ ssize_t result;
+
+ DBG("count %zu", count);
+
+ result = write(gnutls_channel->fd, buf, count);
+
+ if (result < 0 && errno == EAGAIN)
+ gnutls_channel->again = true;
+ else
+ gnutls_channel->again = false;
+
+ DBG("result %zd", result);
+
+ return result;
+}
+
+static ssize_t g_io_gnutls_pull_func(gnutls_transport_ptr_t transport_data,
+ void *buf, size_t count)
+{
+ GIOGnuTLSChannel *gnutls_channel = transport_data;
+ ssize_t result;
+
+ DBG("count %zu", count);
+
+ result = read(gnutls_channel->fd, buf, count);
+
+ if (result < 0 && errno == EAGAIN)
+ gnutls_channel->again = true;
+ else
+ gnutls_channel->again = false;
+
+ DBG("result %zd", result);
+
+ return result;
+}
+
+bool g_io_channel_supports_tls(void)
+{
+ return true;
+}
+
+GIOChannel *g_io_channel_gnutls_new(int fd)
+{
+ GIOGnuTLSChannel *gnutls_channel;
+ GIOChannel *channel;
+ int err;
+
+ DBG("");
+
+ gnutls_channel = g_new(GIOGnuTLSChannel, 1);
+
+ channel = (GIOChannel *) gnutls_channel;
+
+ g_io_channel_init(channel);
+ channel->funcs = &gnutls_channel_funcs;
+
+ gnutls_channel->fd = fd;
+
+ channel->is_seekable = FALSE;
+ channel->is_readable = TRUE;
+ channel->is_writeable = TRUE;
+
+ channel->do_encode = FALSE;
+
+ g_io_gnutls_global_init();
+
+ err = gnutls_init(&gnutls_channel->session, GNUTLS_CLIENT);
+ if (err < 0) {
+ g_free(gnutls_channel);
+ return NULL;
+ }
+
+ gnutls_transport_set_ptr(gnutls_channel->session, gnutls_channel);
+ gnutls_transport_set_push_function(gnutls_channel->session,
+ g_io_gnutls_push_func);
+ gnutls_transport_set_pull_function(gnutls_channel->session,
+ g_io_gnutls_pull_func);
+#if GNUTLS_VERSION_NUMBER < 0x020c00
+ gnutls_transport_set_lowat(gnutls_channel->session, 0);
+
+ gnutls_priority_set_direct(gnutls_channel->session,
+ "NORMAL:%COMPAT", NULL);
+#else
+ gnutls_priority_set_direct(gnutls_channel->session,
+ "NORMAL:-VERS-TLS-ALL:+VERS-TLS1.0:+VERS-SSL3.0:%COMPAT", NULL);
+#endif
+
+ gnutls_certificate_allocate_credentials(&gnutls_channel->cred);
+ gnutls_credentials_set(gnutls_channel->session,
+ GNUTLS_CRD_CERTIFICATE, gnutls_channel->cred);
+
+ DBG("channel %p", channel);
+
+ return channel;
+}
diff --git a/gweb/giognutls.h b/gweb/giognutls.h
new file mode 100644
index 0000000..ea0df8f
--- /dev/null
+++ b/gweb/giognutls.h
@@ -0,0 +1,28 @@
+/*
+ *
+ * Web service library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdbool.h>
+
+#include <glib.h>
+
+bool g_io_channel_supports_tls(void);
+
+GIOChannel *g_io_channel_gnutls_new(int fd);
diff --git a/gweb/gionotls.c b/gweb/gionotls.c
new file mode 100644
index 0000000..2998895
--- /dev/null
+++ b/gweb/gionotls.c
@@ -0,0 +1,36 @@
+/*
+ *
+ * Web service library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "giognutls.h"
+
+bool g_io_channel_supports_tls(void)
+{
+ return false;
+}
+
+GIOChannel *g_io_channel_gnutls_new(int fd)
+{
+ return NULL;
+}
diff --git a/gweb/gresolv.c b/gweb/gresolv.c
new file mode 100644
index 0000000..5cf7a9a
--- /dev/null
+++ b/gweb/gresolv.c
@@ -0,0 +1,1117 @@
+/*
+ *
+ * Resolver library with GLib integration
+ *
+ * Copyright (C) 2009-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdlib.h>
+#include <resolv.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <arpa/nameser.h>
+#include <net/if.h>
+
+#include "gresolv.h"
+
+struct sort_result {
+ int precedence;
+ int src_scope;
+ int dst_scope;
+ int src_label;
+ int dst_label;
+ bool reachable;
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in sin;
+ struct sockaddr_in6 sin6;
+ } src;
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in sin;
+ struct sockaddr_in6 sin6;
+ } dst;
+};
+
+struct resolv_query;
+
+struct resolv_lookup {
+ GResolv *resolv;
+ guint id;
+
+ int nr_results;
+ struct sort_result *results;
+
+ struct resolv_query *ipv4_query;
+ struct resolv_query *ipv6_query;
+
+ guint ipv4_status;
+ guint ipv6_status;
+
+ GResolvResultFunc result_func;
+ gpointer result_data;
+};
+
+struct resolv_query {
+ GResolv *resolv;
+
+ int nr_ns;
+ guint timeout;
+
+ uint16_t msgid;
+
+ struct resolv_lookup *lookup;
+};
+
+struct resolv_nameserver {
+ GResolv *resolv;
+
+ char *address;
+ uint16_t port;
+ unsigned long flags;
+
+ GIOChannel *udp_channel;
+ guint udp_watch;
+};
+
+struct _GResolv {
+ int ref_count;
+
+ int result_family;
+
+ guint next_lookup_id;
+ GQueue *lookup_queue;
+ GQueue *query_queue;
+
+ int index;
+ GList *nameserver_list;
+
+ struct __res_state res;
+
+ GResolvDebugFunc debug_func;
+ gpointer debug_data;
+};
+
+#define debug(resolv, format, arg...) \
+ _debug(resolv, __FILE__, __func__, format, ## arg)
+
+static void _debug(GResolv *resolv, const char *file, const char *caller,
+ const char *format, ...)
+{
+ char str[256];
+ va_list ap;
+ int len;
+
+ if (!resolv->debug_func)
+ return;
+
+ va_start(ap, format);
+
+ if ((len = snprintf(str, sizeof(str), "%s:%s() resolv %p ",
+ file, caller, resolv)) > 0) {
+ if (vsnprintf(str + len, sizeof(str) - len, format, ap) > 0)
+ resolv->debug_func(str, resolv->debug_data);
+ }
+
+ va_end(ap);
+}
+
+static void destroy_query(struct resolv_query *query)
+{
+ debug(query->resolv, "query %p timeout %d", query, query->timeout);
+
+ if (query->timeout > 0)
+ g_source_remove(query->timeout);
+
+ g_free(query);
+}
+
+static void destroy_lookup(struct resolv_lookup *lookup)
+{
+ debug(lookup->resolv, "lookup %p id %d ipv4 %p ipv6 %p",
+ lookup, lookup->id, lookup->ipv4_query, lookup->ipv6_query);
+
+ if (lookup->ipv4_query) {
+ g_queue_remove(lookup->resolv->query_queue,
+ lookup->ipv4_query);
+ destroy_query(lookup->ipv4_query);
+ }
+
+ if (lookup->ipv6_query) {
+ g_queue_remove(lookup->resolv->query_queue,
+ lookup->ipv6_query);
+ destroy_query(lookup->ipv6_query);
+ }
+
+ g_free(lookup->results);
+ g_free(lookup);
+}
+
+static void find_srcaddr(struct sort_result *res)
+{
+ socklen_t sl = sizeof(res->src);
+ int fd;
+
+ fd = socket(res->dst.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC,
+ IPPROTO_IP);
+ if (fd < 0)
+ return;
+
+ if (connect(fd, &res->dst.sa, sizeof(res->dst)) < 0) {
+ close(fd);
+ return;
+ }
+
+ if (getsockname(fd, &res->src.sa, &sl) < 0) {
+ close(fd);
+ return;
+ }
+
+ res->reachable = true;
+ close(fd);
+}
+
+struct gai_table
+{
+ unsigned char addr[NS_IN6ADDRSZ];
+ int mask;
+ int value;
+};
+
+static const struct gai_table gai_labels[] = {
+ {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
+ .mask = 128,
+ .value = 0,
+ }, {
+ .addr = { 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 16,
+ .value = 2,
+ }, {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 96,
+ .value = 3,
+ }, {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 96,
+ .value = 4,
+ }, {
+ /* Variations from RFC 3484, matching glibc behaviour */
+ .addr = { 0xfe, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 10,
+ .value = 5,
+ }, {
+ .addr = { 0xfc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 7,
+ .value = 6,
+ }, {
+ .addr = { 0x20, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 32,
+ .value = 7,
+ }, {
+ /* catch-all */
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 0,
+ .value = 1,
+ }
+};
+
+static const struct gai_table gai_precedences[] = {
+ {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 },
+ .mask = 128,
+ .value = 50,
+ }, {
+ .addr = { 0x20, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 16,
+ .value = 30,
+ }, {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 96,
+ .value = 20,
+ }, {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 96,
+ .value = 10,
+ }, {
+ .addr = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
+ .mask = 0,
+ .value = 40,
+ }
+};
+
+static unsigned char v4mapped[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 };
+
+static bool mask_compare(const unsigned char *one,
+ const unsigned char *two, int mask)
+{
+ if (mask > 8) {
+ if (memcmp(one, two, mask / 8))
+ return false;
+ one += mask / 8;
+ two += mask / 8;
+ mask %= 8;
+ }
+
+ if (mask && ((*one ^ *two) >> (8 - mask)))
+ return false;
+
+ return true;
+}
+
+static int match_gai_table(struct sockaddr *sa, const struct gai_table *tbl)
+{
+ struct sockaddr_in *sin = (void *)sa;
+ struct sockaddr_in6 *sin6 = (void *)sa;
+ void *addr;
+
+ if (sa->sa_family == AF_INET) {
+ addr = v4mapped;
+ memcpy(v4mapped+12, &sin->sin_addr, NS_INADDRSZ);
+ } else
+ addr = &sin6->sin6_addr;
+
+ while (1) {
+ if (mask_compare(addr, tbl->addr, tbl->mask))
+ return tbl->value;
+ tbl++;
+ }
+}
+
+#define DQUAD(_a,_b,_c,_d) ( ((_a)<<24) | ((_b)<<16) | ((_c)<<8) | (_d) )
+#define V4MATCH(addr, a,b,c,d, m) ( ((addr) ^ DQUAD(a,b,c,d)) >> (32 - (m)) )
+
+#define RFC3484_SCOPE_LINK 2
+#define RFC3484_SCOPE_SITE 5
+#define RFC3484_SCOPE_GLOBAL 14
+
+static int addr_scope(struct sockaddr *sa)
+{
+ if (sa->sa_family == AF_INET) {
+ struct sockaddr_in *sin = (void *)sa;
+ guint32 addr = ntohl(sin->sin_addr.s_addr);
+
+ if (V4MATCH(addr, 169,254,0,0, 16) ||
+ V4MATCH(addr, 127,0,0,0, 8))
+ return RFC3484_SCOPE_LINK;
+
+ /* Site-local */
+ if (V4MATCH(addr, 10,0,0,0, 8) ||
+ V4MATCH(addr, 172,16,0,0, 12) ||
+ V4MATCH(addr, 192,168,0,0, 16))
+ return RFC3484_SCOPE_SITE;
+
+ /* Global */
+ return RFC3484_SCOPE_GLOBAL;
+ } else {
+ struct sockaddr_in6 *sin6 = (void *)sa;
+
+ /* Multicast addresses have a 4-bit scope field */
+ if (IN6_IS_ADDR_MULTICAST(&sin6->sin6_addr))
+ return sin6->sin6_addr.s6_addr[1] & 0xf;
+
+ if (IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr) ||
+ IN6_IS_ADDR_LOOPBACK(&sin6->sin6_addr))
+ return RFC3484_SCOPE_LINK;
+
+ if (IN6_IS_ADDR_SITELOCAL(&sin6->sin6_addr))
+ return RFC3484_SCOPE_SITE;
+
+ return RFC3484_SCOPE_GLOBAL;
+ }
+}
+
+static int rfc3484_compare(const void *__one, const void *__two)
+{
+ const struct sort_result *one = __one;
+ const struct sort_result *two = __two;
+
+ /* Rule 1: Avoid unusable destinations */
+ if (one->reachable && !two->reachable)
+ return -1;
+ else if (two->reachable && !one->reachable)
+ return 1;
+
+ /* Rule 2: Prefer matching scope */
+ if (one->dst_scope == one->src_scope &&
+ two->dst_scope != two->src_scope)
+ return -1;
+ else if (two->dst_scope == two->src_scope &&
+ one->dst_scope != one->src_scope)
+ return 1;
+
+ /* Rule 3: Avoid deprecated addresses */
+
+ /* Rule 4: Prefer home addresses */
+
+ /* Rule 5: Prefer matching label */
+ if (one->dst_label == one->src_label &&
+ two->dst_label != two->src_label)
+ return -1;
+ else if (two->dst_label == two->src_label &&
+ one->dst_label != one->src_label)
+ return 1;
+
+ /* Rule 6: Prefer higher precedence */
+ if (one->precedence > two->precedence)
+ return -1;
+ else if (two->precedence > one->precedence)
+ return 1;
+
+ /* Rule 7: Prefer native transport */
+
+ /* Rule 8: Prefer smaller scope */
+ if (one->dst_scope != two->dst_scope)
+ return one->dst_scope - two->dst_scope;
+
+ /* Rule 9: Use longest matching prefix */
+ if (one->dst.sa.sa_family == AF_INET) {
+ /*
+ * Rule 9 is meaningless and counterproductive for Legacy IP
+ * unless perhaps we can tell that it's actually on the local
+ * subnet. But we don't (yet) have local interface config
+ * information, so do nothing here for Legacy IP for now.
+ */
+ } else {
+ int i;
+
+ for (i = 0; i < 4; i++) {
+ guint32 cmp_one, cmp_two;
+
+ cmp_one = one->src.sin6.sin6_addr.s6_addr32[i] ^
+ one->dst.sin6.sin6_addr.s6_addr32[i];
+ cmp_two = two->src.sin6.sin6_addr.s6_addr32[i] ^
+ two->dst.sin6.sin6_addr.s6_addr32[i];
+
+ if (!cmp_two && !cmp_one)
+ continue;
+
+ if (cmp_one && !cmp_two)
+ return 1;
+ if (cmp_two && !cmp_one)
+ return -1;
+
+ /* g_bit_storage() is effectively fls() */
+ cmp_one = g_bit_storage(ntohl(cmp_one));
+ cmp_two = g_bit_storage(ntohl(cmp_two));
+
+ if (cmp_one == cmp_two)
+ break;
+
+ return cmp_one - cmp_two;
+ }
+ }
+
+
+ /* Rule 10: Otherwise, leave the order unchanged */
+ if (one < two)
+ return -1;
+ else
+ return 1;
+}
+
+static void rfc3484_sort_results(struct resolv_lookup *lookup)
+{
+ int i;
+
+ for (i = 0; i < lookup->nr_results; i++) {
+ struct sort_result *res = &lookup->results[i];
+ find_srcaddr(res);
+ res->precedence = match_gai_table(&res->dst.sa,
+ gai_precedences);
+ res->dst_label = match_gai_table(&res->dst.sa, gai_labels);
+ res->src_label = match_gai_table(&res->src.sa, gai_labels);
+ res->dst_scope = addr_scope(&res->dst.sa);
+ res->src_scope = addr_scope(&res->src.sa);
+ }
+
+ qsort(lookup->results, lookup->nr_results,
+ sizeof(struct sort_result), rfc3484_compare);
+}
+
+static void sort_and_return_results(struct resolv_lookup *lookup)
+{
+ char buf[INET6_ADDRSTRLEN + 1];
+ GResolvResultStatus status;
+ char **results = g_try_new0(char *, lookup->nr_results + 1);
+ GResolvResultFunc result_func = lookup->result_func;
+ void *result_data = lookup->result_data;
+ int i, n = 0;
+
+ if (!results)
+ return;
+
+ memset(buf, 0, INET6_ADDRSTRLEN + 1);
+
+ rfc3484_sort_results(lookup);
+
+ for (i = 0; i < lookup->nr_results; i++) {
+ if (lookup->results[i].dst.sa.sa_family == AF_INET) {
+ if (!inet_ntop(AF_INET,
+ &lookup->results[i].dst.sin.sin_addr,
+ buf, sizeof(buf) - 1))
+ continue;
+ } else if (lookup->results[i].dst.sa.sa_family == AF_INET6) {
+ if (!inet_ntop(AF_INET6,
+ &lookup->results[i].dst.sin6.sin6_addr,
+ buf, sizeof(buf) - 1))
+ continue;
+ } else
+ continue;
+
+ results[n++] = g_strdup(buf);
+ }
+
+ results[n++] = NULL;
+
+ if (lookup->resolv->result_family == AF_INET)
+ status = lookup->ipv4_status;
+ else if (lookup->resolv->result_family == AF_INET6)
+ status = lookup->ipv6_status;
+ else {
+ if (lookup->ipv6_status == G_RESOLV_RESULT_STATUS_SUCCESS)
+ status = lookup->ipv6_status;
+ else
+ status = lookup->ipv4_status;
+ }
+
+ debug(lookup->resolv, "lookup %p received %d results", lookup, n);
+
+ g_queue_remove(lookup->resolv->lookup_queue, lookup);
+ destroy_lookup(lookup);
+
+ result_func(status, results, result_data);
+
+ g_strfreev(results);
+}
+
+static gboolean query_timeout(gpointer user_data)
+{
+ struct resolv_query *query = user_data;
+ struct resolv_lookup *lookup = query->lookup;
+ GResolv *resolv = query->resolv;
+
+ query->timeout = 0;
+
+ if (query == lookup->ipv4_query) {
+ lookup->ipv4_status = G_RESOLV_RESULT_STATUS_NO_RESPONSE;
+ lookup->ipv4_query = NULL;
+ } else if (query == lookup->ipv6_query) {
+ lookup->ipv6_status = G_RESOLV_RESULT_STATUS_NO_RESPONSE;
+ lookup->ipv6_query = NULL;
+ }
+
+ g_queue_remove(resolv->query_queue, query);
+ destroy_query(query);
+
+ if (!lookup->ipv4_query && !lookup->ipv6_query)
+ sort_and_return_results(lookup);
+
+ return FALSE;
+}
+
+static void free_nameserver(struct resolv_nameserver *nameserver)
+{
+ if (!nameserver)
+ return;
+
+ if (nameserver->udp_watch > 0)
+ g_source_remove(nameserver->udp_watch);
+
+ if (nameserver->udp_channel) {
+ g_io_channel_shutdown(nameserver->udp_channel, TRUE, NULL);
+ g_io_channel_unref(nameserver->udp_channel);
+ }
+
+ g_free(nameserver->address);
+ g_free(nameserver);
+}
+
+static void flush_nameservers(GResolv *resolv)
+{
+ GList *list;
+
+ for (list = g_list_first(resolv->nameserver_list);
+ list; list = g_list_next(list))
+ free_nameserver(list->data);
+
+ g_list_free(resolv->nameserver_list);
+ resolv->nameserver_list = NULL;
+}
+
+static int send_query(GResolv *resolv, const unsigned char *buf, int len)
+{
+ GList *list;
+ int nr_ns;
+
+ if (!resolv->nameserver_list)
+ return -ENOENT;
+
+ for (list = g_list_first(resolv->nameserver_list), nr_ns = 0;
+ list; list = g_list_next(list), nr_ns++) {
+ struct resolv_nameserver *nameserver = list->data;
+ int sk, sent;
+
+ if (!nameserver->udp_channel)
+ continue;
+
+ sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
+
+ sent = send(sk, buf, len, 0);
+ if (sent < 0)
+ continue;
+ }
+
+ return nr_ns;
+}
+
+static gint compare_lookup_id(gconstpointer a, gconstpointer b)
+{
+ const struct resolv_lookup *lookup = a;
+ guint id = GPOINTER_TO_UINT(b);
+
+ if (lookup->id < id)
+ return -1;
+
+ if (lookup->id > id)
+ return 1;
+
+ return 0;
+}
+
+static gint compare_query_msgid(gconstpointer a, gconstpointer b)
+{
+ const struct resolv_query *query = a;
+ uint16_t msgid = GPOINTER_TO_UINT(b);
+
+ if (query->msgid < msgid)
+ return -1;
+
+ if (query->msgid > msgid)
+ return 1;
+
+ return 0;
+}
+
+static void add_result(struct resolv_lookup *lookup, int family,
+ const void *data)
+{
+ int n = lookup->nr_results++;
+ lookup->results = g_try_realloc(lookup->results,
+ sizeof(struct sort_result) * (n + 1));
+ if (!lookup->results)
+ return;
+
+ memset(&lookup->results[n], 0, sizeof(struct sort_result));
+
+ lookup->results[n].dst.sa.sa_family = family;
+ if (family == AF_INET)
+ memcpy(&lookup->results[n].dst.sin.sin_addr,
+ data, NS_INADDRSZ);
+ else
+ memcpy(&lookup->results[n].dst.sin6.sin6_addr,
+ data, NS_IN6ADDRSZ);
+}
+
+static void parse_response(struct resolv_nameserver *nameserver,
+ const unsigned char *buf, int len)
+{
+ GResolv *resolv = nameserver->resolv;
+ GResolvResultStatus status;
+ struct resolv_query *query;
+ struct resolv_lookup *lookup;
+ GList *list;
+ ns_msg msg;
+ ns_rr rr;
+ int i, rcode, count;
+
+ debug(resolv, "response from %s", nameserver->address);
+
+ if (ns_initparse(buf, len, &msg) < 0)
+ return;
+
+ list = g_queue_find_custom(resolv->query_queue,
+ GUINT_TO_POINTER(ns_msg_id(msg)), compare_query_msgid);
+ if (!list)
+ return;
+
+ rcode = ns_msg_getflag(msg, ns_f_rcode);
+ count = ns_msg_count(msg, ns_s_an);
+
+ debug(resolv, "msg id: 0x%04x rcode: %d count: %d",
+ ns_msg_id(msg), rcode, count);
+
+ switch (rcode) {
+ case ns_r_noerror:
+ status = G_RESOLV_RESULT_STATUS_SUCCESS;
+ break;
+ case ns_r_formerr:
+ status = G_RESOLV_RESULT_STATUS_FORMAT_ERROR;
+ break;
+ case ns_r_servfail:
+ status = G_RESOLV_RESULT_STATUS_SERVER_FAILURE;
+ break;
+ case ns_r_nxdomain:
+ status = G_RESOLV_RESULT_STATUS_NAME_ERROR;
+ break;
+ case ns_r_notimpl:
+ status = G_RESOLV_RESULT_STATUS_NOT_IMPLEMENTED;
+ break;
+ case ns_r_refused:
+ status = G_RESOLV_RESULT_STATUS_REFUSED;
+ break;
+ default:
+ status = G_RESOLV_RESULT_STATUS_ERROR;
+ break;
+ }
+
+ query = list->data;
+ query->nr_ns--;
+
+ lookup = query->lookup;
+
+ if (query == lookup->ipv6_query)
+ lookup->ipv6_status = status;
+ else if (query == lookup->ipv4_query)
+ lookup->ipv4_status = status;
+
+ for (i = 0; i < count; i++) {
+ if (ns_parserr(&msg, ns_s_an, i, &rr) < 0)
+ continue;
+
+ if (ns_rr_class(rr) != ns_c_in)
+ continue;
+
+ g_assert(offsetof(struct sockaddr_in, sin_addr) ==
+ offsetof(struct sockaddr_in6, sin6_flowinfo));
+
+ if (ns_rr_type(rr) == ns_t_a &&
+ ns_rr_rdlen(rr) == NS_INADDRSZ) {
+ add_result(lookup, AF_INET, ns_rr_rdata(rr));
+ } else if (ns_rr_type(rr) == ns_t_aaaa &&
+ ns_rr_rdlen(rr) == NS_IN6ADDRSZ) {
+ add_result(lookup, AF_INET6, ns_rr_rdata(rr));
+ }
+ }
+
+ if (status != G_RESOLV_RESULT_STATUS_SUCCESS && query->nr_ns > 0)
+ return;
+
+ if (query == lookup->ipv6_query)
+ lookup->ipv6_query = NULL;
+ else
+ lookup->ipv4_query = NULL;
+
+ g_queue_remove(resolv->query_queue, query);
+ destroy_query(query);
+
+ if (!lookup->ipv4_query && !lookup->ipv6_query)
+ sort_and_return_results(lookup);
+}
+
+static gboolean received_udp_data(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct resolv_nameserver *nameserver = user_data;
+ unsigned char buf[4096];
+ int sk, len;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ nameserver->udp_watch = 0;
+ return FALSE;
+ }
+
+ sk = g_io_channel_unix_get_fd(nameserver->udp_channel);
+
+ len = recv(sk, buf, sizeof(buf), 0);
+ if (len < 12)
+ return TRUE;
+
+ parse_response(nameserver, buf, len);
+
+ return TRUE;
+}
+
+static int connect_udp_channel(struct resolv_nameserver *nameserver)
+{
+ struct addrinfo hints, *rp;
+ char portnr[6];
+ int err, sk;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_socktype = SOCK_DGRAM;
+ hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
+
+ sprintf(portnr, "%d", nameserver->port);
+ err = getaddrinfo(nameserver->address, portnr, &hints, &rp);
+ if (err)
+ return -EINVAL;
+
+ /*
+ * Do not blindly copy this code elsewhere; it doesn't loop over the
+ * results using ->ai_next as it should. That's OK in *this* case
+ * because it was a numeric lookup; we *know* there's only one.
+ */
+ if (!rp)
+ return -EINVAL;
+
+ sk = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
+ if (sk < 0) {
+ freeaddrinfo(rp);
+ return -EIO;
+ }
+
+ /*
+ * If nameserver points to localhost ip, their is no need to
+ * bind the socket on any interface.
+ */
+ if (nameserver->resolv->index > 0 &&
+ strncmp(nameserver->address, "127.0.0.1", 9) != 0) {
+ char interface[IF_NAMESIZE];
+
+ memset(interface, 0, IF_NAMESIZE);
+ if (if_indextoname(nameserver->resolv->index, interface)) {
+ if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
+ interface, IF_NAMESIZE) < 0) {
+ close(sk);
+ freeaddrinfo(rp);
+ return -EIO;
+ }
+ }
+ }
+
+ if (connect(sk, rp->ai_addr, rp->ai_addrlen) < 0) {
+ close(sk);
+ freeaddrinfo(rp);
+ return -EIO;
+ }
+
+ freeaddrinfo(rp);
+
+ nameserver->udp_channel = g_io_channel_unix_new(sk);
+ if (!nameserver->udp_channel) {
+ close(sk);
+ return -ENOMEM;
+ }
+
+ g_io_channel_set_close_on_unref(nameserver->udp_channel, TRUE);
+
+ nameserver->udp_watch = g_io_add_watch(nameserver->udp_channel,
+ G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
+ received_udp_data, nameserver);
+
+ return 0;
+}
+
+GResolv *g_resolv_new(int index)
+{
+ GResolv *resolv;
+
+ if (index < 0)
+ return NULL;
+
+ resolv = g_try_new0(GResolv, 1);
+ if (!resolv)
+ return NULL;
+
+ resolv->ref_count = 1;
+
+ resolv->result_family = AF_UNSPEC;
+
+ resolv->next_lookup_id = 1;
+
+ resolv->query_queue = g_queue_new();
+ if (!resolv->query_queue) {
+ g_free(resolv);
+ return NULL;
+ }
+
+ resolv->lookup_queue = g_queue_new();
+ if (!resolv->lookup_queue) {
+ g_queue_free(resolv->query_queue);
+ g_free(resolv);
+ return NULL;
+ }
+
+ resolv->index = index;
+ resolv->nameserver_list = NULL;
+
+ res_ninit(&resolv->res);
+
+ return resolv;
+}
+
+GResolv *g_resolv_ref(GResolv *resolv)
+{
+ if (!resolv)
+ return NULL;
+
+ __sync_fetch_and_add(&resolv->ref_count, 1);
+
+ return resolv;
+}
+
+void g_resolv_unref(GResolv *resolv)
+{
+ struct resolv_query *query;
+ struct resolv_lookup *lookup;
+
+ if (!resolv)
+ return;
+
+ if (__sync_fetch_and_sub(&resolv->ref_count, 1) != 1)
+ return;
+
+ while ((lookup = g_queue_pop_head(resolv->lookup_queue))) {
+ debug(resolv, "lookup %p id %d", lookup, lookup->id);
+ destroy_lookup(lookup);
+ }
+
+ while ((query = g_queue_pop_head(resolv->query_queue))) {
+ debug(resolv, "query %p", query);
+ destroy_query(query);
+ }
+
+ g_queue_free(resolv->query_queue);
+ g_queue_free(resolv->lookup_queue);
+
+ flush_nameservers(resolv);
+
+ res_nclose(&resolv->res);
+
+ g_free(resolv);
+}
+
+void g_resolv_set_debug(GResolv *resolv, GResolvDebugFunc func,
+ gpointer user_data)
+{
+ if (!resolv)
+ return;
+
+ resolv->debug_func = func;
+ resolv->debug_data = user_data;
+}
+
+bool g_resolv_add_nameserver(GResolv *resolv, const char *address,
+ uint16_t port, unsigned long flags)
+{
+ struct resolv_nameserver *nameserver;
+
+ if (!resolv)
+ return false;
+
+ nameserver = g_try_new0(struct resolv_nameserver, 1);
+ if (!nameserver)
+ return false;
+
+ nameserver->address = g_strdup(address);
+ nameserver->port = port;
+ nameserver->flags = flags;
+ nameserver->resolv = resolv;
+
+ if (connect_udp_channel(nameserver) < 0) {
+ free_nameserver(nameserver);
+ return false;
+ }
+
+ resolv->nameserver_list = g_list_append(resolv->nameserver_list,
+ nameserver);
+
+ debug(resolv, "setting nameserver %s", address);
+
+ return true;
+}
+
+void g_resolv_flush_nameservers(GResolv *resolv)
+{
+ if (!resolv)
+ return;
+
+ flush_nameservers(resolv);
+}
+
+static gint add_query(struct resolv_lookup *lookup, const char *hostname, int type)
+{
+ struct resolv_query *query = g_try_new0(struct resolv_query, 1);
+ unsigned char buf[4096];
+ int len;
+
+ if (!query)
+ return -ENOMEM;
+
+ len = res_mkquery(ns_o_query, hostname, ns_c_in, type,
+ NULL, 0, NULL, buf, sizeof(buf));
+
+ query->msgid = buf[0] << 8 | buf[1];
+
+ debug(lookup->resolv, "sending %d bytes", len);
+
+ query->nr_ns = send_query(lookup->resolv, buf, len);
+ if (query->nr_ns <= 0) {
+ g_free(query);
+ return -EIO;
+ }
+
+ query->resolv = lookup->resolv;
+ query->lookup = lookup;
+
+ g_queue_push_tail(lookup->resolv->query_queue, query);
+
+ debug(lookup->resolv, "lookup %p id %d query %p", lookup, lookup->id,
+ query);
+
+ query->timeout = g_timeout_add_seconds(5, query_timeout, query);
+
+ if (type == ns_t_aaaa)
+ lookup->ipv6_query = query;
+ else
+ lookup->ipv4_query = query;
+
+ return 0;
+}
+
+guint g_resolv_lookup_hostname(GResolv *resolv, const char *hostname,
+ GResolvResultFunc func, gpointer user_data)
+{
+ struct resolv_lookup *lookup;
+
+ if (!resolv)
+ return 0;
+
+ debug(resolv, "hostname %s", hostname);
+
+ if (!resolv->nameserver_list) {
+ int i;
+
+ for (i = 0; i < resolv->res.nscount; i++) {
+ char buf[100];
+ int family = resolv->res.nsaddr_list[i].sin_family;
+ void *sa_addr = &resolv->res.nsaddr_list[i].sin_addr;
+
+ if (family != AF_INET &&
+ resolv->res._u._ext.nsaddrs[i]) {
+ family = AF_INET6;
+ sa_addr = &resolv->res._u._ext.nsaddrs[i]->sin6_addr;
+ }
+
+ if (family != AF_INET && family != AF_INET6)
+ continue;
+
+ if (inet_ntop(family, sa_addr, buf, sizeof(buf)))
+ g_resolv_add_nameserver(resolv, buf, 53, 0);
+ }
+
+ if (!resolv->nameserver_list)
+ g_resolv_add_nameserver(resolv, "127.0.0.1", 53, 0);
+ }
+
+ lookup = g_try_new0(struct resolv_lookup, 1);
+ if (!lookup)
+ return 0;
+
+ lookup->resolv = resolv;
+ lookup->result_func = func;
+ lookup->result_data = user_data;
+ lookup->id = resolv->next_lookup_id++;
+
+ if (resolv->result_family != AF_INET6) {
+ if (add_query(lookup, hostname, ns_t_a)) {
+ g_free(lookup);
+ return -EIO;
+ }
+ }
+
+ if (resolv->result_family != AF_INET) {
+ if (add_query(lookup, hostname, ns_t_aaaa)) {
+ if (resolv->result_family != AF_INET6) {
+ g_queue_remove(resolv->query_queue,
+ lookup->ipv4_query);
+ destroy_query(lookup->ipv4_query);
+ }
+
+ g_free(lookup);
+ return -EIO;
+ }
+ }
+
+ g_queue_push_tail(resolv->lookup_queue, lookup);
+
+ debug(resolv, "lookup %p id %d", lookup, lookup->id);
+
+ return lookup->id;
+}
+
+bool g_resolv_cancel_lookup(GResolv *resolv, guint id)
+{
+ struct resolv_lookup *lookup;
+ GList *list;
+
+ debug(resolv, "lookup id %d", id);
+
+ list = g_queue_find_custom(resolv->lookup_queue,
+ GUINT_TO_POINTER(id), compare_lookup_id);
+
+ if (!list)
+ return false;
+
+ lookup = list->data;
+
+ debug(resolv, "lookup %p", lookup);
+
+ g_queue_remove(resolv->lookup_queue, lookup);
+ destroy_lookup(lookup);
+
+ return true;
+}
+
+bool g_resolv_set_address_family(GResolv *resolv, int family)
+{
+ if (!resolv)
+ return false;
+
+ if (family != AF_UNSPEC && family != AF_INET && family != AF_INET6)
+ return false;
+
+ resolv->result_family = family;
+
+ return true;
+}
diff --git a/gweb/gresolv.h b/gweb/gresolv.h
new file mode 100644
index 0000000..fac14f5
--- /dev/null
+++ b/gweb/gresolv.h
@@ -0,0 +1,77 @@
+/*
+ *
+ * Resolver library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __G_RESOLV_H
+#define __G_RESOLV_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _GResolv;
+
+typedef struct _GResolv GResolv;
+
+typedef enum {
+ G_RESOLV_RESULT_STATUS_SUCCESS,
+ G_RESOLV_RESULT_STATUS_ERROR,
+ G_RESOLV_RESULT_STATUS_NO_RESPONSE,
+ G_RESOLV_RESULT_STATUS_FORMAT_ERROR,
+ G_RESOLV_RESULT_STATUS_SERVER_FAILURE,
+ G_RESOLV_RESULT_STATUS_NAME_ERROR,
+ G_RESOLV_RESULT_STATUS_NOT_IMPLEMENTED,
+ G_RESOLV_RESULT_STATUS_REFUSED,
+} GResolvResultStatus;
+
+typedef void (*GResolvResultFunc)(GResolvResultStatus status,
+ char **results, gpointer user_data);
+
+typedef void (*GResolvDebugFunc)(const char *str, gpointer user_data);
+
+GResolv *g_resolv_new(int index);
+
+GResolv *g_resolv_ref(GResolv *resolv);
+void g_resolv_unref(GResolv *resolv);
+
+void g_resolv_set_debug(GResolv *resolv,
+ GResolvDebugFunc func, gpointer user_data);
+
+bool g_resolv_add_nameserver(GResolv *resolv, const char *address,
+ uint16_t port, unsigned long flags);
+void g_resolv_flush_nameservers(GResolv *resolv);
+
+guint g_resolv_lookup_hostname(GResolv *resolv, const char *hostname,
+ GResolvResultFunc func, gpointer user_data);
+
+bool g_resolv_cancel_lookup(GResolv *resolv, guint id);
+
+bool g_resolv_set_address_family(GResolv *resolv, int family);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __G_RESOLV_H */
diff --git a/gweb/gweb.c b/gweb/gweb.c
new file mode 100644
index 0000000..f6828cf
--- /dev/null
+++ b/gweb/gweb.c
@@ -0,0 +1,1600 @@
+/*
+ *
+ * Web service library with GLib integration
+ *
+ * Copyright (C) 2009-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/sendfile.h>
+#include <sys/stat.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <net/if.h>
+#include <netinet/tcp.h>
+#include <ifaddrs.h>
+
+#include "giognutls.h"
+#include "gresolv.h"
+#include "gweb.h"
+
+#define DEFAULT_BUFFER_SIZE 2048
+
+#define SESSION_FLAG_USE_TLS (1 << 0)
+
+enum chunk_state {
+ CHUNK_SIZE,
+ CHUNK_R_BODY,
+ CHUNK_N_BODY,
+ CHUNK_DATA,
+};
+
+struct _GWebResult {
+ guint16 status;
+ const guint8 *buffer;
+ gsize length;
+ bool use_chunk;
+ gchar *last_key;
+ GHashTable *headers;
+};
+
+struct web_session {
+ GWeb *web;
+
+ char *address;
+ char *host;
+ uint16_t port;
+ unsigned long flags;
+ struct addrinfo *addr;
+
+ char *content_type;
+
+ GIOChannel *transport_channel;
+ guint transport_watch;
+ guint send_watch;
+
+ guint resolv_action;
+ guint address_action;
+ char *request;
+
+ guint8 *receive_buffer;
+ gsize receive_space;
+ GString *send_buffer;
+ GString *current_header;
+ bool header_done;
+ bool body_done;
+ bool more_data;
+ bool request_started;
+
+ enum chunk_state chunck_state;
+ gsize chunk_size;
+ gsize chunk_left;
+ gsize total_len;
+
+ GWebResult result;
+
+ GWebResultFunc result_func;
+ GWebRouteFunc route_func;
+ GWebInputFunc input_func;
+ int fd;
+ gsize length;
+ gsize offset;
+ gpointer user_data;
+};
+
+struct _GWeb {
+ int ref_count;
+
+ guint next_query_id;
+
+ int family;
+
+ int index;
+ GList *session_list;
+
+ GResolv *resolv;
+ char *proxy;
+ char *accept_option;
+ char *user_agent;
+ char *user_agent_profile;
+ char *http_version;
+ bool close_connection;
+
+ GWebDebugFunc debug_func;
+ gpointer debug_data;
+};
+
+#define debug(web, format, arg...) \
+ _debug(web, __FILE__, __func__, format, ## arg)
+
+static void _debug(GWeb *web, const char *file, const char *caller,
+ const char *format, ...)
+{
+ char str[256];
+ va_list ap;
+ int len;
+
+ if (!web->debug_func)
+ return;
+
+ va_start(ap, format);
+
+ if ((len = snprintf(str, sizeof(str), "%s:%s() web %p ",
+ file, caller, web)) > 0) {
+ if (vsnprintf(str + len, sizeof(str) - len, format, ap) > 0)
+ web->debug_func(str, web->debug_data);
+ }
+
+ va_end(ap);
+}
+
+static void free_session(struct web_session *session)
+{
+ GWeb *web;
+
+ if (!session)
+ return;
+
+ g_free(session->request);
+
+ web = session->web;
+
+ if (session->address_action > 0)
+ g_source_remove(session->address_action);
+
+ if (session->resolv_action > 0)
+ g_resolv_cancel_lookup(web->resolv, session->resolv_action);
+
+ if (session->transport_watch > 0)
+ g_source_remove(session->transport_watch);
+
+ if (session->send_watch > 0)
+ g_source_remove(session->send_watch);
+
+ if (session->transport_channel)
+ g_io_channel_unref(session->transport_channel);
+
+ g_free(session->result.last_key);
+
+ if (session->result.headers)
+ g_hash_table_destroy(session->result.headers);
+
+ if (session->send_buffer)
+ g_string_free(session->send_buffer, TRUE);
+
+ if (session->current_header)
+ g_string_free(session->current_header, TRUE);
+
+ g_free(session->receive_buffer);
+
+ g_free(session->content_type);
+
+ g_free(session->host);
+ g_free(session->address);
+ if (session->addr)
+ freeaddrinfo(session->addr);
+
+ g_free(session);
+}
+
+static void flush_sessions(GWeb *web)
+{
+ GList *list;
+
+ for (list = g_list_first(web->session_list);
+ list; list = g_list_next(list))
+ free_session(list->data);
+
+ g_list_free(web->session_list);
+ web->session_list = NULL;
+}
+
+GWeb *g_web_new(int index)
+{
+ GWeb *web;
+
+ if (index < 0)
+ return NULL;
+
+ web = g_try_new0(GWeb, 1);
+ if (!web)
+ return NULL;
+
+ web->ref_count = 1;
+
+ web->next_query_id = 1;
+
+ web->family = AF_UNSPEC;
+
+ web->index = index;
+ web->session_list = NULL;
+
+ web->resolv = g_resolv_new(index);
+ if (!web->resolv) {
+ g_free(web);
+ return NULL;
+ }
+
+ web->accept_option = g_strdup("*/*");
+ web->user_agent = g_strdup_printf("GWeb/%s", VERSION);
+ web->close_connection = false;
+
+ return web;
+}
+
+GWeb *g_web_ref(GWeb *web)
+{
+ if (!web)
+ return NULL;
+
+ __sync_fetch_and_add(&web->ref_count, 1);
+
+ return web;
+}
+
+void g_web_unref(GWeb *web)
+{
+ if (!web)
+ return;
+
+ if (__sync_fetch_and_sub(&web->ref_count, 1) != 1)
+ return;
+
+ flush_sessions(web);
+
+ g_resolv_unref(web->resolv);
+
+ g_free(web->proxy);
+
+ g_free(web->accept_option);
+ g_free(web->user_agent);
+ g_free(web->user_agent_profile);
+ g_free(web->http_version);
+
+ g_free(web);
+}
+
+bool g_web_supports_tls(void)
+{
+ return g_io_channel_supports_tls();
+}
+
+void g_web_set_debug(GWeb *web, GWebDebugFunc func, gpointer user_data)
+{
+ if (!web)
+ return;
+
+ web->debug_func = func;
+ web->debug_data = user_data;
+
+ g_resolv_set_debug(web->resolv, func, user_data);
+}
+
+bool g_web_set_proxy(GWeb *web, const char *proxy)
+{
+ if (!web)
+ return false;
+
+ g_free(web->proxy);
+
+ if (!proxy) {
+ web->proxy = NULL;
+ debug(web, "clearing proxy");
+ } else {
+ web->proxy = g_strdup(proxy);
+ debug(web, "setting proxy %s", web->proxy);
+ }
+
+ return true;
+}
+
+bool g_web_set_address_family(GWeb *web, int family)
+{
+ if (!web)
+ return false;
+
+ if (family != AF_UNSPEC && family != AF_INET && family != AF_INET6)
+ return false;
+
+ web->family = family;
+
+ g_resolv_set_address_family(web->resolv, family);
+
+ return true;
+}
+
+bool g_web_add_nameserver(GWeb *web, const char *address)
+{
+ if (!web)
+ return false;
+
+ g_resolv_add_nameserver(web->resolv, address, 53, 0);
+
+ return true;
+}
+
+static bool set_accept_option(GWeb *web, const char *format, va_list args)
+{
+ g_free(web->accept_option);
+
+ if (!format) {
+ web->accept_option = NULL;
+ debug(web, "clearing accept option");
+ } else {
+ web->accept_option = g_strdup_vprintf(format, args);
+ debug(web, "setting accept %s", web->accept_option);
+ }
+
+ return true;
+}
+
+bool g_web_set_accept(GWeb *web, const char *format, ...)
+{
+ va_list args;
+ bool result;
+
+ if (!web)
+ return false;
+
+ va_start(args, format);
+ result = set_accept_option(web, format, args);
+ va_end(args);
+
+ return result;
+}
+
+static bool set_user_agent(GWeb *web, const char *format, va_list args)
+{
+ g_free(web->user_agent);
+
+ if (!format) {
+ web->user_agent = NULL;
+ debug(web, "clearing user agent");
+ } else {
+ web->user_agent = g_strdup_vprintf(format, args);
+ debug(web, "setting user agent %s", web->user_agent);
+ }
+
+ return true;
+}
+
+bool g_web_set_user_agent(GWeb *web, const char *format, ...)
+{
+ va_list args;
+ bool result;
+
+ if (!web)
+ return false;
+
+ va_start(args, format);
+ result = set_user_agent(web, format, args);
+ va_end(args);
+
+ return result;
+}
+
+bool g_web_set_ua_profile(GWeb *web, const char *profile)
+{
+ if (!web)
+ return false;
+
+ g_free(web->user_agent_profile);
+
+ web->user_agent_profile = g_strdup(profile);
+ debug(web, "setting user agent profile %s", web->user_agent);
+
+ return true;
+}
+
+bool g_web_set_http_version(GWeb *web, const char *version)
+{
+ if (!web)
+ return false;
+
+ g_free(web->http_version);
+
+ if (!version) {
+ web->http_version = NULL;
+ debug(web, "clearing HTTP version");
+ } else {
+ web->http_version = g_strdup(version);
+ debug(web, "setting HTTP version %s", web->http_version);
+ }
+
+ return true;
+}
+
+void g_web_set_close_connection(GWeb *web, bool enabled)
+{
+ if (!web)
+ return;
+
+ web->close_connection = enabled;
+}
+
+bool g_web_get_close_connection(GWeb *web)
+{
+ if (!web)
+ return false;
+
+ return web->close_connection;
+}
+
+static inline void call_result_func(struct web_session *session, guint16 status)
+{
+
+ if (!session->result_func)
+ return;
+
+ if (status != 0)
+ session->result.status = status;
+
+ session->result_func(&session->result, session->user_data);
+
+}
+
+static inline void call_route_func(struct web_session *session)
+{
+ if (session->route_func)
+ session->route_func(session->address, session->addr->ai_family,
+ session->web->index, session->user_data);
+}
+
+static bool process_send_buffer(struct web_session *session)
+{
+ GString *buf;
+ gsize count, bytes_written;
+ GIOStatus status;
+
+ if (!session)
+ return false;
+
+ buf = session->send_buffer;
+ count = buf->len;
+
+ if (count == 0) {
+ if (session->request_started &&
+ !session->more_data &&
+ session->fd == -1)
+ session->body_done = true;
+
+ return false;
+ }
+
+ status = g_io_channel_write_chars(session->transport_channel,
+ buf->str, count, &bytes_written, NULL);
+
+ debug(session->web, "status %u bytes to write %zu bytes written %zu",
+ status, count, bytes_written);
+
+ if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN)
+ return false;
+
+ g_string_erase(buf, 0, bytes_written);
+
+ return true;
+}
+
+static bool process_send_file(struct web_session *session)
+{
+ int sk;
+ off_t offset;
+ ssize_t bytes_sent;
+
+ if (session->fd == -1)
+ return false;
+
+ if (!session->request_started || session->more_data)
+ return false;
+
+ sk = g_io_channel_unix_get_fd(session->transport_channel);
+ if (sk < 0)
+ return false;
+
+ offset = session->offset;
+
+ bytes_sent = sendfile(sk, session->fd, &offset, session->length);
+
+ debug(session->web, "errno: %d, bytes to send %zu / bytes sent %zu",
+ errno, session->length, bytes_sent);
+
+ if (bytes_sent < 0 && errno != EAGAIN)
+ return false;
+
+ session->offset = offset;
+ session->length -= bytes_sent;
+
+ if (session->length == 0) {
+ session->body_done = true;
+ return false;
+ }
+
+ return true;
+}
+
+static void process_next_chunk(struct web_session *session)
+{
+ GString *buf = session->send_buffer;
+ const guint8 *body;
+ gsize length;
+
+ if (!session->input_func) {
+ session->more_data = false;
+ return;
+ }
+
+ session->more_data = session->input_func(&body, &length,
+ session->user_data);
+
+ if (length > 0) {
+ g_string_append_printf(buf, "%zx\r\n", length);
+ g_string_append_len(buf, (char *) body, length);
+ g_string_append(buf, "\r\n");
+ }
+
+ if (!session->more_data)
+ g_string_append(buf, "0\r\n\r\n");
+}
+
+static void start_request(struct web_session *session)
+{
+ GString *buf = session->send_buffer;
+ const char *version;
+ const guint8 *body;
+ gsize length;
+
+ debug(session->web, "request %s from %s",
+ session->request, session->host);
+
+ g_string_truncate(buf, 0);
+
+ if (!session->web->http_version)
+ version = "1.1";
+ else
+ version = session->web->http_version;
+
+ if (!session->content_type)
+ g_string_append_printf(buf, "GET %s HTTP/%s\r\n",
+ session->request, version);
+ else
+ g_string_append_printf(buf, "POST %s HTTP/%s\r\n",
+ session->request, version);
+
+ g_string_append_printf(buf, "Host: %s\r\n", session->host);
+
+ if (session->web->user_agent)
+ g_string_append_printf(buf, "User-Agent: %s\r\n",
+ session->web->user_agent);
+
+ if (session->web->user_agent_profile) {
+ g_string_append_printf(buf, "x-wap-profile: %s\r\n",
+ session->web->user_agent_profile);
+ }
+
+ if (session->web->accept_option)
+ g_string_append_printf(buf, "Accept: %s\r\n",
+ session->web->accept_option);
+
+ if (session->content_type) {
+ g_string_append_printf(buf, "Content-Type: %s\r\n",
+ session->content_type);
+ if (!session->input_func) {
+ session->more_data = false;
+ length = session->length;
+ } else
+ session->more_data = session->input_func(&body, &length,
+ session->user_data);
+ if (!session->more_data)
+ g_string_append_printf(buf, "Content-Length: %zu\r\n",
+ length);
+ else
+ g_string_append(buf, "Transfer-Encoding: chunked\r\n");
+ }
+
+ if (session->web->close_connection)
+ g_string_append(buf, "Connection: close\r\n");
+
+ g_string_append(buf, "\r\n");
+
+ if (session->content_type && length > 0) {
+ if (session->more_data) {
+ g_string_append_printf(buf, "%zx\r\n", length);
+ g_string_append_len(buf, (char *) body, length);
+ g_string_append(buf, "\r\n");
+ } else if (session->fd == -1)
+ g_string_append_len(buf, (char *) body, length);
+ }
+}
+
+static gboolean send_data(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct web_session *session = user_data;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ session->send_watch = 0;
+ return FALSE;
+ }
+
+ if (process_send_buffer(session))
+ return TRUE;
+
+ if (process_send_file(session))
+ return TRUE;
+
+ if (!session->request_started) {
+ session->request_started = true;
+ start_request(session);
+ } else if (session->more_data)
+ process_next_chunk(session);
+
+ process_send_buffer(session);
+
+ if (session->body_done) {
+ session->send_watch = 0;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static int decode_chunked(struct web_session *session,
+ const guint8 *buf, gsize len)
+{
+ const guint8 *ptr = buf;
+ gsize counter;
+
+ while (len > 0) {
+ guint8 *pos;
+ gsize count;
+ char *str;
+
+ switch (session->chunck_state) {
+ case CHUNK_SIZE:
+ pos = memchr(ptr, '\n', len);
+ if (!pos) {
+ g_string_append_len(session->current_header,
+ (gchar *) ptr, len);
+ return 0;
+ }
+
+ count = pos - ptr;
+ if (count < 1 || ptr[count - 1] != '\r')
+ return -EILSEQ;
+
+ g_string_append_len(session->current_header,
+ (gchar *) ptr, count);
+
+ len -= count + 1;
+ ptr = pos + 1;
+
+ str = session->current_header->str;
+
+ counter = strtoul(str, NULL, 16);
+ if ((counter == 0 && errno == EINVAL) ||
+ counter == ULONG_MAX)
+ return -EILSEQ;
+
+ session->chunk_size = counter;
+ session->chunk_left = counter;
+
+ session->chunck_state = CHUNK_DATA;
+ break;
+ case CHUNK_R_BODY:
+ if (*ptr != '\r')
+ return -EILSEQ;
+ ptr++;
+ len--;
+ session->chunck_state = CHUNK_N_BODY;
+ break;
+ case CHUNK_N_BODY:
+ if (*ptr != '\n')
+ return -EILSEQ;
+ ptr++;
+ len--;
+ session->chunck_state = CHUNK_SIZE;
+ break;
+ case CHUNK_DATA:
+ if (session->chunk_size == 0) {
+ debug(session->web, "Download Done in chunk");
+ g_string_truncate(session->current_header, 0);
+ return 0;
+ }
+
+ if (session->chunk_left <= len) {
+ session->result.buffer = ptr;
+ session->result.length = session->chunk_left;
+ call_result_func(session, 0);
+
+ len -= session->chunk_left;
+ ptr += session->chunk_left;
+
+ session->total_len += session->chunk_left;
+ session->chunk_left = 0;
+
+ g_string_truncate(session->current_header, 0);
+ session->chunck_state = CHUNK_R_BODY;
+ break;
+ }
+ /* more data */
+ session->result.buffer = ptr;
+ session->result.length = len;
+ call_result_func(session, 0);
+
+ session->chunk_left -= len;
+ session->total_len += len;
+
+ len -= len;
+ ptr += len;
+ break;
+ }
+ }
+
+ return 0;
+}
+
+static int handle_body(struct web_session *session,
+ const guint8 *buf, gsize len)
+{
+ int err;
+
+ debug(session->web, "[body] length %zu", len);
+
+ if (!session->result.use_chunk) {
+ if (len > 0) {
+ session->result.buffer = buf;
+ session->result.length = len;
+ call_result_func(session, 0);
+ }
+ return 0;
+ }
+
+ err = decode_chunked(session, buf, len);
+ if (err < 0) {
+ debug(session->web, "Error in chunk decode %d", err);
+
+ session->result.buffer = NULL;
+ session->result.length = 0;
+ call_result_func(session, 400);
+ }
+
+ return err;
+}
+
+static void handle_multi_line(struct web_session *session)
+{
+ gsize count;
+ char *str;
+ gchar *value;
+
+ str = session->current_header->str;
+
+ if (str[0] != ' ' && str[0] != '\t')
+ return;
+
+ while (str[0] == ' ' || str[0] == '\t')
+ str++;
+
+ count = str - session->current_header->str;
+ if (count > 0) {
+ g_string_erase(session->current_header, 0, count);
+ g_string_insert_c(session->current_header, 0, ' ');
+ }
+
+ value = g_hash_table_lookup(session->result.headers,
+ session->result.last_key);
+ if (value) {
+ g_string_insert(session->current_header, 0, value);
+
+ str = session->current_header->str;
+
+ g_hash_table_replace(session->result.headers,
+ g_strdup(session->result.last_key),
+ g_strdup(str));
+ }
+}
+
+static void add_header_field(struct web_session *session)
+{
+ gsize count;
+ guint8 *pos;
+ char *str;
+ gchar *value;
+ gchar *key;
+
+ str = session->current_header->str;
+
+ pos = memchr(str, ':', session->current_header->len);
+ if (pos) {
+ *pos = '\0';
+ pos++;
+
+ key = g_strdup(str);
+
+ /* remove preceding white spaces */
+ while (*pos == ' ')
+ pos++;
+
+ count = (char *) pos - str;
+
+ g_string_erase(session->current_header, 0, count);
+
+ value = g_hash_table_lookup(session->result.headers, key);
+ if (value) {
+ g_string_insert_c(session->current_header, 0, ' ');
+ g_string_insert_c(session->current_header, 0, ';');
+
+ g_string_insert(session->current_header, 0, value);
+ }
+
+ str = session->current_header->str;
+ g_hash_table_replace(session->result.headers, key,
+ g_strdup(str));
+
+ g_free(session->result.last_key);
+ session->result.last_key = g_strdup(key);
+ }
+}
+
+static gboolean received_data(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct web_session *session = user_data;
+ guint8 *ptr = session->receive_buffer;
+ gsize bytes_read;
+ GIOStatus status;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ session->transport_watch = 0;
+ session->result.buffer = NULL;
+ session->result.length = 0;
+ call_result_func(session, 400);
+ return FALSE;
+ }
+
+ status = g_io_channel_read_chars(channel,
+ (gchar *) session->receive_buffer,
+ session->receive_space - 1, &bytes_read, NULL);
+
+ debug(session->web, "bytes read %zu", bytes_read);
+
+ if (status != G_IO_STATUS_NORMAL && status != G_IO_STATUS_AGAIN) {
+ session->transport_watch = 0;
+ session->result.buffer = NULL;
+ session->result.length = 0;
+ call_result_func(session, 0);
+ return FALSE;
+ }
+
+ session->receive_buffer[bytes_read] = '\0';
+
+ if (session->header_done) {
+ if (handle_body(session, session->receive_buffer,
+ bytes_read) < 0) {
+ session->transport_watch = 0;
+ return FALSE;
+ }
+ return TRUE;
+ }
+
+ while (bytes_read > 0) {
+ guint8 *pos;
+ gsize count;
+ char *str;
+
+ pos = memchr(ptr, '\n', bytes_read);
+ if (!pos) {
+ g_string_append_len(session->current_header,
+ (gchar *) ptr, bytes_read);
+ return TRUE;
+ }
+
+ *pos = '\0';
+ count = strlen((char *) ptr);
+ if (count > 0 && ptr[count - 1] == '\r') {
+ ptr[--count] = '\0';
+ bytes_read--;
+ }
+
+ g_string_append_len(session->current_header,
+ (gchar *) ptr, count);
+
+ bytes_read -= count + 1;
+ if (bytes_read > 0)
+ ptr = pos + 1;
+ else
+ ptr = NULL;
+
+ if (session->current_header->len == 0) {
+ char *val;
+
+ session->header_done = true;
+
+ val = g_hash_table_lookup(session->result.headers,
+ "Transfer-Encoding");
+ if (val) {
+ val = g_strrstr(val, "chunked");
+ if (val) {
+ session->result.use_chunk = true;
+
+ session->chunck_state = CHUNK_SIZE;
+ session->chunk_left = 0;
+ session->total_len = 0;
+ }
+ }
+
+ if (handle_body(session, ptr, bytes_read) < 0) {
+ session->transport_watch = 0;
+ return FALSE;
+ }
+ break;
+ }
+
+ str = session->current_header->str;
+
+ if (session->result.status == 0) {
+ unsigned int code;
+
+ if (sscanf(str, "HTTP/%*s %u %*s", &code) == 1)
+ session->result.status = code;
+ }
+
+ debug(session->web, "[header] %s", str);
+
+ /* handle multi-line header */
+ if (str[0] == ' ' || str[0] == '\t')
+ handle_multi_line(session);
+ else
+ add_header_field(session);
+
+ g_string_truncate(session->current_header, 0);
+ }
+
+ return TRUE;
+}
+
+static int bind_to_address(int sk, const char *interface, int family)
+{
+ struct ifaddrs *ifaddr_list, *ifaddr;
+ int size, err = -1;
+
+ if (getifaddrs(&ifaddr_list) < 0)
+ return err;
+
+ for (ifaddr = ifaddr_list; ifaddr; ifaddr = ifaddr->ifa_next) {
+ if (g_strcmp0(ifaddr->ifa_name, interface) != 0)
+ continue;
+
+ if (!ifaddr->ifa_addr ||
+ ifaddr->ifa_addr->sa_family != family)
+ continue;
+
+ switch (family) {
+ case AF_INET:
+ size = sizeof(struct sockaddr_in);
+ break;
+ case AF_INET6:
+ size = sizeof(struct sockaddr_in6);
+ break;
+ default:
+ continue;
+ }
+
+ err = bind(sk, (struct sockaddr *) ifaddr->ifa_addr, size);
+ break;
+ }
+
+ freeifaddrs(ifaddr_list);
+ return err;
+}
+
+static inline int bind_socket(int sk, int index, int family)
+{
+ char interface[IF_NAMESIZE];
+ int err;
+
+ if (!if_indextoname(index, interface))
+ return -1;
+
+ err = setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
+ interface, IF_NAMESIZE);
+ if (err < 0)
+ err = bind_to_address(sk, interface, family);
+
+ return err;
+}
+
+static int connect_session_transport(struct web_session *session)
+{
+ GIOFlags flags;
+ int sk;
+
+ sk = socket(session->addr->ai_family, SOCK_STREAM | SOCK_CLOEXEC,
+ IPPROTO_TCP);
+ if (sk < 0)
+ return -EIO;
+
+ if (session->web->index > 0) {
+ if (bind_socket(sk, session->web->index,
+ session->addr->ai_family) < 0) {
+ debug(session->web, "bind() %s", strerror(errno));
+ close(sk);
+ return -EIO;
+ }
+ }
+
+ if (session->flags & SESSION_FLAG_USE_TLS) {
+ debug(session->web, "using TLS encryption");
+ session->transport_channel = g_io_channel_gnutls_new(sk);
+ } else {
+ debug(session->web, "no encryption");
+ session->transport_channel = g_io_channel_unix_new(sk);
+ }
+
+ if (!session->transport_channel) {
+ debug(session->web, "channel missing");
+ close(sk);
+ return -ENOMEM;
+ }
+
+ flags = g_io_channel_get_flags(session->transport_channel);
+ g_io_channel_set_flags(session->transport_channel,
+ flags | G_IO_FLAG_NONBLOCK, NULL);
+
+ g_io_channel_set_encoding(session->transport_channel, NULL, NULL);
+ g_io_channel_set_buffered(session->transport_channel, FALSE);
+
+ g_io_channel_set_close_on_unref(session->transport_channel, TRUE);
+
+ if (connect(sk, session->addr->ai_addr,
+ session->addr->ai_addrlen) < 0) {
+ if (errno != EINPROGRESS) {
+ debug(session->web, "connect() %s", strerror(errno));
+ close(sk);
+ return -EIO;
+ }
+ }
+
+ session->transport_watch = g_io_add_watch(session->transport_channel,
+ G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
+ received_data, session);
+
+ session->send_watch = g_io_add_watch(session->transport_channel,
+ G_IO_OUT | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
+ send_data, session);
+
+ return 0;
+}
+
+static int create_transport(struct web_session *session)
+{
+ int err;
+
+ err = connect_session_transport(session);
+ if (err < 0)
+ return err;
+
+ debug(session->web, "creating session %s:%u",
+ session->address, session->port);
+
+ return 0;
+}
+
+static int parse_url(struct web_session *session,
+ const char *url, const char *proxy)
+{
+ char *scheme, *host, *port, *path;
+
+ scheme = g_strdup(url);
+ if (!scheme)
+ return -EINVAL;
+
+ host = strstr(scheme, "://");
+ if (host) {
+ *host = '\0';
+ host += 3;
+
+ if (strcasecmp(scheme, "https") == 0) {
+ session->port = 443;
+ session->flags |= SESSION_FLAG_USE_TLS;
+ } else if (strcasecmp(scheme, "http") == 0) {
+ session->port = 80;
+ } else {
+ g_free(scheme);
+ return -EINVAL;
+ }
+ } else {
+ host = scheme;
+ session->port = 80;
+ }
+
+ path = strchr(host, '/');
+ if (path)
+ *(path++) = '\0';
+
+ if (!proxy)
+ session->request = g_strdup_printf("/%s", path ? path : "");
+ else
+ session->request = g_strdup(url);
+
+ port = strrchr(host, ':');
+ if (port) {
+ char *end;
+ int tmp = strtol(port + 1, &end, 10);
+
+ if (*end == '\0') {
+ *port = '\0';
+ session->port = tmp;
+ }
+
+ if (!proxy)
+ session->host = g_strdup(host);
+ else
+ session->host = g_strdup_printf("%s:%u", host, tmp);
+ } else
+ session->host = g_strdup(host);
+
+ g_free(scheme);
+
+ if (!proxy)
+ return 0;
+
+ scheme = g_strdup(proxy);
+ if (!scheme)
+ return -EINVAL;
+
+ host = strstr(proxy, "://");
+ if (host) {
+ *host = '\0';
+ host += 3;
+
+ if (strcasecmp(scheme, "http") != 0) {
+ g_free(scheme);
+ return -EINVAL;
+ }
+ } else
+ host = scheme;
+
+ path = strchr(host, '/');
+ if (path)
+ *(path++) = '\0';
+
+ port = strrchr(host, ':');
+ if (port) {
+ char *end;
+ int tmp = strtol(port + 1, &end, 10);
+
+ if (*end == '\0') {
+ *port = '\0';
+ session->port = tmp;
+ }
+ }
+
+ session->address = g_strdup(host);
+
+ g_free(scheme);
+
+ return 0;
+}
+
+static void handle_resolved_address(struct web_session *session)
+{
+ struct addrinfo hints;
+ char *port;
+ int ret;
+
+ debug(session->web, "address %s", session->address);
+
+ memset(&hints, 0, sizeof(struct addrinfo));
+ hints.ai_flags = AI_NUMERICHOST;
+ hints.ai_family = session->web->family;
+
+ if (session->addr) {
+ freeaddrinfo(session->addr);
+ session->addr = NULL;
+ }
+
+ port = g_strdup_printf("%u", session->port);
+ ret = getaddrinfo(session->address, port, &hints, &session->addr);
+ g_free(port);
+ if (ret != 0 || !session->addr) {
+ call_result_func(session, 400);
+ return;
+ }
+
+ call_route_func(session);
+
+ if (create_transport(session) < 0) {
+ call_result_func(session, 409);
+ return;
+ }
+}
+
+static gboolean already_resolved(gpointer data)
+{
+ struct web_session *session = data;
+
+ session->address_action = 0;
+ handle_resolved_address(session);
+
+ return FALSE;
+}
+
+static void resolv_result(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+ struct web_session *session = user_data;
+
+ if (!results || !results[0]) {
+ call_result_func(session, 404);
+ return;
+ }
+
+ g_free(session->address);
+ session->address = g_strdup(results[0]);
+
+ handle_resolved_address(session);
+}
+
+static bool is_ip_address(const char *host)
+{
+ struct addrinfo hints;
+ struct addrinfo *addr;
+ int result;
+
+ memset(&hints, 0, sizeof(struct addrinfo));
+ hints.ai_flags = AI_NUMERICHOST;
+ addr = NULL;
+
+ result = getaddrinfo(host, NULL, &hints, &addr);
+ freeaddrinfo(addr);
+
+ return result == 0;
+}
+
+static guint do_request(GWeb *web, const char *url,
+ const char *type, GWebInputFunc input,
+ int fd, gsize length, GWebResultFunc func,
+ GWebRouteFunc route, gpointer user_data)
+{
+ struct web_session *session;
+ const gchar *host;
+
+ if (!web || !url)
+ return 0;
+
+ debug(web, "request %s", url);
+
+ session = g_try_new0(struct web_session, 1);
+ if (!session)
+ return 0;
+
+ if (parse_url(session, url, web->proxy) < 0) {
+ free_session(session);
+ return 0;
+ }
+
+ debug(web, "proxy host %s", session->address);
+ debug(web, "port %u", session->port);
+ debug(web, "host %s", session->host);
+ debug(web, "flags %lu", session->flags);
+ debug(web, "request %s", session->request);
+
+ if (type) {
+ session->content_type = g_strdup(type);
+
+ debug(web, "content-type %s", session->content_type);
+ }
+
+ session->web = web;
+
+ session->result_func = func;
+ session->route_func = route;
+ session->input_func = input;
+ session->fd = fd;
+ session->length = length;
+ session->offset = 0;
+ session->user_data = user_data;
+
+ session->receive_buffer = g_try_malloc(DEFAULT_BUFFER_SIZE);
+ if (!session->receive_buffer) {
+ free_session(session);
+ return 0;
+ }
+
+ session->result.headers = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+ if (!session->result.headers) {
+ free_session(session);
+ return 0;
+ }
+
+ session->receive_space = DEFAULT_BUFFER_SIZE;
+ session->send_buffer = g_string_sized_new(0);
+ session->current_header = g_string_sized_new(0);
+ session->header_done = false;
+ session->body_done = false;
+
+ host = session->address ? session->address : session->host;
+ if (is_ip_address(host)) {
+ if (session->address != host) {
+ g_free(session->address);
+ session->address = g_strdup(host);
+ }
+ session->address_action = g_timeout_add(0, already_resolved,
+ session);
+ } else {
+ session->resolv_action = g_resolv_lookup_hostname(web->resolv,
+ host, resolv_result, session);
+ if (session->resolv_action == 0) {
+ free_session(session);
+ return 0;
+ }
+ }
+
+ web->session_list = g_list_append(web->session_list, session);
+
+ return web->next_query_id++;
+}
+
+guint g_web_request_get(GWeb *web, const char *url, GWebResultFunc func,
+ GWebRouteFunc route, gpointer user_data)
+{
+ return do_request(web, url, NULL, NULL, -1, 0, func, route, user_data);
+}
+
+guint g_web_request_post(GWeb *web, const char *url,
+ const char *type, GWebInputFunc input,
+ GWebResultFunc func, gpointer user_data)
+{
+ return do_request(web, url, type, input, -1, 0, func, NULL, user_data);
+}
+
+guint g_web_request_post_file(GWeb *web, const char *url,
+ const char *type, const char *file,
+ GWebResultFunc func, gpointer user_data)
+{
+ struct stat st;
+ int fd;
+ guint ret;
+
+ if (stat(file, &st) < 0)
+ return 0;
+
+ fd = open(file, O_RDONLY);
+ if (fd < 0)
+ return 0;
+
+ ret = do_request(web, url, type, NULL, fd, st.st_size, func, NULL,
+ user_data);
+ if (ret == 0)
+ close(fd);
+
+ return ret;
+}
+
+bool g_web_cancel_request(GWeb *web, guint id)
+{
+ if (!web)
+ return false;
+
+ return true;
+}
+
+guint16 g_web_result_get_status(GWebResult *result)
+{
+ if (!result)
+ return 0;
+
+ return result->status;
+}
+
+bool g_web_result_get_chunk(GWebResult *result,
+ const guint8 **chunk, gsize *length)
+{
+ if (!result)
+ return false;
+
+ if (!chunk)
+ return false;
+
+ *chunk = result->buffer;
+
+ if (length)
+ *length = result->length;
+
+ return true;
+}
+
+bool g_web_result_get_header(GWebResult *result,
+ const char *header, const char **value)
+{
+ if (!result)
+ return false;
+
+ if (!value)
+ return false;
+
+ *value = g_hash_table_lookup(result->headers, header);
+
+ if (!*value)
+ return false;
+
+ return true;
+}
+
+struct _GWebParser {
+ gint ref_count;
+ char *begin_token;
+ char *end_token;
+ const char *token_str;
+ size_t token_len;
+ size_t token_pos;
+ bool intoken;
+ GString *content;
+ GWebParserFunc func;
+ gpointer user_data;
+};
+
+GWebParser *g_web_parser_new(const char *begin, const char *end,
+ GWebParserFunc func, gpointer user_data)
+{
+ GWebParser *parser;
+
+ parser = g_try_new0(GWebParser, 1);
+ if (!parser)
+ return NULL;
+
+ parser->ref_count = 1;
+
+ parser->begin_token = g_strdup(begin);
+ parser->end_token = g_strdup(end);
+
+ if (!parser->begin_token) {
+ g_free(parser);
+ return NULL;
+ }
+
+ parser->func = func;
+ parser->user_data = user_data;
+
+ parser->token_str = parser->begin_token;
+ parser->token_len = strlen(parser->token_str);
+ parser->token_pos = 0;
+
+ parser->intoken = false;
+ parser->content = g_string_sized_new(0);
+
+ return parser;
+}
+
+GWebParser *g_web_parser_ref(GWebParser *parser)
+{
+ if (!parser)
+ return NULL;
+
+ __sync_fetch_and_add(&parser->ref_count, 1);
+
+ return parser;
+}
+
+void g_web_parser_unref(GWebParser *parser)
+{
+ if (!parser)
+ return;
+
+ if (__sync_fetch_and_sub(&parser->ref_count, 1) != 1)
+ return;
+
+ g_string_free(parser->content, TRUE);
+
+ g_free(parser->begin_token);
+ g_free(parser->end_token);
+ g_free(parser);
+}
+
+void g_web_parser_feed_data(GWebParser *parser,
+ const guint8 *data, gsize length)
+{
+ const guint8 *ptr = data;
+
+ if (!parser)
+ return;
+
+ while (length > 0) {
+ guint8 chr = parser->token_str[parser->token_pos];
+
+ if (parser->token_pos == 0) {
+ guint8 *pos;
+
+ pos = memchr(ptr, chr, length);
+ if (!pos) {
+ if (parser->intoken)
+ g_string_append_len(parser->content,
+ (gchar *) ptr, length);
+ break;
+ }
+
+ if (parser->intoken)
+ g_string_append_len(parser->content,
+ (gchar *) ptr, (pos - ptr) + 1);
+
+ length -= (pos - ptr) + 1;
+ ptr = pos + 1;
+
+ parser->token_pos++;
+ continue;
+ }
+
+ if (parser->intoken)
+ g_string_append_c(parser->content, ptr[0]);
+
+ if (ptr[0] != chr) {
+ length--;
+ ptr++;
+
+ parser->token_pos = 0;
+ continue;
+ }
+
+ length--;
+ ptr++;
+
+ parser->token_pos++;
+
+ if (parser->token_pos == parser->token_len) {
+ if (!parser->intoken) {
+ g_string_append(parser->content,
+ parser->token_str);
+
+ parser->intoken = true;
+ parser->token_str = parser->end_token;
+ parser->token_len = strlen(parser->end_token);
+ parser->token_pos = 0;
+ } else {
+ char *str;
+ str = g_string_free(parser->content, FALSE);
+ parser->content = g_string_sized_new(0);
+ if (parser->func)
+ parser->func(str, parser->user_data);
+ g_free(str);
+
+ parser->intoken = false;
+ parser->token_str = parser->begin_token;
+ parser->token_len = strlen(parser->begin_token);
+ parser->token_pos = 0;
+ }
+ }
+ }
+}
+
+void g_web_parser_end_data(GWebParser *parser)
+{
+ if (!parser)
+ return;
+}
diff --git a/gweb/gweb.h b/gweb/gweb.h
new file mode 100644
index 0000000..6c28542
--- /dev/null
+++ b/gweb/gweb.h
@@ -0,0 +1,113 @@
+/*
+ *
+ * Web service library with GLib integration
+ *
+ * Copyright (C) 2009-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __G_WEB_H
+#define __G_WEB_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _GWeb;
+struct _GWebResult;
+struct _GWebParser;
+
+typedef struct _GWeb GWeb;
+typedef struct _GWebResult GWebResult;
+typedef struct _GWebParser GWebParser;
+
+typedef bool (*GWebResultFunc)(GWebResult *result, gpointer user_data);
+
+typedef bool (*GWebRouteFunc)(const char *addr, int ai_family,
+ int if_index, gpointer user_data);
+
+typedef bool (*GWebInputFunc)(const guint8 **data, gsize *length,
+ gpointer user_data);
+
+typedef void (*GWebDebugFunc)(const char *str, gpointer user_data);
+
+GWeb *g_web_new(int index);
+
+GWeb *g_web_ref(GWeb *web);
+void g_web_unref(GWeb *web);
+
+void g_web_set_debug(GWeb *web, GWebDebugFunc func, gpointer user_data);
+
+bool g_web_supports_tls(void);
+
+bool g_web_set_proxy(GWeb *web, const char *proxy);
+
+bool g_web_set_address_family(GWeb *web, int family);
+
+bool g_web_add_nameserver(GWeb *web, const char *address);
+
+bool g_web_set_accept(GWeb *web, const char *format, ...)
+ __attribute__((format(printf, 2, 3)));
+bool g_web_set_user_agent(GWeb *web, const char *format, ...)
+ __attribute__((format(printf, 2, 3)));
+bool g_web_set_ua_profile(GWeb *web, const char *profile);
+
+bool g_web_set_http_version(GWeb *web, const char *version);
+
+void g_web_set_close_connection(GWeb *web, bool enabled);
+bool g_web_get_close_connection(GWeb *web);
+
+guint g_web_request_get(GWeb *web, const char *url,
+ GWebResultFunc func, GWebRouteFunc route,
+ gpointer user_data);
+guint g_web_request_post(GWeb *web, const char *url,
+ const char *type, GWebInputFunc input,
+ GWebResultFunc func, gpointer user_data);
+guint g_web_request_post_file(GWeb *web, const char *url,
+ const char *type, const char *file,
+ GWebResultFunc func, gpointer user_data);
+
+bool g_web_cancel_request(GWeb *web, guint id);
+
+guint16 g_web_result_get_status(GWebResult *result);
+
+bool g_web_result_get_header(GWebResult *result,
+ const char *header, const char **value);
+bool g_web_result_get_chunk(GWebResult *result,
+ const guint8 **chunk, gsize *length);
+
+typedef void (*GWebParserFunc)(const char *str, gpointer user_data);
+
+GWebParser *g_web_parser_new(const char *begin, const char *end,
+ GWebParserFunc func, gpointer user_data);
+
+GWebParser *g_web_parser_ref(GWebParser *parser);
+void g_web_parser_unref(GWebParser *parser);
+
+void g_web_parser_feed_data(GWebParser *parser,
+ const guint8 *data, gsize length);
+void g_web_parser_end_data(GWebParser *parser);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __G_WEB_H */
diff --git a/include/agent.h b/include/agent.h
new file mode 100644
index 0000000..6961f7a
--- /dev/null
+++ b/include/agent.h
@@ -0,0 +1,82 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_AGENT_H
+#define __CONNMAN_AGENT_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:agent
+ * @title: agent primitives
+ * @short_description: Functions for handling generic agent details
+ */
+
+struct connman_agent;
+
+struct connman_agent_driver {
+ const char *name;
+ const char *interface;
+ int priority;
+ int (*probe) (struct connman_agent *agent);
+ void (*remove) (struct connman_agent *agent);
+ void * (*context_ref) (void *user_context);
+ void (*context_unref) (void *user_context);
+};
+
+int connman_agent_driver_register(struct connman_agent_driver *driver);
+void connman_agent_driver_unregister(struct connman_agent_driver *driver);
+
+typedef void (* report_error_cb_t) (void *user_context,
+ bool retry, void *user_data);
+
+int connman_agent_report_error_full(void *user_context, const char *path,
+ const char *method, const char *error,
+ report_error_cb_t callback,
+ const char *dbus_sender, void *user_data);
+int connman_agent_report_error(void *user_context, const char *path,
+ const char *error,
+ report_error_cb_t callback,
+ const char *dbus_sender, void *user_data);
+
+int connman_agent_register(const char *sender, const char *path);
+int connman_agent_unregister(const char *sender, const char *path);
+void connman_agent_cancel(void *user_context);
+
+typedef void (*agent_queue_cb)(DBusMessage *reply, void *user_data);
+
+int connman_agent_queue_message(void *user_context,
+ DBusMessage *msg, int timeout,
+ agent_queue_cb callback, void *user_data,
+ void *agent_data);
+
+void *connman_agent_get_info(const char *dbus_sender, const char **sender,
+ const char **path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_TECHNOLOGY_H */
diff --git a/include/dbus.h b/include/dbus.h
new file mode 100644
index 0000000..26f94d6
--- /dev/null
+++ b/include/dbus.h
@@ -0,0 +1,198 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_DBUS_H
+#define __CONNMAN_DBUS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONNMAN_SERVICE "net.connman"
+#define CONNMAN_PATH "/net/connman"
+
+#define CONNMAN_DEBUG_INTERFACE CONNMAN_SERVICE ".Debug"
+#define CONNMAN_ERROR_INTERFACE CONNMAN_SERVICE ".Error"
+#define CONNMAN_AGENT_INTERFACE CONNMAN_SERVICE ".Agent"
+#define CONNMAN_COUNTER_INTERFACE CONNMAN_SERVICE ".Counter"
+
+#define CONNMAN_MANAGER_INTERFACE CONNMAN_SERVICE ".Manager"
+#define CONNMAN_MANAGER_PATH "/"
+
+#define CONNMAN_CLOCK_INTERFACE CONNMAN_SERVICE ".Clock"
+#define CONNMAN_TASK_INTERFACE CONNMAN_SERVICE ".Task"
+#define CONNMAN_SERVICE_INTERFACE CONNMAN_SERVICE ".Service"
+#define CONNMAN_PROVIDER_INTERFACE CONNMAN_SERVICE ".Provider"
+#define CONNMAN_TECHNOLOGY_INTERFACE CONNMAN_SERVICE ".Technology"
+#define CONNMAN_SESSION_INTERFACE CONNMAN_SERVICE ".Session"
+#define CONNMAN_NOTIFICATION_INTERFACE CONNMAN_SERVICE ".Notification"
+#define CONNMAN_PEER_INTERFACE CONNMAN_SERVICE ".Peer"
+
+#define CONNMAN_PRIVILEGE_MODIFY 1
+#define CONNMAN_PRIVILEGE_SECRET 2
+
+typedef void (* connman_dbus_append_cb_t) (DBusMessageIter *iter,
+ void *user_data);
+
+DBusConnection *connman_dbus_get_connection(void);
+
+void connman_dbus_property_append_basic(DBusMessageIter *iter,
+ const char *key, int type, void *val);
+void connman_dbus_property_append_dict(DBusMessageIter *iter, const char *key,
+ connman_dbus_append_cb_t function, void *user_data);
+void connman_dbus_property_append_array(DBusMessageIter *iter,
+ const char *key, int type,
+ connman_dbus_append_cb_t function, void *user_data);
+void connman_dbus_property_append_fixed_array(DBusMessageIter *iter,
+ const char *key, int type, void *val, int len);
+
+dbus_bool_t connman_dbus_property_changed_basic(const char *path,
+ const char *interface, const char *key,
+ int type, void *val);
+dbus_bool_t connman_dbus_property_changed_dict(const char *path,
+ const char *interface, const char *key,
+ connman_dbus_append_cb_t function, void *user_data);
+dbus_bool_t connman_dbus_property_changed_array(const char *path,
+ const char *interface, const char *key, int type,
+ connman_dbus_append_cb_t function, void *user_data);
+
+dbus_bool_t connman_dbus_setting_changed_basic(const char *owner,
+ const char *path, const char *key,
+ int type, void *val);
+dbus_bool_t connman_dbus_setting_changed_dict(const char *owner,
+ const char *path, const char *key,
+ connman_dbus_append_cb_t function,
+ void *user_data);
+dbus_bool_t connman_dbus_setting_changed_array(const char *owner,
+ const char *path, const char *key, int type,
+ connman_dbus_append_cb_t function,
+ void *user_data);
+
+static inline void connman_dbus_dict_open(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, dict);
+}
+
+static inline void connman_dbus_dict_open_variant(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, dict);
+}
+
+static inline void connman_dbus_array_open(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING,
+ dict);
+}
+
+static inline void connman_dbus_dict_close(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_close_container(iter, dict);
+}
+
+static inline void connman_dbus_dict_append_basic(DBusMessageIter *dict,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ connman_dbus_property_append_basic(&entry, key, type, val);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+static inline void connman_dbus_dict_append_dict(DBusMessageIter *dict,
+ const char *key, connman_dbus_append_cb_t function,
+ void *user_data)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ connman_dbus_property_append_dict(&entry, key, function, user_data);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+static inline void connman_dbus_dict_append_array(DBusMessageIter *dict,
+ const char *key, int type, connman_dbus_append_cb_t function,
+ void *user_data)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ connman_dbus_property_append_array(&entry, key,
+ type, function, user_data);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+static inline void connman_dbus_dict_append_fixed_array(DBusMessageIter *dict,
+ const char *key, int type, void *val, int len)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ connman_dbus_property_append_fixed_array(&entry, key, type, val, len);
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+dbus_bool_t connman_dbus_validate_ident(const char *ident);
+char *connman_dbus_encode_string(const char *value);
+
+typedef void (* connman_dbus_get_connection_unix_user_cb_t) (unsigned int uid,
+ void *user_data, int err);
+
+int connman_dbus_get_connection_unix_user(DBusConnection *connection,
+ const char *bus_name,
+ connman_dbus_get_connection_unix_user_cb_t func,
+ void *user_data);
+
+typedef void (* connman_dbus_get_context_cb_t) (const unsigned char *context,
+ void *user_data, int err);
+
+int connman_dbus_get_selinux_context(DBusConnection *connection,
+ const char *service,
+ connman_dbus_get_context_cb_t func,
+ void *user_data);
+
+void connman_dbus_reply_pending(DBusMessage *pending,
+ int error, const char *path);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_DBUS_H */
diff --git a/include/device.h b/include/device.h
new file mode 100644
index 0000000..c6bc47c
--- /dev/null
+++ b/include/device.h
@@ -0,0 +1,143 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_DEVICE_H
+#define __CONNMAN_DEVICE_H
+
+#include <connman/network.h>
+#include <connman/service.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:device
+ * @title: Device premitives
+ * @short_description: Functions for handling devices
+ */
+
+enum connman_device_type {
+ CONNMAN_DEVICE_TYPE_UNKNOWN = 0,
+ CONNMAN_DEVICE_TYPE_ETHERNET = 1,
+ CONNMAN_DEVICE_TYPE_WIFI = 2,
+ CONNMAN_DEVICE_TYPE_BLUETOOTH = 3,
+ CONNMAN_DEVICE_TYPE_CELLULAR = 4,
+ CONNMAN_DEVICE_TYPE_GPS = 5,
+ CONNMAN_DEVICE_TYPE_GADGET = 6,
+ CONNMAN_DEVICE_TYPE_LOWPAN = 7,
+ CONNMAN_DEVICE_TYPE_VENDOR = 10000,
+};
+
+#define CONNMAN_DEVICE_PRIORITY_LOW -100
+#define CONNMAN_DEVICE_PRIORITY_DEFAULT 0
+#define CONNMAN_DEVICE_PRIORITY_HIGH 100
+
+struct connman_device;
+
+struct connman_device *connman_device_create(const char *node,
+ enum connman_device_type type);
+
+#define connman_device_ref(device) \
+ connman_device_ref_debug(device, __FILE__, __LINE__, __func__)
+
+#define connman_device_unref(device) \
+ connman_device_unref_debug(device, __FILE__, __LINE__, __func__)
+
+struct connman_device *
+connman_device_ref_debug(struct connman_device *device,
+ const char *file, int line, const char *caller);
+void connman_device_unref_debug(struct connman_device *device,
+ const char *file, int line, const char *caller);
+
+enum connman_device_type connman_device_get_type(struct connman_device *device);
+void connman_device_set_index(struct connman_device *device, int index);
+int connman_device_get_index(struct connman_device *device);
+void connman_device_set_interface(struct connman_device *device,
+ const char *interface);
+
+void connman_device_set_ident(struct connman_device *device,
+ const char *ident);
+const char *connman_device_get_ident(struct connman_device *device);
+
+int connman_device_set_powered(struct connman_device *device,
+ bool powered);
+bool connman_device_get_powered(struct connman_device *device);
+int connman_device_set_scanning(struct connman_device *device,
+ enum connman_service_type type, bool scanning);
+bool connman_device_get_scanning(struct connman_device *device);
+void connman_device_reset_scanning(struct connman_device *device);
+
+int connman_device_set_disconnected(struct connman_device *device,
+ bool disconnected);
+bool connman_device_get_disconnected(struct connman_device *device);
+
+int connman_device_set_string(struct connman_device *device,
+ const char *key, const char *value);
+const char *connman_device_get_string(struct connman_device *device,
+ const char *key);
+
+int connman_device_add_network(struct connman_device *device,
+ struct connman_network *network);
+struct connman_network *connman_device_get_network(struct connman_device *device,
+ const char *identifier);
+int connman_device_remove_network(struct connman_device *device,
+ struct connman_network *network);
+
+int connman_device_register(struct connman_device *device);
+void connman_device_unregister(struct connman_device *device);
+
+void *connman_device_get_data(struct connman_device *device);
+void connman_device_set_data(struct connman_device *device, void *data);
+
+int connman_device_set_regdom(struct connman_device *device,
+ const char *alpha2);
+void connman_device_regdom_notify(struct connman_device *device,
+ int result, const char *alpha2);
+struct connman_device *connman_device_create_from_index(int index);
+struct connman_device *connman_device_find_by_index(int index);
+int connman_device_reconnect_service(struct connman_device *device);
+
+struct connman_device_driver {
+ const char *name;
+ enum connman_device_type type;
+ int priority;
+ int (*probe) (struct connman_device *device);
+ void (*remove) (struct connman_device *device);
+ int (*enable) (struct connman_device *device);
+ int (*disable) (struct connman_device *device);
+ int (*scan)(enum connman_service_type type,
+ struct connman_device *device,
+ const char *ssid, unsigned int ssid_len,
+ const char *identity, const char* passphrase,
+ const char *security, void *user_data);
+ int (*set_regdom) (struct connman_device *device,
+ const char *alpha2);
+};
+
+int connman_device_driver_register(struct connman_device_driver *driver);
+void connman_device_driver_unregister(struct connman_device_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_DEVICE_H */
diff --git a/include/gdbus.h b/include/gdbus.h
new file mode 100644
index 0000000..eb67dc7
--- /dev/null
+++ b/include/gdbus.h
@@ -0,0 +1,385 @@
+/*
+ *
+ * D-Bus helper library
+ *
+ * Copyright (C) 2004-2011 Marcel Holtmann <marcel@holtmann.org>
+ *
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __GDBUS_H
+#define __GDBUS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <dbus/dbus.h>
+#include <glib.h>
+
+typedef struct GDBusArgInfo GDBusArgInfo;
+typedef struct GDBusMethodTable GDBusMethodTable;
+typedef struct GDBusSignalTable GDBusSignalTable;
+typedef struct GDBusPropertyTable GDBusPropertyTable;
+typedef struct GDBusSecurityTable GDBusSecurityTable;
+
+typedef void (* GDBusWatchFunction) (DBusConnection *connection,
+ void *user_data);
+
+typedef void (* GDBusMessageFunction) (DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+typedef gboolean (* GDBusSignalFunction) (DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+DBusConnection *g_dbus_setup_bus(DBusBusType type, const char *name,
+ DBusError *error);
+
+DBusConnection *g_dbus_setup_private(DBusBusType type, const char *name,
+ DBusError *error);
+
+gboolean g_dbus_request_name(DBusConnection *connection, const char *name,
+ DBusError *error);
+
+gboolean g_dbus_set_disconnect_function(DBusConnection *connection,
+ GDBusWatchFunction function,
+ void *user_data, DBusFreeFunction destroy);
+
+typedef void (* GDBusDestroyFunction) (void *user_data);
+
+typedef DBusMessage * (* GDBusMethodFunction) (DBusConnection *connection,
+ DBusMessage *message, void *user_data);
+
+typedef gboolean (*GDBusPropertyGetter)(const GDBusPropertyTable *property,
+ DBusMessageIter *iter, void *data);
+
+typedef guint32 GDBusPendingPropertySet;
+
+typedef void (*GDBusPropertySetter)(const GDBusPropertyTable *property,
+ DBusMessageIter *value, GDBusPendingPropertySet id,
+ void *data);
+
+typedef gboolean (*GDBusPropertyExists)(const GDBusPropertyTable *property,
+ void *data);
+
+typedef guint32 GDBusPendingReply;
+
+typedef void (* GDBusSecurityFunction) (DBusConnection *connection,
+ const char *action,
+ gboolean interaction,
+ GDBusPendingReply pending);
+
+enum GDBusFlags {
+ G_DBUS_FLAG_ENABLE_EXPERIMENTAL = (1 << 0),
+};
+
+enum GDBusMethodFlags {
+ G_DBUS_METHOD_FLAG_NONE = 0,
+ G_DBUS_METHOD_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_METHOD_FLAG_NOREPLY = (1 << 1),
+ G_DBUS_METHOD_FLAG_ASYNC = (1 << 2),
+ G_DBUS_METHOD_FLAG_EXPERIMENTAL = (1 << 3),
+};
+
+enum GDBusSignalFlags {
+ G_DBUS_SIGNAL_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_SIGNAL_FLAG_EXPERIMENTAL = (1 << 1),
+};
+
+enum GDBusPropertyFlags {
+ G_DBUS_PROPERTY_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_PROPERTY_FLAG_EXPERIMENTAL = (1 << 1),
+};
+
+enum GDBusSecurityFlags {
+ G_DBUS_SECURITY_FLAG_DEPRECATED = (1 << 0),
+ G_DBUS_SECURITY_FLAG_BUILTIN = (1 << 1),
+ G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION = (1 << 2),
+};
+typedef enum GDBusMethodFlags GDBusMethodFlags;
+typedef enum GDBusSignalFlags GDBusSignalFlags;
+typedef enum GDBusPropertyFlags GDBusPropertyFlags;
+typedef enum GDBusSecurityFlags GDBusSecurityFlags;
+
+struct GDBusArgInfo {
+ const char *name;
+ const char *signature;
+};
+
+struct GDBusMethodTable {
+ const char *name;
+ GDBusMethodFunction function;
+ GDBusMethodFlags flags;
+ unsigned int privilege;
+ const GDBusArgInfo *in_args;
+ const GDBusArgInfo *out_args;
+};
+
+struct GDBusSignalTable {
+ const char *name;
+ GDBusSignalFlags flags;
+ const GDBusArgInfo *args;
+};
+
+struct GDBusPropertyTable {
+ const char *name;
+ const char *type;
+ GDBusPropertyGetter get;
+ GDBusPropertySetter set;
+ GDBusPropertyExists exists;
+ GDBusPropertyFlags flags;
+};
+
+struct GDBusSecurityTable {
+ unsigned int privilege;
+ const char *action;
+ GDBusSecurityFlags flags;
+ GDBusSecurityFunction function;
+};
+
+#define GDBUS_ARGS(args...) (const GDBusArgInfo[]) { args, { } }
+
+#define GDBUS_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function
+
+#define GDBUS_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_ASYNC
+
+#define GDBUS_DEPRECATED_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_DEPRECATED
+
+#define GDBUS_DEPRECATED_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_DEPRECATED
+
+#define GDBUS_EXPERIMENTAL_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_EXPERIMENTAL
+
+#define GDBUS_EXPERIMENTAL_ASYNC_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_ASYNC | G_DBUS_METHOD_FLAG_EXPERIMENTAL
+
+#define GDBUS_NOREPLY_METHOD(_name, _in_args, _out_args, _function) \
+ .name = _name, \
+ .in_args = _in_args, \
+ .out_args = _out_args, \
+ .function = _function, \
+ .flags = G_DBUS_METHOD_FLAG_NOREPLY
+
+#define GDBUS_SIGNAL(_name, _args) \
+ .name = _name, \
+ .args = _args
+
+#define GDBUS_DEPRECATED_SIGNAL(_name, _args) \
+ .name = _name, \
+ .args = _args, \
+ .flags = G_DBUS_SIGNAL_FLAG_DEPRECATED
+
+#define GDBUS_EXPERIMENTAL_SIGNAL(_name, _args) \
+ .name = _name, \
+ .args = _args, \
+ .flags = G_DBUS_SIGNAL_FLAG_EXPERIMENTAL
+
+void g_dbus_set_flags(int flags);
+int g_dbus_get_flags(void);
+
+gboolean g_dbus_register_interface(DBusConnection *connection,
+ const char *path, const char *name,
+ const GDBusMethodTable *methods,
+ const GDBusSignalTable *signals,
+ const GDBusPropertyTable *properties,
+ void *user_data,
+ GDBusDestroyFunction destroy);
+gboolean g_dbus_unregister_interface(DBusConnection *connection,
+ const char *path, const char *name);
+
+gboolean g_dbus_register_security(const GDBusSecurityTable *security);
+gboolean g_dbus_unregister_security(const GDBusSecurityTable *security);
+
+void g_dbus_pending_success(DBusConnection *connection,
+ GDBusPendingReply pending);
+void g_dbus_pending_error(DBusConnection *connection,
+ GDBusPendingReply pending,
+ const char *name, const char *format, ...)
+ __attribute__((format(printf, 4, 5)));
+void g_dbus_pending_error_valist(DBusConnection *connection,
+ GDBusPendingReply pending, const char *name,
+ const char *format, va_list args);
+
+DBusMessage *g_dbus_create_error(DBusMessage *message, const char *name,
+ const char *format, ...)
+ __attribute__((format(printf, 3, 4)));
+DBusMessage *g_dbus_create_error_valist(DBusMessage *message, const char *name,
+ const char *format, va_list args);
+DBusMessage *g_dbus_create_reply(DBusMessage *message, int type, ...);
+DBusMessage *g_dbus_create_reply_valist(DBusMessage *message,
+ int type, va_list args);
+
+gboolean g_dbus_send_message(DBusConnection *connection, DBusMessage *message);
+gboolean g_dbus_send_message_with_reply(DBusConnection *connection,
+ DBusMessage *message,
+ DBusPendingCall **call, int timeout);
+gboolean g_dbus_send_error(DBusConnection *connection, DBusMessage *message,
+ const char *name, const char *format, ...)
+ __attribute__((format(printf, 4, 5)));
+gboolean g_dbus_send_error_valist(DBusConnection *connection,
+ DBusMessage *message, const char *name,
+ const char *format, va_list args);
+gboolean g_dbus_send_reply(DBusConnection *connection,
+ DBusMessage *message, int type, ...);
+gboolean g_dbus_send_reply_valist(DBusConnection *connection,
+ DBusMessage *message, int type, va_list args);
+
+gboolean g_dbus_emit_signal(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name, int type, ...);
+gboolean g_dbus_emit_signal_valist(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name, int type, va_list args);
+
+guint g_dbus_add_service_watch(DBusConnection *connection, const char *name,
+ GDBusWatchFunction connect,
+ GDBusWatchFunction disconnect,
+ void *user_data, GDBusDestroyFunction destroy);
+guint g_dbus_add_disconnect_watch(DBusConnection *connection, const char *name,
+ GDBusWatchFunction function,
+ void *user_data, GDBusDestroyFunction destroy);
+guint g_dbus_add_signal_watch(DBusConnection *connection,
+ const char *sender, const char *path,
+ const char *interface, const char *member,
+ GDBusSignalFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+guint g_dbus_add_properties_watch(DBusConnection *connection,
+ const char *sender, const char *path,
+ const char *interface,
+ GDBusSignalFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+gboolean g_dbus_remove_watch(DBusConnection *connection, guint tag);
+void g_dbus_remove_all_watches(DBusConnection *connection);
+
+void g_dbus_pending_property_success(GDBusPendingPropertySet id);
+void g_dbus_pending_property_error_valist(GDBusPendingReply id,
+ const char *name, const char *format, va_list args);
+void g_dbus_pending_property_error(GDBusPendingReply id, const char *name,
+ const char *format, ...);
+void g_dbus_emit_property_changed(DBusConnection *connection,
+ const char *path, const char *interface,
+ const char *name);
+gboolean g_dbus_get_properties(DBusConnection *connection, const char *path,
+ const char *interface, DBusMessageIter *iter);
+
+gboolean g_dbus_attach_object_manager(DBusConnection *connection);
+gboolean g_dbus_detach_object_manager(DBusConnection *connection);
+
+typedef struct GDBusClient GDBusClient;
+typedef struct GDBusProxy GDBusProxy;
+
+GDBusProxy *g_dbus_proxy_new(GDBusClient *client, const char *path,
+ const char *interface);
+
+GDBusProxy *g_dbus_proxy_ref(GDBusProxy *proxy);
+void g_dbus_proxy_unref(GDBusProxy *proxy);
+
+const char *g_dbus_proxy_get_path(GDBusProxy *proxy);
+const char *g_dbus_proxy_get_interface(GDBusProxy *proxy);
+
+gboolean g_dbus_proxy_get_property(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter);
+
+gboolean g_dbus_proxy_refresh_property(GDBusProxy *proxy, const char *name);
+
+typedef void (* GDBusResultFunction) (const DBusError *error, void *user_data);
+
+gboolean g_dbus_proxy_set_property_basic(GDBusProxy *proxy,
+ const char *name, int type, const void *value,
+ GDBusResultFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+
+gboolean g_dbus_proxy_set_property_array(GDBusProxy *proxy,
+ const char *name, int type, const void *value,
+ size_t size, GDBusResultFunction function,
+ void *user_data, GDBusDestroyFunction destroy);
+
+typedef void (* GDBusSetupFunction) (DBusMessageIter *iter, void *user_data);
+typedef void (* GDBusReturnFunction) (DBusMessage *message, void *user_data);
+
+gboolean g_dbus_proxy_method_call(GDBusProxy *proxy, const char *method,
+ GDBusSetupFunction setup,
+ GDBusReturnFunction function, void *user_data,
+ GDBusDestroyFunction destroy);
+
+typedef void (* GDBusClientFunction) (GDBusClient *client, void *user_data);
+typedef void (* GDBusProxyFunction) (GDBusProxy *proxy, void *user_data);
+typedef void (* GDBusPropertyFunction) (GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data);
+
+gboolean g_dbus_proxy_set_property_watch(GDBusProxy *proxy,
+ GDBusPropertyFunction function, void *user_data);
+
+gboolean g_dbus_proxy_set_removed_watch(GDBusProxy *proxy,
+ GDBusProxyFunction destroy, void *user_data);
+
+GDBusClient *g_dbus_client_new(DBusConnection *connection,
+ const char *service, const char *path);
+GDBusClient *g_dbus_client_new_full(DBusConnection *connection,
+ const char *service,
+ const char *path,
+ const char *root_path);
+
+GDBusClient *g_dbus_client_ref(GDBusClient *client);
+void g_dbus_client_unref(GDBusClient *client);
+
+gboolean g_dbus_client_set_connect_watch(GDBusClient *client,
+ GDBusWatchFunction function, void *user_data);
+gboolean g_dbus_client_set_disconnect_watch(GDBusClient *client,
+ GDBusWatchFunction function, void *user_data);
+gboolean g_dbus_client_set_signal_watch(GDBusClient *client,
+ GDBusMessageFunction function, void *user_data);
+gboolean g_dbus_client_set_ready_watch(GDBusClient *client,
+ GDBusClientFunction ready, void *user_data);
+gboolean g_dbus_client_set_proxy_handlers(GDBusClient *client,
+ GDBusProxyFunction proxy_added,
+ GDBusProxyFunction proxy_removed,
+ GDBusPropertyFunction property_changed,
+ void *user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __GDBUS_H */
diff --git a/include/inet.h b/include/inet.h
new file mode 100644
index 0000000..bb0f1dc
--- /dev/null
+++ b/include/inet.h
@@ -0,0 +1,84 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_INET_H
+#define __CONNMAN_INET_H
+
+#include <arpa/inet.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+#include <connman/device.h>
+#include <connman/ipconfig.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int connman_inet_ifindex(const char *name);
+char *connman_inet_ifname(int index);
+
+int connman_inet_ifup(int index);
+int connman_inet_ifdown(int index);
+
+int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress);
+int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress);
+int connman_inet_add_host_route(int index, const char *host, const char *gateway);
+int connman_inet_del_host_route(int index, const char *host);
+int connman_inet_add_network_route(int index, const char *host, const char *gateway,
+ const char *netmask);
+int connman_inet_del_network_route(int index, const char *host);
+int connman_inet_clear_gateway_address(int index, const char *gateway);
+int connman_inet_set_gateway_interface(int index);
+int connman_inet_clear_gateway_interface(int index);
+bool connman_inet_compare_subnet(int index, const char *host);
+int connman_inet_set_ipv6_address(int index,
+ struct connman_ipaddress *ipaddress);
+int connman_inet_clear_ipv6_address(int index,
+ const char *address, int prefix_len);
+int connman_inet_add_ipv6_network_route(int index, const char *host,
+ const char *gateway, unsigned char prefix_len);
+int connman_inet_add_ipv6_host_route(int index, const char *host,
+ const char *gateway);
+int connman_inet_del_ipv6_network_route(int index, const char *host,
+ unsigned char prefix_len);
+int connman_inet_del_ipv6_host_route(int index, const char *host);
+int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway);
+int connman_inet_set_ipv6_gateway_interface(int index);
+int connman_inet_clear_ipv6_gateway_interface(int index);
+
+int connman_inet_add_to_bridge(int index, const char *bridge);
+int connman_inet_remove_from_bridge(int index, const char *bridge);
+
+int connman_inet_set_mtu(int index, int mtu);
+int connman_inet_setup_tunnel(char *tunnel, int mtu);
+int connman_inet_create_tunnel(char **iface);
+int connman_inet_get_dest_addr(int index, char **dest);
+int connman_inet_ipv6_get_dest_addr(int index, char **dest);
+int connman_inet_check_ipaddress(const char *host);
+bool connman_inet_check_hostname(const char *ptr, size_t len);
+bool connman_inet_is_ipv6_supported(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_INET_H */
diff --git a/include/inotify.h b/include/inotify.h
new file mode 100644
index 0000000..4bc6330
--- /dev/null
+++ b/include/inotify.h
@@ -0,0 +1,37 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012,2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_INOTIFY_H
+#define __CONNMAN_INOTIFY_H
+
+struct inotify_event;
+
+typedef void (* inotify_event_cb) (struct inotify_event *event,
+ const char *ident);
+
+int connman_inotify_register(const char *path, inotify_event_cb callback);
+void connman_inotify_unregister(const char *path, inotify_event_cb callback);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_INOTIFY_H */
diff --git a/include/ipaddress.h b/include/ipaddress.h
new file mode 100644
index 0000000..3655ca8
--- /dev/null
+++ b/include/ipaddress.h
@@ -0,0 +1,60 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_IPADDRESS_H
+#define __CONNMAN_IPADDRESS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:ipaddress
+ * @title: IP address premitives
+ * @short_description: Functions for IP address handling
+ */
+
+struct connman_ipaddress;
+
+unsigned char connman_ipaddress_calc_netmask_len(const char *netmask);
+struct connman_ipaddress *connman_ipaddress_alloc(int family);
+void connman_ipaddress_free(struct connman_ipaddress *ipaddress);
+int connman_ipaddress_set_ipv4(struct connman_ipaddress *ipaddress,
+ const char *address, const char *netmask,
+ const char *gateway);
+int connman_ipaddress_set_ipv6(struct connman_ipaddress *ipaddress,
+ const char *address,
+ unsigned char prefix_length,
+ const char *gateway);
+int connman_ipaddress_get_ip(struct connman_ipaddress *ipaddress,
+ const char **address, unsigned char *prefix_length);
+void connman_ipaddress_set_peer(struct connman_ipaddress *ipaddress,
+ const char *peer);
+void connman_ipaddress_clear(struct connman_ipaddress *ipaddress);
+void connman_ipaddress_copy_address(struct connman_ipaddress *ipaddress,
+ struct connman_ipaddress *source);
+struct connman_ipaddress *connman_ipaddress_copy(struct connman_ipaddress *ipaddress);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_IPADDRESS_H */
diff --git a/include/ipconfig.h b/include/ipconfig.h
new file mode 100644
index 0000000..e26dd1a
--- /dev/null
+++ b/include/ipconfig.h
@@ -0,0 +1,63 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_IPCONFIG_H
+#define __CONNMAN_IPCONFIG_H
+
+#include <connman/ipaddress.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:ipconfig
+ * @title: IP configuration premitives
+ * @short_description: Functions for IP configuration handling
+ */
+
+enum connman_ipconfig_type {
+ CONNMAN_IPCONFIG_TYPE_UNKNOWN = 0,
+ CONNMAN_IPCONFIG_TYPE_IPV4 = 1,
+ CONNMAN_IPCONFIG_TYPE_IPV6 = 2,
+ CONNMAN_IPCONFIG_TYPE_ALL = 3,
+};
+
+enum connman_ipconfig_method {
+ CONNMAN_IPCONFIG_METHOD_UNKNOWN = 0,
+ CONNMAN_IPCONFIG_METHOD_OFF = 1,
+ CONNMAN_IPCONFIG_METHOD_FIXED = 2,
+ CONNMAN_IPCONFIG_METHOD_MANUAL = 3,
+ CONNMAN_IPCONFIG_METHOD_DHCP = 4,
+ CONNMAN_IPCONFIG_METHOD_AUTO = 5,
+};
+
+struct connman_ipconfig;
+struct connman_ipdevice;
+
+struct connman_ipdevice *connman_ipdevice_lookup_from_index(int index);
+void connman_ipdevice_set_address(struct connman_ipdevice *ipdevice, const char* address);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_IPCONFIG_H */
diff --git a/include/log.h b/include/log.h
new file mode 100644
index 0000000..d41d037
--- /dev/null
+++ b/include/log.h
@@ -0,0 +1,371 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_LOG_H
+#define __CONNMAN_LOG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:log
+ * @title: Logging premitives
+ * @short_description: Functions for logging error and debug information
+ */
+
+void connman_info(const char *format, ...)
+ __attribute__((format(printf, 1, 2)));
+void connman_warn(const char *format, ...)
+ __attribute__((format(printf, 1, 2)));
+void connman_error(const char *format, ...)
+ __attribute__((format(printf, 1, 2)));
+void connman_debug(const char *format, ...)
+ __attribute__((format(printf, 1, 2)));
+
+#define connman_warn_once(fmt, arg...) do { \
+ static bool printed; \
+ if (!printed) { \
+ connman_warn(fmt, ## arg); \
+ printed = true; \
+ } \
+} while (0)
+
+struct connman_debug_desc {
+ const char *name;
+ const char *file;
+#define CONNMAN_DEBUG_FLAG_DEFAULT (0)
+#define CONNMAN_DEBUG_FLAG_PRINT (1 << 0)
+#define CONNMAN_DEBUG_FLAG_ALIAS (1 << 1)
+ unsigned int flags;
+} __attribute__((aligned(8)));
+
+#define CONNMAN_DEBUG_DEFINE(name) \
+ static struct connman_debug_desc __debug_alias_ ## name \
+ __attribute__((used, section("__debug"), aligned(8))) = { \
+ #name, __FILE__, CONNMAN_DEBUG_FLAG_ALIAS \
+ };
+
+/**
+ * DBG:
+ * @fmt: format string
+ * @arg...: list of arguments
+ *
+ * Simple macro around connman_debug() which also include the function
+ * name it is called in.
+ */
+#define DBG(fmt, arg...) do { \
+ static struct connman_debug_desc __connman_debug_desc \
+ __attribute__((used, section("__debug"), aligned(8))) = { \
+ .file = __FILE__, .flags = CONNMAN_DEBUG_FLAG_DEFAULT, \
+ }; \
+ if (__connman_debug_desc.flags & CONNMAN_DEBUG_FLAG_PRINT) \
+ connman_debug("%s:%s() " fmt, \
+ __FILE__, __FUNCTION__ , ## arg); \
+} while (0)
+
+#if !defined(CONNMAN_DEBUG)
+#define CONNMAN_DEBUG DEBUG && !NDEBUG
+#endif
+
+#if CONNMAN_DEBUG
+extern unsigned int trace_depth;
+extern char trace_tabbuf[];
+
+extern void connman_create_indent(unsigned int depth, char *buffer);
+
+#define connman_trace(dir, fmt, arg...) \
+ do { \
+ connman_create_indent(trace_depth, trace_tabbuf); \
+ connman_debug("%s" dir " (%d) %s: " fmt, \
+ trace_tabbuf, \
+ trace_depth, \
+ __FUNCTION__, \
+ ## arg); \
+ } while (0)
+
+#define connman_trace_in(fmt, arg...) \
+ do { \
+ connman_trace("-->", fmt, ## arg); \
+ trace_depth++; \
+ } while (0)
+
+#define connman_trace_out(fmt, arg...) \
+ do { \
+ --trace_depth; \
+ connman_trace("<--", fmt, ## arg); \
+ } while (0)
+#else
+#define connman_trace_in(fmt, arg...)
+#define connman_trace_out(fmt, arg...)
+#endif
+
+extern void connman_assert_handler(const char *name, const char *predicate, const char *message, const char *file, unsigned int line, void *value, int terminate);
+
+#if !defined(CONNMAN_ASSERT)
+#define CONNMAN_ASSERT(name, predicate, message, file, line, value) connman_assert_handler(name, predicate, message, file, line, value, 0)
+#endif
+
+#if !defined(CONNMAN_ASSERT_MODULE)
+#define CONNMAN_ASSERT_MODULE NULL
+#endif
+
+#if CONNMAN_DEBUG
+#define connman_assert(predicate) \
+ do { \
+ if (!(predicate)) { \
+ connman_assert_handler(CONNMAN_ASSERT_MODULE, \
+ #predicate, \
+ NULL, \
+ __FILE__, \
+ __LINE__, \
+ 0, \
+ 1); \
+ } \
+ } while (0)
+#else
+#define connman_assert(predicate)
+#endif
+
+#if CONNMAN_DEBUG
+#define connman_check_message(predicate, message) \
+ do { \
+ if (!(predicate)) { \
+ CONNMAN_ASSERT(CONNMAN_ASSERT_MODULE, \
+ #predicate, \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ 0); \
+ } \
+ } while (0)
+#else
+#define connman_check_message(predicate, message)
+#endif
+
+#if CONNMAN_DEBUG
+#define connman_check(predicate) \
+ connman_check_message(predicate, NULL)
+#else
+#define connman_check(predicate)
+#endif
+
+#if CONNMAN_DEBUG
+#define connman_check_ok_message(error, message) \
+ do { \
+ if ((error) != 0) { \
+ CONNMAN_ASSERT(CONNMAN_ASSERT_MODULE, \
+ #error " == 0", \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ (void *)error); \
+ } \
+ } while (0)
+#else
+#define connman_check_ok_message(error, message)
+#endif
+
+#if CONNMAN_DEBUG
+#define connman_check_ok(error) \
+ connman_check_ok_message(error, NULL)
+#else
+#define connman_check_ok(error)
+#endif
+
+#if CONNMAN_DEBUG
+#define connman_verify_message(predicate, message) \
+ connman_check_message(predicate, message)
+#else
+#define connman_verify_message(predicate, message) \
+ do { \
+ if (!predicate) { } \
+ } while (0)
+#endif
+
+#define connman_verify(predicate) \
+ connman_verify_message(predicate, NULL)
+
+#if CONNMAN_DEBUG
+#define connman_verify_execute_message(predicate, action, message) \
+ do { \
+ if (!(predicate)) { \
+ CONNMAN_ASSERT(CONNMAN_ASSERT_MODULE, \
+ #predicate, \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ 0); \
+ { \
+ action; \
+ } \
+ } \
+ } while (0)
+#else
+#define connman_verify_execute_message(predicate, action, message) \
+ do { \
+ if (!(predicate)) { \
+ { \
+ action; \
+ } \
+ } \
+ } while (0)
+#endif
+
+#define connman_verify_execute(predicate, action) \
+ connman_verify_execute_message(predicate, action, NULL)
+
+#if CONNMAN_DEBUG
+#define connman_verify_ok_message(error, message) \
+ connman_check_ok_message(error, message)
+#else
+#define connman_verify_ok_message(error, message) \
+ connman_verify_message(error == 0, message)
+#endif
+
+#define connman_verify_ok(error) \
+ connman_verify_ok_message(error, NULL)
+
+#define connman_require_quiet(predicate, label) \
+ do { \
+ if (!(predicate)) { \
+ goto label; \
+ } \
+ } while (0)
+
+#if CONNMAN_DEBUG
+#define connman_require_message(predicate, label, message) \
+ do { \
+ if (!(predicate)) { \
+ CONNMAN_ASSERT(CONNMAN_ASSERT_MODULE, \
+ #predicate, \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ 0); \
+ goto label; \
+ } \
+ } while (0)
+#else
+#define connman_require_message(predicate, label, message) \
+ connman_require(predicate, label)
+#endif
+
+#define connman_require(predicate, label) \
+ connman_require_message(predicate, label, NULL)
+
+#define connman_require_execute_quiet(predicate, label, action) \
+ do { \
+ if (!(predicate)) { \
+ { \
+ action; \
+ } \
+ goto label; \
+ } \
+ } while (0)
+
+#if CONNMAN_DEBUG
+#define connman_require_execute_message(predicate, label, action, message) \
+ do { \
+ if (!(predicate)) { \
+ CONNMAN_ASSERT( \
+ CONNMAN_ASSERT_MODULE, \
+ #predicate, \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ 0); \
+ { \
+ action; \
+ } \
+ goto label; \
+ } \
+ } while (0)
+#else
+#define connman_require_execute_message(predicate, label, action, message) \
+ connman_require_execute_message_quiet(predicate, label, action, message)
+#endif
+
+#define connman_require_execute(predicate, label, action) \
+ connman_require_execute_message(predicate, label, action, NULL)
+
+#define connman_require_ok_quiet(error, label) \
+ connnman_require_quiet(error == 0, label)
+
+#if CONNMAN_DEBUG
+#define connman_require_ok_message(error, label, message) \
+ do { \
+ if ((error) != 0) { \
+ CONNMAN_ASSERT(CONNMAN_ASSERT_MODULE, \
+ #error " == 0 ", \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ error); \
+ goto label; \
+ } \
+ } while (0)
+#else
+#define connman_require_ok_message(error, label, message) \
+ connman_require_ok_quiet(error, label)
+#endif
+
+#define connman_require_ok(error, label) \
+ connman_require_ok_message(error, label, NULL)
+
+#define connman_require_ok_execute_quiet(error, label, action) \
+ do { \
+ if ((error) != 0) { \
+ { \
+ action; \
+ } \
+ goto label; \
+ } \
+ } while (0)
+#if CONNMAN_DEBUG
+#define connman_require_ok_execute_message(error, label, action, message) \
+ do { \
+ if ((error) != 0) { \
+ CONNMAN_ASSERT(CONNMAN_ASSERT_MODULE, \
+ #error " == 0 ", \
+ message, \
+ __FILE__, \
+ __LINE__, \
+ error); \
+ { \
+ action; \
+ } \
+ goto label; \
+ } \
+ } while (0)
+#else
+#define connman_require_ok_execute_message(error, label, action, message) \
+ connman_require_ok_execute_quiet(error, label, action)
+#endif
+
+#define connman_require_ok_execute(error, label, action) \
+ connman_require_ok_execute_message(error, label, action, NULL)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_LOG_H */
diff --git a/include/machine.h b/include/machine.h
new file mode 100644
index 0000000..c8d8735
--- /dev/null
+++ b/include/machine.h
@@ -0,0 +1,35 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_MACHINE_H
+#define __CONNMAN_MACHINE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char *connman_machine_get_type(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_MACHINE_H */
diff --git a/include/network.h b/include/network.h
new file mode 100644
index 0000000..f9227fd
--- /dev/null
+++ b/include/network.h
@@ -0,0 +1,179 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_NETWORK_H
+#define __CONNMAN_NETWORK_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#include <connman/device.h>
+#include <connman/ipconfig.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:network
+ * @title: Network premitives
+ * @short_description: Functions for handling networks
+ */
+
+enum connman_network_type {
+ CONNMAN_NETWORK_TYPE_UNKNOWN = 0,
+ CONNMAN_NETWORK_TYPE_ETHERNET = 1,
+ CONNMAN_NETWORK_TYPE_WIFI = 2,
+ CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN = 8,
+ CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN = 9,
+ CONNMAN_NETWORK_TYPE_CELLULAR = 10,
+ CONNMAN_NETWORK_TYPE_GADGET = 11,
+ CONNMAN_NETWORK_TYPE_LOWPAN = 12,
+ CONNMAN_NETWORK_TYPE_VENDOR = 10000,
+};
+
+enum connman_network_error {
+ CONNMAN_NETWORK_ERROR_UNKNOWN = 0,
+ CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL = 1,
+ CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL = 2,
+ CONNMAN_NETWORK_ERROR_INVALID_KEY = 3,
+ CONNMAN_NETWORK_ERROR_CONNECT_FAIL = 4,
+};
+
+#define CONNMAN_NETWORK_PRIORITY_LOW -100
+#define CONNMAN_NETWORK_PRIORITY_DEFAULT 0
+#define CONNMAN_NETWORK_PRIORITY_HIGH 100
+
+struct connman_network;
+
+struct connman_network *connman_network_create(const char *identifier,
+ enum connman_network_type type);
+
+#define connman_network_ref(network) \
+ connman_network_ref_debug(network, __func__, __LINE__, __func__)
+
+#define connman_network_unref(network) \
+ connman_network_unref_debug(network, __func__, __LINE__, __func__)
+
+struct connman_network *
+connman_network_ref_debug(struct connman_network *network,
+ const char *file, int line, const char *caller);
+void connman_network_unref_debug(struct connman_network *network,
+ const char *file, int line, const char *caller);
+
+enum connman_network_type connman_network_get_type(struct connman_network *network);
+const char *connman_network_get_identifier(struct connman_network *network);
+
+void connman_network_set_index(struct connman_network *network, int index);
+int connman_network_get_index(struct connman_network *network);
+
+void connman_network_set_group(struct connman_network *network,
+ const char *group);
+const char *connman_network_get_group(struct connman_network *network);
+
+bool connman_network_get_connecting(struct connman_network *network);
+int connman_network_set_available(struct connman_network *network,
+ bool available);
+bool connman_network_get_available(struct connman_network *network);
+int connman_network_set_associating(struct connman_network *network,
+ bool associating);
+void connman_network_set_error(struct connman_network *network,
+ enum connman_network_error error);
+int connman_network_set_connected(struct connman_network *network,
+ bool connected);
+bool connman_network_get_connected(struct connman_network *network);
+
+bool connman_network_get_associating(struct connman_network *network);
+
+bool connman_network_get_connectable(struct connman_network *network);
+
+int connman_network_set_connectable(struct connman_network *network, bool connectable);
+
+int connman_network_needs_input(struct connman_network *network);
+
+void connman_network_clear_hidden(void *user_data);
+int connman_network_connect_hidden(struct connman_network *network,
+ char *identity, char* passphrase, void *user_data);
+
+void connman_network_set_ipv4_method(struct connman_network *network,
+ enum connman_ipconfig_method method);
+void connman_network_set_ipv6_method(struct connman_network *network,
+ enum connman_ipconfig_method method);
+int connman_network_set_ipaddress(struct connman_network *network,
+ struct connman_ipaddress *ipaddress);
+int connman_network_set_nameservers(struct connman_network *network,
+ const char *nameservers);
+int connman_network_set_domain(struct connman_network *network,
+ const char *domain);
+int connman_network_set_name(struct connman_network *network,
+ const char *name);
+int connman_network_set_strength(struct connman_network *network,
+ uint8_t strength);
+uint8_t connman_network_get_strength(struct connman_network *network);
+int connman_network_set_frequency(struct connman_network *network,
+ uint16_t frequency);
+uint16_t connman_network_get_frequency(struct connman_network *network);
+int connman_network_set_wifi_channel(struct connman_network *network,
+ uint16_t channel);
+uint16_t connman_network_get_wifi_channel(struct connman_network *network);
+
+int connman_network_set_lowpan_xpan_id(struct connman_network *network,
+ uint64_t xpan_id);
+uint64_t connman_network_get_lowpan_xpan_id(struct connman_network *network);
+
+int connman_network_set_string(struct connman_network *network,
+ const char *key, const char *value);
+const char *connman_network_get_string(struct connman_network *network,
+ const char *key);
+int connman_network_set_bool(struct connman_network *network,
+ const char *key, bool value);
+bool connman_network_get_bool(struct connman_network *network,
+ const char *key);
+int connman_network_set_blob(struct connman_network *network,
+ const char *key, const void *data, unsigned int size);
+const void *connman_network_get_blob(struct connman_network *network,
+ const char *key, unsigned int *size);
+
+struct connman_device *connman_network_get_device(struct connman_network *network);
+
+void *connman_network_get_data(struct connman_network *network);
+void connman_network_set_data(struct connman_network *network, void *data);
+
+void connman_network_update(struct connman_network *network);
+
+struct connman_network_driver {
+ const char *name;
+ enum connman_network_type type;
+ int priority;
+ int (*probe) (struct connman_network *network);
+ void (*remove) (struct connman_network *network);
+ int (*connect) (struct connman_network *network);
+ int (*disconnect) (struct connman_network *network, bool user_initiated);
+};
+
+int connman_network_driver_register(struct connman_network_driver *driver);
+void connman_network_driver_unregister(struct connman_network_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_NETWORK_H */
diff --git a/include/notifier.h b/include/notifier.h
new file mode 100644
index 0000000..c4b0383
--- /dev/null
+++ b/include/notifier.h
@@ -0,0 +1,68 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_NOTIFIER_H
+#define __CONNMAN_NOTIFIER_H
+
+#include <connman/service.h>
+#include <connman/ipconfig.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:notifier
+ * @title: Notifier premitives
+ * @short_description: Functions for registering notifier modules
+ */
+
+#define CONNMAN_NOTIFIER_PRIORITY_LOW -100
+#define CONNMAN_NOTIFIER_PRIORITY_DEFAULT 0
+#define CONNMAN_NOTIFIER_PRIORITY_HIGH 100
+
+struct connman_notifier {
+ const char *name;
+ int priority;
+ void (*default_changed) (struct connman_service *service);
+ void (*service_add) (struct connman_service *service,
+ const char *name);
+ void (*service_remove) (struct connman_service *service);
+ void (*service_enabled) (enum connman_service_type type,
+ bool enabled);
+ void (*offline_mode) (bool enabled);
+ void (*proxy_changed) (struct connman_service *service);
+ void (*service_state_changed) (struct connman_service *service,
+ enum connman_service_state state);
+ void (*ipconfig_changed) (struct connman_service *service,
+ struct connman_ipconfig *ipconfig);
+ void (*sleep_event) (void * identifier, int cansleep, time_t valid_until);
+ void (*idle_state) (bool idle);
+};
+
+int connman_notifier_register(struct connman_notifier *notifier);
+void connman_notifier_unregister(struct connman_notifier *notifier);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_NOTIFIER_H */
diff --git a/include/option.h b/include/option.h
new file mode 100644
index 0000000..5e97ed4
--- /dev/null
+++ b/include/option.h
@@ -0,0 +1,35 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_OPTION_H
+#define __CONNMAN_OPTION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+const char *connman_option_get_string(const char *key);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_OPTION_H */
diff --git a/include/peer.h b/include/peer.h
new file mode 100644
index 0000000..8066393
--- /dev/null
+++ b/include/peer.h
@@ -0,0 +1,118 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_PEER_H
+#define __CONNMAN_PEER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum connman_peer_state {
+ CONNMAN_PEER_STATE_UNKNOWN = 0,
+ CONNMAN_PEER_STATE_IDLE = 1,
+ CONNMAN_PEER_STATE_ASSOCIATION = 2,
+ CONNMAN_PEER_STATE_CONFIGURATION = 3,
+ CONNMAN_PEER_STATE_READY = 4,
+ CONNMAN_PEER_STATE_DISCONNECT = 5,
+ CONNMAN_PEER_STATE_FAILURE = 6,
+};
+
+enum connman_peer_wps_method {
+ CONNMAN_PEER_WPS_UNKNOWN = 0,
+ CONNMAN_PEER_WPS_PBC = 1,
+ CONNMAN_PEER_WPS_PIN = 2,
+};
+
+enum connman_peer_service_type {
+ CONNMAN_PEER_SERVICE_UNKNOWN = 0,
+ CONNMAN_PEER_SERVICE_WIFI_DISPLAY = 1,
+};
+
+struct connman_peer;
+
+struct connman_peer *connman_peer_create(const char *identifier);
+
+#define connman_peer_ref(peer) \
+ connman_peer_ref_debug(peer, __FILE__, __LINE__, __func__)
+
+#define connman_peer_unref(peer) \
+ connman_peer_unref_debug(peer, __FILE__, __LINE__, __func__)
+
+struct connman_peer *connman_peer_ref_debug(struct connman_peer *peer,
+ const char *file, int line, const char *caller);
+void connman_peer_unref_debug(struct connman_peer *peer,
+ const char *file, int line, const char *caller);
+
+const char *connman_peer_get_identifier(struct connman_peer *peer);
+void connman_peer_set_name(struct connman_peer *peer, const char *name);
+void connman_peer_set_iface_address(struct connman_peer *peer,
+ const unsigned char *iface_address);
+void connman_peer_set_device(struct connman_peer *peer,
+ struct connman_device *device);
+struct connman_device *connman_peer_get_device(struct connman_peer *peer);
+void connman_peer_set_sub_device(struct connman_peer *peer,
+ struct connman_device *device);
+void connman_peer_set_as_master(struct connman_peer *peer, bool master);
+int connman_peer_set_state(struct connman_peer *peer,
+ enum connman_peer_state new_state);
+int connman_peer_request_connection(struct connman_peer *peer);
+void connman_peer_reset_services(struct connman_peer *peer);
+void connman_peer_add_service(struct connman_peer *peer,
+ enum connman_peer_service_type type,
+ const unsigned char *data, int data_length);
+void connman_peer_services_changed(struct connman_peer *peer);
+
+int connman_peer_register(struct connman_peer *peer);
+void connman_peer_unregister(struct connman_peer *peer);
+
+struct connman_peer *connman_peer_get(struct connman_device *device,
+ const char *identifier);
+
+typedef void (* peer_service_registration_cb_t) (int result, void *user_data);
+
+struct connman_peer_driver {
+ int (*connect) (struct connman_peer *peer,
+ enum connman_peer_wps_method wps_method,
+ const char *wps_pin);
+ int (*disconnect) (struct connman_peer *peer);
+ int (*register_service) (const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version,
+ peer_service_registration_cb_t callback,
+ void *user_data);
+ int (*unregister_service) (const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version);
+};
+
+int connman_peer_driver_register(struct connman_peer_driver *driver);
+void connman_peer_driver_unregister(struct connman_peer_driver *driver);
+
+bool connman_peer_service_is_master(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_PEER_H */
diff --git a/include/plugin.h b/include/plugin.h
new file mode 100644
index 0000000..8d2bb08
--- /dev/null
+++ b/include/plugin.h
@@ -0,0 +1,107 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_PLUGIN_H
+#define __CONNMAN_PLUGIN_H
+
+#include <connman/version.h>
+#include <connman/log.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef CONNMAN_API_SUBJECT_TO_CHANGE
+#error "Please define CONNMAN_API_SUBJECT_TO_CHANGE to acknowledge your \
+understanding that ConnMan hasn't reached a stable API."
+#endif
+
+#define CONNMAN_PLUGIN_PRIORITY_LOW -100
+#define CONNMAN_PLUGIN_PRIORITY_DEFAULT 0
+#define CONNMAN_PLUGIN_PRIORITY_HIGH 100
+
+/**
+ * SECTION:plugin
+ * @title: Plugin premitives
+ * @short_description: Functions for declaring plugins
+ */
+
+struct connman_plugin_desc {
+ const char *name;
+ const char *description;
+ const char *version;
+ int priority;
+ int (*init) (void);
+ void (*exit) (void);
+ void *debug_start;
+ void *debug_stop;
+};
+
+/**
+ * CONNMAN_PLUGIN_DEFINE:
+ * @name: plugin name
+ * @description: plugin description
+ * @version: plugin version string
+ * @init: init function called on plugin loading
+ * @exit: exit function called on plugin removal
+ *
+ * Macro for defining a plugin descriptor
+ *
+ * |[
+ * #include <connman/plugin.h>
+ *
+ * static int example_init(void)
+ * {
+ * return 0;
+ * }
+ *
+ * static void example_exit(void)
+ * {
+ * }
+ *
+ * CONNMAN_PLUGIN_DEFINE(example, "Example plugin", CONNMAN_VERSION,
+ * example_init, example_exit)
+ * ]|
+ */
+#ifdef CONNMAN_PLUGIN_BUILTIN
+#define CONNMAN_PLUGIN_DEFINE(name, description, version, priority, init, exit) \
+ struct connman_plugin_desc __connman_builtin_ ## name = { \
+ #name, description, version, priority, init, exit \
+ };
+#else
+#define CONNMAN_PLUGIN_DEFINE(name, description, version, priority, init, exit) \
+ extern struct connman_debug_desc __start___debug[] \
+ __attribute__ ((weak, visibility("hidden"))); \
+ extern struct connman_debug_desc __stop___debug[] \
+ __attribute__ ((weak, visibility("hidden"))); \
+ extern struct connman_plugin_desc connman_plugin_desc \
+ __attribute__ ((visibility("default"))); \
+ struct connman_plugin_desc connman_plugin_desc = { \
+ #name, description, version, priority, init, exit, \
+ __start___debug, __stop___debug \
+ };
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_PLUGIN_H */
diff --git a/include/provider.h b/include/provider.h
new file mode 100644
index 0000000..d1a8983
--- /dev/null
+++ b/include/provider.h
@@ -0,0 +1,149 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_PROVIDER_H
+#define __CONNMAN_PROVIDER_H
+
+#include <stdbool.h>
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:provider
+ * @title: Provider premitives
+ * @short_description: Functions for handling providers
+ */
+
+enum connman_provider_type {
+ CONNMAN_PROVIDER_TYPE_UNKNOWN = 0,
+ CONNMAN_PROVIDER_TYPE_VPN = 1,
+};
+
+enum connman_provider_state {
+ CONNMAN_PROVIDER_STATE_UNKNOWN = 0,
+ CONNMAN_PROVIDER_STATE_IDLE = 1,
+ CONNMAN_PROVIDER_STATE_CONNECT = 2,
+ CONNMAN_PROVIDER_STATE_READY = 3,
+ CONNMAN_PROVIDER_STATE_DISCONNECT = 4,
+ CONNMAN_PROVIDER_STATE_FAILURE = 5,
+};
+
+enum connman_provider_error {
+ CONNMAN_PROVIDER_ERROR_UNKNOWN = 0,
+ CONNMAN_PROVIDER_ERROR_CONNECT_FAILED = 1,
+ CONNMAN_PROVIDER_ERROR_LOGIN_FAILED = 2,
+ CONNMAN_PROVIDER_ERROR_AUTH_FAILED = 3,
+};
+
+enum connman_provider_route_type {
+ CONNMAN_PROVIDER_ROUTE_UNKNOWN = 0,
+ CONNMAN_PROVIDER_ROUTE_ALL = 0,
+ CONNMAN_PROVIDER_ROUTE_USER = 1,
+ CONNMAN_PROVIDER_ROUTE_SERVER = 2,
+};
+
+struct connman_provider;
+struct connman_ipaddress;
+
+#define connman_provider_ref(provider) \
+ connman_provider_ref_debug(provider, __FILE__, __LINE__, __func__)
+
+#define connman_provider_unref(provider) \
+ connman_provider_unref_debug(provider, __FILE__, __LINE__, __func__)
+
+struct connman_provider *
+connman_provider_ref_debug(struct connman_provider *provider,
+ const char *file, int line, const char *caller);
+void connman_provider_unref_debug(struct connman_provider *provider,
+ const char *file, int line, const char *caller);
+
+int connman_provider_disconnect(struct connman_provider *provider);
+int connman_provider_remove(struct connman_provider *provider);
+
+int connman_provider_set_string(struct connman_provider *provider,
+ const char *key, const char *value);
+const char *connman_provider_get_string(struct connman_provider *provider,
+ const char *key);
+
+int connman_provider_set_state(struct connman_provider *provider,
+ enum connman_provider_state state);
+
+int connman_provider_indicate_error(struct connman_provider *provider,
+ enum connman_provider_error error);
+
+void connman_provider_set_index(struct connman_provider *provider, int index);
+int connman_provider_get_index(struct connman_provider *provider);
+
+void connman_provider_set_data(struct connman_provider *provider, void *data);
+void *connman_provider_get_data(struct connman_provider *provider);
+int connman_provider_set_ipaddress(struct connman_provider *provider,
+ struct connman_ipaddress *ipaddress);
+int connman_provider_set_pac(struct connman_provider *provider,
+ const char *pac);
+int connman_provider_create_service(struct connman_provider *provider);
+int connman_provider_set_immutable(struct connman_provider *provider,
+ bool immutable);
+struct connman_provider *connman_provider_get(const char *identifier);
+void connman_provider_put(struct connman_provider *provider);
+int connman_provider_set_domain(struct connman_provider *provider,
+ const char *domain);
+int connman_provider_set_nameservers(struct connman_provider *provider,
+ char * const *nameservers);
+int connman_provider_append_route(struct connman_provider *provider,
+ const char *key, const char *value);
+
+const char *connman_provider_get_driver_name(struct connman_provider *provider);
+const char *connman_provider_get_save_group(struct connman_provider *provider);
+typedef void (* connection_ready_cb) (DBusMessage *msg, int error_code,
+ void *user_data);
+
+struct connman_provider_driver {
+ const char *name;
+ enum connman_provider_type type;
+ int (*probe) (struct connman_provider *provider);
+ int (*remove) (struct connman_provider *provider);
+ int (*connect) (struct connman_provider *provider);
+ int (*disconnect) (struct connman_provider *provider);
+ int (*save) (struct connman_provider *provider, GKeyFile *keyfile);
+ int (*set_property) (struct connman_provider *provider,
+ const char *key, const char *value);
+ const char * (*get_property) (struct connman_provider *provider,
+ const char *key);
+ int (*create) (DBusMessage *msg, connection_ready_cb callback);
+ int (*set_routes) (struct connman_provider *provider,
+ enum connman_provider_route_type type);
+ bool (*check_routes) (struct connman_provider *provider);
+};
+
+int connman_provider_driver_register(struct connman_provider_driver *driver);
+void connman_provider_driver_unregister(struct connman_provider_driver *driver);
+void connman_provider_set_driver(struct connman_provider *provider,
+ struct connman_provider_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_PROVIDER_H */
diff --git a/include/provision.h b/include/provision.h
new file mode 100644
index 0000000..3eb80a8
--- /dev/null
+++ b/include/provision.h
@@ -0,0 +1,53 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_PROVISION_H
+#define __CONNMAN_PROVISION_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:provision
+ * @title: Provisioned configuration premitives
+ * @short_description: Functions for provision configuration handling
+ */
+
+struct connman_config_entry {
+ char *ident;
+ char *name;
+ void *ssid;
+ unsigned int ssid_len;
+ bool hidden;
+};
+
+int connman_config_provision_mutable_service(GKeyFile *keyfile);
+struct connman_config_entry **connman_config_get_entries(const char *type);
+void connman_config_free_entries(struct connman_config_entry **entries);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_PROVISION_H */
diff --git a/include/proxy.h b/include/proxy.h
new file mode 100644
index 0000000..7842f65
--- /dev/null
+++ b/include/proxy.h
@@ -0,0 +1,67 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_PROXY_H
+#define __CONNMAN_PROXY_H
+
+#include <connman/service.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:proxy
+ * @title: Proxy premitives
+ * @short_description: Functions for handling proxy configuration
+ */
+
+typedef void (*connman_proxy_lookup_cb) (const char *proxy, void *user_data);
+
+unsigned int connman_proxy_lookup(const char *interface, const char *url,
+ struct connman_service *service,
+ connman_proxy_lookup_cb cb, void *user_data);
+void connman_proxy_lookup_cancel(unsigned int token);
+
+void connman_proxy_driver_lookup_notify(struct connman_service *service,
+ const char *url, const char *result);
+
+#define CONNMAN_PROXY_PRIORITY_LOW -100
+#define CONNMAN_PROXY_PRIORITY_DEFAULT 0
+#define CONNMAN_PROXY_PRIORITY_HIGH 100
+
+struct connman_proxy_driver {
+ const char *name;
+ int priority;
+ int (*request_lookup) (struct connman_service *service,
+ const char *url);
+ void (*cancel_lookup) (struct connman_service *service,
+ const char *url);
+};
+
+int connman_proxy_driver_register(struct connman_proxy_driver *driver);
+void connman_proxy_driver_unregister(struct connman_proxy_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_PROXY_H */
diff --git a/include/resolver.h b/include/resolver.h
new file mode 100644
index 0000000..70a02ad
--- /dev/null
+++ b/include/resolver.h
@@ -0,0 +1,47 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_RESOLVER_H
+#define __CONNMAN_RESOLVER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:resolver
+ * @title: Resolver premitives
+ * @short_description: Functions for registering resolver modules
+ */
+
+int connman_resolver_append(int index, const char *domain,
+ const char *server);
+int connman_resolver_append_lifetime(int index, const char *domain,
+ const char *server, unsigned int lifetime);
+int connman_resolver_remove(int index, const char *domain,
+ const char *server);
+int connman_resolver_remove_all(int index);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_RESOLVER_H */
diff --git a/include/rtnl.h b/include/rtnl.h
new file mode 100644
index 0000000..aa70f4d
--- /dev/null
+++ b/include/rtnl.h
@@ -0,0 +1,65 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_RTNL_H
+#define __CONNMAN_RTNL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:rtnl
+ * @title: RTNL premitives
+ * @short_description: Functions for registering RTNL modules
+ */
+
+typedef void (* connman_rtnl_link_cb_t) (unsigned flags, unsigned change,
+ void *user_data);
+
+unsigned int connman_rtnl_add_newlink_watch(int index,
+ connman_rtnl_link_cb_t callback, void *user_data);
+
+void connman_rtnl_remove_watch(unsigned int id);
+
+#define CONNMAN_RTNL_PRIORITY_LOW -100
+#define CONNMAN_RTNL_PRIORITY_DEFAULT 0
+#define CONNMAN_RTNL_PRIORITY_HIGH 100
+
+struct connman_rtnl {
+ const char *name;
+ int priority;
+ void (*newlink) (unsigned short type, int index,
+ unsigned flags, unsigned change);
+ void (*dellink) (unsigned short type, int index,
+ unsigned flags, unsigned change);
+ void (*newgateway) (int index, const char *gateway);
+ void (*delgateway) (int index, const char *gateway);
+};
+
+int connman_rtnl_register(struct connman_rtnl *rtnl);
+void connman_rtnl_unregister(struct connman_rtnl *rtnl);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_RTNL_H */
diff --git a/include/service.h b/include/service.h
new file mode 100644
index 0000000..8673141
--- /dev/null
+++ b/include/service.h
@@ -0,0 +1,152 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_SERVICE_H
+#define __CONNMAN_SERVICE_H
+
+#include <stdbool.h>
+#include <connman/ipconfig.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:service
+ * @title: Service premitives
+ * @short_description: Functions for handling services
+ */
+
+enum connman_service_type {
+ CONNMAN_SERVICE_TYPE_UNKNOWN = 0,
+ CONNMAN_SERVICE_TYPE_SYSTEM = 1,
+ CONNMAN_SERVICE_TYPE_ETHERNET = 2,
+ CONNMAN_SERVICE_TYPE_WIFI = 3,
+ CONNMAN_SERVICE_TYPE_BLUETOOTH = 4,
+ CONNMAN_SERVICE_TYPE_CELLULAR = 5,
+ CONNMAN_SERVICE_TYPE_GPS = 6,
+ CONNMAN_SERVICE_TYPE_VPN = 7,
+ CONNMAN_SERVICE_TYPE_GADGET = 8,
+ CONNMAN_SERVICE_TYPE_P2P = 9,
+ CONNMAN_SERVICE_TYPE_LOWPAN = 10
+};
+#define MAX_CONNMAN_SERVICE_TYPES 11
+
+
+enum connman_service_security {
+ CONNMAN_SERVICE_SECURITY_UNKNOWN = 0,
+ CONNMAN_SERVICE_SECURITY_NONE = 1,
+ CONNMAN_SERVICE_SECURITY_WEP = 2,
+ CONNMAN_SERVICE_SECURITY_PSK = 3,
+ CONNMAN_SERVICE_SECURITY_8021X = 4,
+ CONNMAN_SERVICE_SECURITY_WPA = 8,
+ CONNMAN_SERVICE_SECURITY_RSN = 9,
+};
+
+enum connman_service_state {
+ CONNMAN_SERVICE_STATE_UNKNOWN = 0,
+ CONNMAN_SERVICE_STATE_IDLE = 1,
+ CONNMAN_SERVICE_STATE_ASSOCIATION = 2,
+ CONNMAN_SERVICE_STATE_CONFIGURATION = 3,
+ CONNMAN_SERVICE_STATE_READY = 4,
+ CONNMAN_SERVICE_STATE_ONLINE = 5,
+ CONNMAN_SERVICE_STATE_DISCONNECT = 6,
+ CONNMAN_SERVICE_STATE_FAILURE = 7,
+};
+
+enum connman_service_error {
+ CONNMAN_SERVICE_ERROR_UNKNOWN = 0,
+ CONNMAN_SERVICE_ERROR_OUT_OF_RANGE = 1,
+ CONNMAN_SERVICE_ERROR_PIN_MISSING = 2,
+ CONNMAN_SERVICE_ERROR_DHCP_FAILED = 3,
+ CONNMAN_SERVICE_ERROR_CONNECT_FAILED = 4,
+ CONNMAN_SERVICE_ERROR_LOGIN_FAILED = 5,
+ CONNMAN_SERVICE_ERROR_AUTH_FAILED = 6,
+ CONNMAN_SERVICE_ERROR_INVALID_KEY = 7,
+};
+
+enum connman_service_proxy_method {
+ CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN = 0,
+ CONNMAN_SERVICE_PROXY_METHOD_DIRECT = 1,
+ CONNMAN_SERVICE_PROXY_METHOD_MANUAL = 2,
+ CONNMAN_SERVICE_PROXY_METHOD_AUTO = 3,
+};
+
+enum connman_service_connect_reason {
+ CONNMAN_SERVICE_CONNECT_REASON_NONE = 0,
+ CONNMAN_SERVICE_CONNECT_REASON_AUTO = 1,
+ CONNMAN_SERVICE_CONNECT_REASON_USER = 2,
+ CONNMAN_SERVICE_CONNECT_REASON_SESSION = 3,
+};
+
+struct connman_service;
+struct connman_network;
+
+struct connman_service *connman_service_create(void);
+
+#define connman_service_ref(service) \
+ connman_service_ref_debug(service, __FILE__, __LINE__, __func__)
+
+#define connman_service_unref(service) \
+ connman_service_unref_debug(service, __FILE__, __LINE__, __func__)
+
+struct connman_service *
+connman_service_ref_debug(struct connman_service *service,
+ const char *file, int line, const char *caller);
+void connman_service_unref_debug(struct connman_service *service,
+ const char *file, int line, const char *caller);
+
+enum connman_service_type connman_service_get_type(struct connman_service *service);
+char *connman_service_get_interface(struct connman_service *service);
+
+const char *connman_service_get_domainname(struct connman_service *service);
+char **connman_service_get_nameservers(struct connman_service *service);
+char **connman_service_get_timeservers_config(struct connman_service *service);
+char **connman_service_get_timeservers(struct connman_service *service);
+void connman_service_set_proxy_method(struct connman_service *service, enum connman_service_proxy_method method);
+enum connman_service_proxy_method connman_service_get_proxy_method(struct connman_service *service);
+char **connman_service_get_proxy_servers(struct connman_service *service);
+char **connman_service_get_proxy_excludes(struct connman_service *service);
+const char *connman_service_get_proxy_url(struct connman_service *service);
+const char *connman_service_get_proxy_autoconfig(struct connman_service *service);
+bool connman_service_get_favorite(struct connman_service *service);
+bool connman_service_get_autoconnect(struct connman_service *service);
+
+struct connman_service *connman_service_lookup_from_network(struct connman_network *network);
+
+void connman_service_create_ip4config(struct connman_service *service,
+ int index);
+void connman_service_create_ip6config(struct connman_service *service,
+ int index);
+
+int connman_service_connect(struct connman_service *service, enum connman_service_connect_reason reason);
+int connman_service_disconnect(struct connman_service *service);
+
+int connman_service_ipconfig_indicate_state(struct connman_service *service,
+ enum connman_service_state new_state,
+ enum connman_ipconfig_type type);
+void connman_service_force_notify(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_SERVICE_H */
diff --git a/include/session.h b/include/session.h
new file mode 100644
index 0000000..37dfc4e
--- /dev/null
+++ b/include/session.h
@@ -0,0 +1,110 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_SESSION_H
+#define __CONNMAN_SESSION_H
+
+#include <connman/service.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONNMAN_SESSION_POLICY_PRIORITY_LOW -100
+#define CONNMAN_SESSION_POLICY_PRIORITY_DEFAULT 0
+#define CONNMAN_SESSION_POLICY_PRIORITY_HIGH 100
+
+enum connman_session_roaming_policy {
+ CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN = 0,
+ CONNMAN_SESSION_ROAMING_POLICY_DEFAULT = 1,
+ CONNMAN_SESSION_ROAMING_POLICY_ALWAYS = 2,
+ CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN = 3,
+ CONNMAN_SESSION_ROAMING_POLICY_NATIONAL = 4,
+ CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL = 5,
+};
+
+enum connman_session_type {
+ CONNMAN_SESSION_TYPE_UNKNOWN = 0,
+ CONNMAN_SESSION_TYPE_ANY = 1,
+ CONNMAN_SESSION_TYPE_LOCAL = 2,
+ CONNMAN_SESSION_TYPE_INTERNET = 3,
+};
+
+enum connman_session_id_type {
+ CONNMAN_SESSION_ID_TYPE_UNKNOWN = 0,
+ CONNMAN_SESSION_ID_TYPE_UID = 1,
+ CONNMAN_SESSION_ID_TYPE_GID = 2,
+ CONNMAN_SESSION_ID_TYPE_LSM = 3,
+};
+
+struct connman_session;
+
+struct connman_session_config {
+ enum connman_session_id_type id_type;
+ char *id;
+ bool priority;
+ enum connman_session_roaming_policy roaming_policy;
+ enum connman_session_type type;
+ bool ecall;
+ GSList *allowed_bearers;
+};
+
+typedef int (* connman_session_config_func_t) (struct connman_session *session,
+ struct connman_session_config *config,
+ void *user_data, int err);
+
+struct connman_session_policy {
+ const char *name;
+ int priority;
+ bool (*autoconnect)(enum connman_service_connect_reason reason);
+ int (*create)(struct connman_session *session,
+ connman_session_config_func_t cb,
+ void *user_data);
+ void (*destroy)(struct connman_session *session);
+ void (*session_changed)(struct connman_session *session, bool active,
+ GSList *bearers);
+ bool (*allowed)(struct connman_session *session,
+ struct connman_service *service);
+};
+
+int connman_session_policy_register(struct connman_session_policy *config);
+void connman_session_policy_unregister(struct connman_session_policy *config);
+
+int connman_session_config_update(struct connman_session *session);
+void connman_session_destroy(struct connman_session *session);
+
+void connman_session_set_default_config(struct connman_session_config *config);
+struct connman_session_config *connman_session_create_default_config(void);
+
+enum connman_session_roaming_policy connman_session_parse_roaming_policy(const char *policy);
+enum connman_session_type connman_session_parse_connection_type(const char *type);
+int connman_session_parse_bearers(const char *token, GSList **list);
+
+const char *connman_session_get_owner(struct connman_session *session);
+
+int connman_session_connect(struct connman_service *service);
+int connman_session_disconnect(struct connman_service *service);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_SESSION_H */
diff --git a/include/setting.h b/include/setting.h
new file mode 100644
index 0000000..a882021
--- /dev/null
+++ b/include/setting.h
@@ -0,0 +1,42 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_SETTING_H
+#define __CONNMAN_SETTING_H
+
+#include <stdbool.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+bool connman_setting_get_bool(const char *key);
+char **connman_setting_get_string_list(const char *key);
+unsigned int *connman_setting_get_uint_list(const char *key);
+
+unsigned int connman_timeout_input_request(void);
+unsigned int connman_timeout_browser_launch(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_SETTING_H */
diff --git a/include/storage.h b/include/storage.h
new file mode 100644
index 0000000..4c23a14
--- /dev/null
+++ b/include/storage.h
@@ -0,0 +1,38 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_STORAGE_H
+#define __CONNMAN_STORAGE_H
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+gchar **connman_storage_get_services();
+GKeyFile *connman_storage_load_service(const char *service_id);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_STORAGE_H */
diff --git a/include/task.h b/include/task.h
new file mode 100644
index 0000000..9977d63
--- /dev/null
+++ b/include/task.h
@@ -0,0 +1,67 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_TASK_H
+#define __CONNMAN_TASK_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:task
+ * @title: Task premitives
+ * @short_description: Functions for handling tasks
+ */
+
+struct connman_task;
+
+typedef void (* connman_task_exit_t) (struct connman_task *task,
+ int exit_code, void *user_data);
+
+typedef DBusMessage * (* connman_task_notify_t) (struct connman_task *task,
+ DBusMessage *message, void *user_data);
+
+struct connman_task *connman_task_create(const char *program);
+void connman_task_destroy(struct connman_task *task);
+
+const char *connman_task_get_path(struct connman_task *task);
+
+int connman_task_add_argument(struct connman_task *task,
+ const char *name, const char *format, ...);
+int connman_task_add_variable(struct connman_task *task,
+ const char *key, const char *format, ...);
+
+int connman_task_set_notify(struct connman_task *task, const char *member,
+ connman_task_notify_t function, void *user_data);
+
+int connman_task_run(struct connman_task *task,
+ connman_task_exit_t function, void *user_data,
+ int *stdin_fd, int *stdout_fd, int *stderr_fd);
+int connman_task_stop(struct connman_task *task);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_TASK_H */
diff --git a/include/technology.h b/include/technology.h
new file mode 100644
index 0000000..d7fcdde
--- /dev/null
+++ b/include/technology.h
@@ -0,0 +1,74 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_TECHNOLOGY_H
+#define __CONNMAN_TECHNOLOGY_H
+
+#include <connman/service.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:technology
+ * @title: technology premitives
+ * @short_description: Functions for handling technology details
+ */
+
+struct connman_technology;
+
+void connman_technology_tethering_notify(struct connman_technology *technology,
+ bool enabled);
+int connman_technology_set_regdom(const char *alpha2);
+void connman_technology_regdom_notify(struct connman_technology *technology,
+ const char *alpha2);
+
+bool connman_technology_get_wifi_tethering(const char **ssid,
+ const char **psk);
+bool connman_technology_is_tethering_allowed(enum connman_service_type type);
+
+struct connman_technology_driver {
+ const char *name;
+ enum connman_service_type type;
+ int priority;
+ int (*probe) (struct connman_technology *technology);
+ void (*remove) (struct connman_technology *technology);
+ void (*add_interface) (struct connman_technology *technology,
+ int index, const char *name,
+ const char *ident);
+ void (*remove_interface) (struct connman_technology *technology,
+ int index);
+ int (*set_tethering) (struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled);
+ int (*set_regdom) (struct connman_technology *technology,
+ const char *alpha2);
+};
+
+int connman_technology_driver_register(struct connman_technology_driver *driver);
+void connman_technology_driver_unregister(struct connman_technology_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_TECHNOLOGY_H */
diff --git a/include/timeserver.h b/include/timeserver.h
new file mode 100644
index 0000000..48ea194
--- /dev/null
+++ b/include/timeserver.h
@@ -0,0 +1,35 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_TIMESERVER_H
+#define __CONNMAN_TIMESERVER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int __connman_timeserver_system_set(char **server);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_TIMESERVER_H */
diff --git a/include/utsname.h b/include/utsname.h
new file mode 100644
index 0000000..b8165f6
--- /dev/null
+++ b/include/utsname.h
@@ -0,0 +1,52 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_UTSNAME_H
+#define __CONNMAN_UTSNAME_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:utsname
+ * @title: utsname premitives
+ * @short_description: Functions for handling utsname
+ */
+
+const char *connman_utsname_get_hostname(void);
+
+struct connman_utsname_driver {
+ const char *name;
+ int priority;
+ const char * (*get_hostname) (void);
+ int (*set_hostname) (const char *hostname);
+ int (*set_domainname) (const char *domainname);
+};
+
+int connman_utsname_driver_register(struct connman_utsname_driver *driver);
+void connman_utsname_driver_unregister(struct connman_utsname_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_UTSNAME_H */
diff --git a/include/version.h.in b/include/version.h.in
new file mode 100644
index 0000000..d3d6dd3
--- /dev/null
+++ b/include/version.h.in
@@ -0,0 +1,35 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_VERSION_H
+#define __CONNMAN_VERSION_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define CONNMAN_VERSION "@VERSION@"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_VERSION_H */
diff --git a/include/vpn-dbus.h b/include/vpn-dbus.h
new file mode 100644
index 0000000..01780cb
--- /dev/null
+++ b/include/vpn-dbus.h
@@ -0,0 +1,58 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __VPN_DBUS_H
+#define __VPN_DBUS_H
+
+#include <dbus/dbus.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VPN_SERVICE "net.connman.vpn"
+#define VPN_PATH "/net/connman/vpn"
+
+#define VPN_ERROR_INTERFACE VPN_SERVICE ".Error"
+
+#define VPN_MANAGER_INTERFACE VPN_SERVICE ".Manager"
+#define VPN_MANAGER_PATH "/"
+
+#define VPN_CONNECTION_INTERFACE VPN_SERVICE ".Connection"
+#define VPN_AGENT_INTERFACE VPN_SERVICE ".Agent"
+#define VPN_TASK_INTERFACE VPN_SERVICE ".Task"
+
+#define VPN_PRIVILEGE_MODIFY 1
+#define VPN_PRIVILEGE_SECRET 2
+
+#define CONNECTION_ADDED "ConnectionAdded"
+#define CONNECTION_REMOVED "ConnectionRemoved"
+#define PROPERTY_CHANGED "PropertyChanged"
+#define GET_CONNECTIONS "GetConnections"
+#define VPN_CONNECT "Connect"
+#define VPN_DISCONNECT "Disconnect"
+#define VPN_REMOVE "Remove"
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __VPN_DBUS_H */
diff --git a/plugins/bluetooth.c b/plugins/bluetooth.c
new file mode 100644
index 0000000..f192c18
--- /dev/null
+++ b/plugins/bluetooth.c
@@ -0,0 +1,992 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/dbus.h>
+#include <connman/technology.h>
+#include <connman/device.h>
+#include <connman/inet.h>
+#include <gdbus.h>
+
+#define BLUEZ_SERVICE "org.bluez"
+#define BLUEZ_PATH "/org/bluez"
+#define BLUETOOTH_PAN_PANU "00001115-0000-1000-8000-00805f9b34fb"
+#define BLUETOOTH_PAN_NAP "00001116-0000-1000-8000-00805f9b34fb"
+#define BLUETOOTH_PAN_GN "00001117-0000-1000-8000-00805f9b34fb"
+
+#define BLUETOOTH_ADDR_LEN 6
+
+static DBusConnection *connection;
+static GDBusClient *client;
+static GHashTable *devices;
+static GHashTable *networks;
+static bool bluetooth_tethering;
+
+struct bluetooth_pan {
+ struct connman_network *network;
+ GDBusProxy *btdevice_proxy;
+ GDBusProxy *btnetwork_proxy;
+ const char *pan_role;
+};
+
+static void address2ident(const char *address, char *ident)
+{
+ int i;
+
+ for (i = 0; i < BLUETOOTH_ADDR_LEN; i++) {
+ ident[i * 2] = address[i * 3];
+ ident[i * 2 + 1] = address[i * 3 + 1];
+ }
+ ident[BLUETOOTH_ADDR_LEN * 2] = '\0';
+}
+
+static const char *proxy_get_string(GDBusProxy *proxy, const char *property)
+{
+ DBusMessageIter iter;
+ const char *str;
+
+ if (!g_dbus_proxy_get_property(proxy, property, &iter))
+ return NULL;
+ dbus_message_iter_get_basic(&iter, &str);
+ return str;
+}
+
+static bool proxy_get_bool(GDBusProxy *proxy, const char *property)
+{
+ DBusMessageIter iter;
+ dbus_bool_t value;
+
+ if (!g_dbus_proxy_get_property(proxy, property, &iter))
+ return false;
+ dbus_message_iter_get_basic(&iter, &value);
+ return value;
+}
+
+static const char *proxy_get_role(GDBusProxy *proxy)
+{
+ DBusMessageIter iter, value;
+ const char *pref = NULL;
+
+ if (!proxy)
+ return NULL;
+
+ if (!g_dbus_proxy_get_property(proxy, "UUIDs", &iter))
+ return NULL;
+
+ dbus_message_iter_recurse(&iter, &value);
+ while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
+ const char *uuid;
+
+ dbus_message_iter_get_basic(&value, &uuid);
+ /*
+ * If a device offers more than one role, we prefer NAP,
+ * then GN, then PANU.
+ */
+ if (!strcmp(uuid, BLUETOOTH_PAN_NAP))
+ return "nap";
+ if (!strcmp(uuid, BLUETOOTH_PAN_GN))
+ pref = "gn";
+ if (!strcmp(uuid, BLUETOOTH_PAN_PANU) && !pref)
+ pref = "panu";
+
+ dbus_message_iter_next(&value);
+ }
+
+ return pref;
+}
+
+static int bluetooth_pan_probe(struct connman_network *network)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ DBG("network %p", network);
+
+ g_hash_table_iter_init(&iter, networks);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct bluetooth_pan *pan = value;
+
+ if (network == pan->network)
+ return 0;
+ }
+
+ return -EOPNOTSUPP;
+}
+
+static void pan_remove_nap(struct bluetooth_pan *pan)
+{
+ struct connman_device *device;
+ struct connman_network *network = pan->network;
+
+ DBG("network %p pan %p", pan->network, pan);
+
+ if (!network)
+ return;
+
+ pan->network = NULL;
+ connman_network_set_data(network, NULL);
+
+ device = connman_network_get_device(network);
+ if (device)
+ connman_device_remove_network(device, network);
+
+ connman_network_unref(network);
+}
+
+static void bluetooth_pan_remove(struct connman_network *network)
+{
+ struct bluetooth_pan *pan = connman_network_get_data(network);
+
+ DBG("network %p pan %p", network, pan);
+
+ connman_network_set_data(network, NULL);
+
+ if (pan)
+ pan_remove_nap(pan);
+}
+
+static bool pan_connect(struct bluetooth_pan *pan,
+ const char *iface)
+{
+ int index;
+
+ if (!iface) {
+ if (!proxy_get_bool(pan->btnetwork_proxy, "Connected"))
+ return false;
+ iface = proxy_get_string(pan->btnetwork_proxy, "Interface");
+ }
+
+ if (!iface)
+ return false;
+
+ index = connman_inet_ifindex(iface);
+ if (index < 0) {
+ DBG("network %p invalid index %d", pan->network, index);
+ return false;
+ }
+
+ connman_network_set_index(pan->network, index);
+ connman_network_set_connected(pan->network, true);
+
+ return true;
+}
+
+static void pan_connect_cb(DBusMessage *message, void *user_data)
+{
+ const char *path = user_data;
+ const char *iface = NULL;
+ struct bluetooth_pan *pan;
+ DBusMessageIter iter;
+
+ pan = g_hash_table_lookup(networks, path);
+ if (!pan) {
+ DBG("network already removed");
+ return;
+ }
+
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
+ const char *dbus_error = dbus_message_get_error_name(message);
+
+ DBG("network %p %s", pan->network, dbus_error);
+
+ if (strcmp(dbus_error,
+ "org.bluez.Error.AlreadyConnected") != 0) {
+ connman_network_set_error(pan->network,
+ CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
+ return;
+ }
+ } else {
+ if (dbus_message_iter_init(message, &iter) &&
+ dbus_message_iter_get_arg_type(&iter) ==
+ DBUS_TYPE_STRING)
+ dbus_message_iter_get_basic(&iter, &iface);
+ }
+
+ DBG("network %p interface %s", pan->network, iface);
+
+ pan_connect(pan, iface);
+}
+
+static void pan_connect_append(DBusMessageIter *iter,
+ void *user_data)
+{
+ const char *path = user_data;
+ struct bluetooth_pan *pan;
+
+ pan = g_hash_table_lookup(networks, path);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &pan->pan_role);
+}
+
+static int bluetooth_pan_connect(struct connman_network *network)
+{
+ struct bluetooth_pan *pan = connman_network_get_data(network);
+ const char *path;
+
+ DBG("network %p", network);
+
+ if (!pan)
+ return -EINVAL;
+
+ path = g_dbus_proxy_get_path(pan->btnetwork_proxy);
+
+ if (!g_dbus_proxy_method_call(pan->btnetwork_proxy, "Connect",
+ pan_connect_append, pan_connect_cb,
+ g_strdup(path), g_free))
+ return -EIO;
+
+ connman_network_set_associating(pan->network, true);
+
+ return -EINPROGRESS;
+}
+
+static void pan_disconnect_cb(DBusMessage *message, void *user_data)
+{
+ const char *path = user_data;
+ struct bluetooth_pan *pan;
+
+ pan = g_hash_table_lookup(networks, path);
+ if (!pan) {
+ DBG("network already removed");
+ return;
+ }
+
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
+ const char *dbus_error = dbus_message_get_error_name(message);
+
+ DBG("network %p %s", pan->network, dbus_error);
+ }
+
+ DBG("network %p", pan->network);
+
+ connman_network_set_connected(pan->network, false);
+}
+
+static int bluetooth_pan_disconnect(struct connman_network *network, bool user_initiated)
+{
+ struct bluetooth_pan *pan = connman_network_get_data(network);
+ const char *path;
+
+ DBG("network %p", network);
+
+ if (!pan)
+ return -EINVAL;
+
+ path = g_dbus_proxy_get_path(pan->btnetwork_proxy);
+
+ if (!g_dbus_proxy_method_call(pan->btnetwork_proxy, "Disconnect",
+ NULL, pan_disconnect_cb, g_strdup(path), g_free))
+ return -EIO;
+
+ return -EINPROGRESS;
+}
+
+static void btnetwork_property_change(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct bluetooth_pan *pan;
+ dbus_bool_t connected;
+ bool proxy_connected, network_connected;
+
+ if (strcmp(name, "Connected") != 0)
+ return;
+
+ pan = g_hash_table_lookup(networks, g_dbus_proxy_get_path(proxy));
+ if (!pan || !pan->network)
+ return;
+
+ dbus_message_iter_get_basic(iter, &connected);
+ proxy_connected = connected;
+
+ network_connected = connman_network_get_connected(pan->network);
+
+ DBG("network %p network connected %d proxy connected %d",
+ pan->network, network_connected, proxy_connected);
+
+ if (network_connected != proxy_connected)
+ connman_network_set_connected(pan->network, proxy_connected);
+}
+
+static void pan_create_nap(struct bluetooth_pan *pan)
+{
+ struct connman_device *device;
+ const char* role;
+
+ role = proxy_get_role(pan->btdevice_proxy);
+ if (!role) {
+ pan_remove_nap(pan);
+ return;
+ }
+
+ device = g_hash_table_lookup(devices,
+ proxy_get_string(pan->btdevice_proxy, "Adapter"));
+
+ if (!device || !connman_device_get_powered(device))
+ return;
+
+ if (!pan->network) {
+ const char *address;
+ char ident[BLUETOOTH_ADDR_LEN * 2 + 1];
+ const char *name, *path;
+
+ address = proxy_get_string(pan->btdevice_proxy, "Address");
+ if (!address) {
+ connman_warn("Bluetooth device address missing");
+ return;
+ }
+
+ address2ident(address, ident);
+
+ pan->network = connman_network_create(ident,
+ CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN);
+
+ name = proxy_get_string(pan->btdevice_proxy, "Alias");
+ path = g_dbus_proxy_get_path(pan->btnetwork_proxy);
+
+ DBG("network %p %s %s", pan->network, path, name);
+
+ if (!pan->network) {
+ connman_warn("Bluetooth network %s creation failed",
+ path);
+ return;
+ }
+
+ connman_network_set_data(pan->network, pan);
+ connman_network_set_name(pan->network, name);
+ connman_network_set_group(pan->network, ident);
+ }
+
+ pan->pan_role = role;
+ connman_device_add_network(device, pan->network);
+
+ if (pan_connect(pan, NULL))
+ DBG("network %p already connected", pan->network);
+}
+
+static void btdevice_property_change(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct bluetooth_pan *pan;
+ const char *old_role = NULL;
+ const char *new_role;
+
+ if (strcmp(name, "UUIDs"))
+ return;
+
+ pan = g_hash_table_lookup(networks, g_dbus_proxy_get_path(proxy));
+ if (!pan)
+ return;
+
+ if (pan->network &&
+ connman_network_get_device(pan->network))
+ old_role = pan->pan_role;
+ new_role = proxy_get_role(pan->btdevice_proxy);
+
+ DBG("network %p network role %s proxy role %s", pan->network, old_role,
+ new_role);
+
+ if (old_role && new_role && !strcmp(old_role, new_role))
+ return;
+
+ pan_create_nap(pan);
+}
+
+static void pan_free(gpointer data)
+{
+ struct bluetooth_pan *pan = data;
+
+ if (pan->btnetwork_proxy) {
+ g_dbus_proxy_unref(pan->btnetwork_proxy);
+ pan->btnetwork_proxy = NULL;
+ }
+
+ if (pan->btdevice_proxy) {
+ g_dbus_proxy_unref(pan->btdevice_proxy);
+ pan->btdevice_proxy = NULL;
+ }
+
+ pan_remove_nap(pan);
+
+ g_free(pan);
+}
+
+static void pan_create(GDBusProxy *network_proxy)
+{
+ const char *path = g_dbus_proxy_get_path(network_proxy);
+ struct bluetooth_pan *pan;
+
+ pan = g_try_new0(struct bluetooth_pan, 1);
+
+ if (!pan) {
+ connman_error("Out of memory creating PAN NAP");
+ return;
+ }
+
+ g_hash_table_replace(networks, g_strdup(path), pan);
+
+ pan->btnetwork_proxy = g_dbus_proxy_ref(network_proxy);
+ pan->btdevice_proxy = g_dbus_proxy_new(client, path,
+ "org.bluez.Device1");
+
+ if (!pan->btdevice_proxy) {
+ connman_error("Cannot create BT PAN watcher %s", path);
+ g_hash_table_remove(networks, path);
+ return;
+ }
+
+ g_dbus_proxy_set_property_watch(pan->btnetwork_proxy,
+ btnetwork_property_change, NULL);
+
+ g_dbus_proxy_set_property_watch(pan->btdevice_proxy,
+ btdevice_property_change, NULL);
+
+ DBG("pan %p %s role %s", pan, path, proxy_get_role(pan->btdevice_proxy));
+
+ pan_create_nap(pan);
+}
+
+static struct connman_network_driver network_driver = {
+ .name = "bluetooth",
+ .type = CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN,
+ .probe = bluetooth_pan_probe,
+ .remove = bluetooth_pan_remove,
+ .connect = bluetooth_pan_connect,
+ .disconnect = bluetooth_pan_disconnect,
+};
+
+static void enable_device(struct connman_device *device, const char *path)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ DBG("device %p %s", device, path);
+ connman_device_set_powered(device, true);
+
+ g_hash_table_iter_init(&iter, networks);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct bluetooth_pan *pan = value;
+
+ if (g_strcmp0(proxy_get_string(pan->btdevice_proxy, "Adapter"),
+ path) == 0) {
+
+ DBG("enable network %p", pan->network);
+ pan_create_nap(pan);
+ }
+ }
+}
+
+static void device_enable_cb(const DBusError *error, void *user_data)
+{
+ char *path = user_data;
+ struct connman_device *device;
+
+ device = g_hash_table_lookup(devices, path);
+ if (!device) {
+ DBG("device already removed");
+ goto out;
+ }
+
+ if (dbus_error_is_set(error)) {
+ connman_warn("Bluetooth device %s not enabled %s",
+ path, error->message);
+ goto out;
+ }
+
+ enable_device(device, path);
+out:
+ g_free(path);
+}
+
+static int bluetooth_device_enable(struct connman_device *device)
+{
+ GDBusProxy *proxy = connman_device_get_data(device);
+ dbus_bool_t device_powered = TRUE;
+ const char *path;
+
+ if (!proxy)
+ return 0;
+
+ path = g_dbus_proxy_get_path(proxy);
+
+ if (proxy_get_bool(proxy, "Powered")) {
+ DBG("already enabled %p %s", device, path);
+ return -EALREADY;
+ }
+
+ DBG("device %p %s", device, path);
+
+ g_dbus_proxy_set_property_basic(proxy, "Powered",
+ DBUS_TYPE_BOOLEAN, &device_powered,
+ device_enable_cb, g_strdup(path), NULL);
+
+ return -EINPROGRESS;
+}
+
+static void disable_device(struct connman_device *device, const char *path)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ DBG("device %p %s", device, path);
+ connman_device_set_powered(device, false);
+
+ g_hash_table_iter_init(&iter, networks);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct bluetooth_pan *pan = value;
+
+ if (pan->network && connman_network_get_device(pan->network)
+ == device) {
+ DBG("disable network %p", pan->network);
+ connman_device_remove_network(device, pan->network);
+ }
+ }
+}
+
+static void device_disable_cb(const DBusError *error, void *user_data)
+{
+ char *path = user_data;
+ struct connman_device *device;
+
+ device = g_hash_table_lookup(devices, path);
+ if (!device) {
+ DBG("device already removed");
+ goto out;
+ }
+
+ if (dbus_error_is_set(error)) {
+ connman_warn("Bluetooth device %s not disabled: %s",
+ path, error->message);
+ goto out;
+ }
+
+ disable_device(device, path);
+
+out:
+ g_free(path);
+}
+
+static int bluetooth_device_disable(struct connman_device *device)
+{
+ GDBusProxy *proxy = connman_device_get_data(device);
+ dbus_bool_t device_powered = FALSE;
+ const char *path;
+
+ if (!proxy)
+ return 0;
+
+ path = g_dbus_proxy_get_path(proxy);
+
+ if (!proxy_get_bool(proxy, "Powered")) {
+ DBG("already disabled %p %s", device, path);
+ return -EALREADY;
+ }
+
+ DBG("device %p %s", device, path);
+
+ g_dbus_proxy_set_property_basic(proxy, "Powered",
+ DBUS_TYPE_BOOLEAN, &device_powered,
+ device_disable_cb, g_strdup(path), NULL);
+
+ return -EINPROGRESS;
+}
+
+static void adapter_property_change(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct connman_device *device;
+ const char *path;
+ bool adapter_powered, device_powered;
+
+ if (strcmp(name, "Powered") != 0)
+ return;
+
+ path = g_dbus_proxy_get_path(proxy);
+ device = g_hash_table_lookup(devices, path);
+
+ adapter_powered = proxy_get_bool(proxy, "Powered");
+ device_powered = connman_device_get_powered(device);
+
+ DBG("device %p %s device powered %d adapter powered %d", device, path,
+ device_powered, adapter_powered);
+
+ if (device_powered != adapter_powered) {
+ if (adapter_powered)
+ enable_device(device, path);
+ else
+ disable_device(device, path);
+ }
+}
+
+static void device_free(gpointer data)
+{
+ struct connman_device *device = data;
+ GDBusProxy *proxy = connman_device_get_data(device);
+
+ connman_device_set_data(device, NULL);
+ if (proxy)
+ g_dbus_proxy_unref(proxy);
+
+ connman_device_unregister(device);
+ connman_device_unref(device);
+}
+
+struct tethering_info {
+ struct connman_technology *technology;
+ char *bridge;
+ bool enable;
+};
+
+static void tethering_free(void *user_data)
+{
+ struct tethering_info *tethering = user_data;
+
+ g_free(tethering->bridge);
+ g_free(tethering);
+}
+
+static void tethering_create_cb(DBusMessage *message, void *user_data)
+{
+ struct tethering_info *tethering = user_data;
+
+ if (dbus_message_get_type(message) == DBUS_MESSAGE_TYPE_ERROR) {
+ const char *dbus_error = dbus_message_get_error_name(message);
+
+ DBG("%s tethering failed: %s",
+ tethering->enable ? "enable" : "disable",
+ dbus_error);
+ return;
+ }
+
+ DBG("bridge %s %s", tethering->bridge, tethering->enable ?
+ "enabled": "disabled");
+
+ if (tethering->technology)
+ connman_technology_tethering_notify(tethering->technology,
+ tethering->enable);
+}
+
+static void tethering_append(DBusMessageIter *iter, void *user_data)
+{
+ struct tethering_info *tethering = user_data;
+ const char *nap = "nap";
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &nap);
+ if (tethering->enable)
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &tethering->bridge);
+}
+
+static bool tethering_create(const char *path,
+ struct connman_technology *technology, const char *bridge,
+ bool enabled)
+{
+ struct tethering_info *tethering = g_new0(struct tethering_info, 1);
+ GDBusProxy *proxy;
+ const char *method;
+ bool result;
+
+ DBG("path %s bridge %s", path, bridge);
+
+ if (!bridge)
+ return -EINVAL;
+
+ proxy = g_dbus_proxy_new(client, path, "org.bluez.NetworkServer1");
+ if (!proxy)
+ return false;
+
+ tethering->technology = technology;
+ tethering->bridge = g_strdup(bridge);
+ tethering->enable = enabled;
+
+ if (tethering->enable)
+ method = "Register";
+ else
+ method = "Unregister";
+
+ result = g_dbus_proxy_method_call(proxy, method, tethering_append,
+ tethering_create_cb, tethering, tethering_free);
+
+ g_dbus_proxy_unref(proxy);
+
+ return result;
+}
+
+static void device_create(GDBusProxy *proxy)
+{
+ struct connman_device *device = NULL;
+ const char *path = g_dbus_proxy_get_path(proxy);
+ const char *address;
+ char ident[BLUETOOTH_ADDR_LEN * 2 + 1];
+ bool powered;
+
+ address = proxy_get_string(proxy, "Address");
+ if (!address)
+ return;
+
+ address2ident(address, ident);
+
+ device = connman_device_create("bluetooth",
+ CONNMAN_DEVICE_TYPE_BLUETOOTH);
+ if (!device)
+ return;
+
+ connman_device_set_data(device, g_dbus_proxy_ref(proxy));
+ connman_device_set_ident(device, ident);
+
+ g_hash_table_replace(devices, g_strdup(path), device);
+
+ DBG("device %p %s device powered %d adapter powered %d", device,
+ path, connman_device_get_powered(device),
+ proxy_get_bool(proxy, "Powered"));
+
+ if (connman_device_register(device) < 0) {
+ g_hash_table_remove(devices, device);
+ return;
+ }
+
+ g_dbus_proxy_set_property_watch(proxy, adapter_property_change, NULL);
+
+ powered = proxy_get_bool(proxy, "Powered");
+ connman_device_set_powered(device, powered);
+
+ if (proxy_get_role(proxy) && !bluetooth_tethering)
+ tethering_create(path, NULL, NULL, false);
+}
+
+static void object_added(GDBusProxy *proxy, void *user_data)
+{
+ const char *interface;
+
+ interface = g_dbus_proxy_get_interface(proxy);
+ if (!interface) {
+ connman_warn("Interface or proxy missing when adding "
+ "bluetooth object");
+ return;
+ }
+
+ if (strcmp(interface, "org.bluez.Adapter1") == 0) {
+ DBG("%s %s", interface, g_dbus_proxy_get_path(proxy));
+ device_create(proxy);
+ return;
+ }
+
+ if (strcmp(interface, "org.bluez.Network1") == 0) {
+ DBG("%s %s", interface, g_dbus_proxy_get_path(proxy));
+ pan_create(proxy);
+ return;
+ }
+}
+
+static void object_removed(GDBusProxy *proxy, void *user_data)
+{
+ const char *interface, *path;
+
+ interface = g_dbus_proxy_get_interface(proxy);
+ if (!interface) {
+ connman_warn("Interface or proxy missing when removing "
+ "bluetooth object");
+ return;
+ }
+
+ if (strcmp(interface, "org.bluez.Adapter1") == 0) {
+ path = g_dbus_proxy_get_path(proxy);
+ DBG("%s %s", interface, path);
+
+ g_hash_table_remove(devices, path);
+ }
+
+ if (strcmp(interface, "org.bluez.Network1") == 0) {
+ path = g_dbus_proxy_get_path(proxy);
+ DBG("%s %s", interface, path);
+
+ g_hash_table_remove(networks, path);
+ }
+
+}
+
+static int bluetooth_device_probe(struct connman_device *device)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ g_hash_table_iter_init(&iter, devices);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_device *known = value;
+
+ if (device == known)
+ return 0;
+ }
+
+ return -EOPNOTSUPP;
+}
+
+static void bluetooth_device_remove(struct connman_device *device)
+{
+ DBG("%p", device);
+}
+
+static struct connman_device_driver device_driver = {
+ .name = "bluetooth",
+ .type = CONNMAN_DEVICE_TYPE_BLUETOOTH,
+ .probe = bluetooth_device_probe,
+ .remove = bluetooth_device_remove,
+ .enable = bluetooth_device_enable,
+ .disable = bluetooth_device_disable,
+};
+
+static int bluetooth_tech_probe(struct connman_technology *technology)
+{
+ return 0;
+}
+
+static void bluetooth_tech_remove(struct connman_technology *technology)
+{
+
+}
+
+static int bluetooth_tech_set_tethering(struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled)
+{
+ GHashTableIter hash_iter;
+ gpointer key, value;
+ int i = 0;
+
+ bluetooth_tethering = enabled;
+
+ g_hash_table_iter_init(&hash_iter, devices);
+
+ while (g_hash_table_iter_next(&hash_iter, &key, &value)) {
+ const char *path = key;
+ struct connman_device *device = value;
+
+ DBG("device %p", device);
+
+ if (tethering_create(path, technology, bridge, enabled)
+ )
+ i++;
+ }
+
+ DBG("%s %d device(s)", enabled ? "enabled" : "disabled", i);
+
+ if (i == 0)
+ return -ENODEV;
+
+ return 0;
+}
+
+static struct connman_technology_driver tech_driver = {
+ .name = "bluetooth",
+ .type = CONNMAN_SERVICE_TYPE_BLUETOOTH,
+ .probe = bluetooth_tech_probe,
+ .remove = bluetooth_tech_remove,
+ .set_tethering = bluetooth_tech_set_tethering,
+};
+
+static int bluetooth_init(void)
+{
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ goto out;
+
+ if (connman_technology_driver_register(&tech_driver) < 0) {
+ connman_warn("Failed to initialize technology for Bluez 5");
+ goto out;
+ }
+
+ devices = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
+ device_free);
+
+ if (connman_device_driver_register(&device_driver) < 0) {
+ connman_warn("Failed to initialize device driver for "
+ BLUEZ_SERVICE);
+ connman_technology_driver_unregister(&tech_driver);
+ goto out;
+ }
+
+ if (connman_network_driver_register(&network_driver) < 0) {
+ connman_technology_driver_unregister(&tech_driver);
+ connman_device_driver_unregister(&device_driver);
+ goto out;
+ }
+
+ networks = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
+ pan_free);
+
+ client = g_dbus_client_new(connection, BLUEZ_SERVICE, BLUEZ_PATH);
+ if (!client) {
+ connman_warn("Failed to initialize D-Bus client for "
+ BLUEZ_SERVICE);
+ goto out;
+ }
+
+ g_dbus_client_set_proxy_handlers(client, object_added, object_removed,
+ NULL, NULL);
+
+ return 0;
+
+out:
+ if (networks)
+ g_hash_table_destroy(networks);
+
+ if (devices)
+ g_hash_table_destroy(devices);
+
+ if (client)
+ g_dbus_client_unref(client);
+
+ if (connection)
+ dbus_connection_unref(connection);
+
+ return -EIO;
+}
+
+static void bluetooth_exit(void)
+{
+ /*
+ * We unset the disabling of the Bluetooth device when shutting down
+ * so that non-PAN BT connections are not affected.
+ */
+ device_driver.disable = NULL;
+
+ g_dbus_client_unref(client);
+
+ connman_network_driver_unregister(&network_driver);
+ g_hash_table_destroy(networks);
+
+ connman_device_driver_unregister(&device_driver);
+ g_hash_table_destroy(devices);
+
+ connman_technology_driver_unregister(&tech_driver);
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(bluetooth, "Bluetooth technology plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, bluetooth_init, bluetooth_exit)
diff --git a/plugins/bluetooth_legacy.c b/plugins/bluetooth_legacy.c
new file mode 100644
index 0000000..62c89e1
--- /dev/null
+++ b/plugins/bluetooth_legacy.c
@@ -0,0 +1,1385 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <netinet/ether.h>
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/technology.h>
+#include <connman/device.h>
+#include <connman/inet.h>
+#include <connman/dbus.h>
+#include <connman/log.h>
+
+#define BLUEZ_SERVICE "org.bluez"
+#define BLUEZ_MANAGER_INTERFACE BLUEZ_SERVICE ".Manager"
+#define BLUEZ_ADAPTER_INTERFACE BLUEZ_SERVICE ".Adapter"
+#define BLUEZ_DEVICE_INTERFACE BLUEZ_SERVICE ".Device"
+#define BLUEZ_NETWORK_INTERFACE BLUEZ_SERVICE ".Network"
+#define BLUEZ_NETWORK_SERVER BLUEZ_SERVICE ".NetworkServer"
+
+#define LIST_ADAPTERS "ListAdapters"
+#define ADAPTER_ADDED "AdapterAdded"
+#define ADAPTER_REMOVED "AdapterRemoved"
+#define DEVICE_REMOVED "DeviceRemoved"
+
+#define PROPERTY_CHANGED "PropertyChanged"
+#define GET_PROPERTIES "GetProperties"
+#define SET_PROPERTY "SetProperty"
+
+#define CONNECT "Connect"
+#define DISCONNECT "Disconnect"
+
+#define REGISTER "Register"
+#define UNREGISTER "Unregister"
+
+#define UUID_NAP "00001116-0000-1000-8000-00805f9b34fb"
+
+#define TIMEOUT 60000
+
+static DBusConnection *connection;
+
+static GHashTable *bluetooth_devices = NULL;
+static GHashTable *bluetooth_networks = NULL;
+static GHashTable *pending_networks = NULL;
+
+static int pan_probe(struct connman_network *network)
+{
+ GHashTableIter iter;
+ gpointer key, val;
+
+ g_hash_table_iter_init(&iter, bluetooth_networks);
+ while (g_hash_table_iter_next(&iter, &key, &val)) {
+ struct connman_network *known = val;
+
+ if (network != known)
+ continue;
+
+ DBG("network %p", network);
+
+ return 0;
+ }
+
+ return -EOPNOTSUPP;
+}
+
+static void pan_remove(struct connman_network *network)
+{
+ DBG("network %p", network);
+}
+
+static void connect_reply(DBusPendingCall *call, void *user_data)
+{
+ char *path = user_data;
+ struct connman_network *network;
+ DBusMessage *reply;
+ DBusError error;
+ const char *interface = NULL;
+ int index;
+
+ network = g_hash_table_lookup(bluetooth_networks, path);
+ if (!network)
+ return;
+
+ DBG("network %p", network);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+
+ goto err;
+ }
+
+ if (!dbus_message_get_args(reply, &error, DBUS_TYPE_STRING,
+ &interface, DBUS_TYPE_INVALID)) {
+ if (dbus_error_is_set(&error)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ } else
+ connman_error("Wrong arguments for connect");
+ goto err;
+ }
+
+ if (!interface)
+ goto err;
+
+ DBG("interface %s", interface);
+
+ index = connman_inet_ifindex(interface);
+
+ connman_network_set_index(network, index);
+
+ connman_network_set_connected(network, true);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+
+ return;
+err:
+
+ connman_network_set_connected(network, false);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int pan_connect(struct connman_network *network)
+{
+ const char *path = connman_network_get_string(network, "Path");
+ const char *uuid = "nap";
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("network %p", network);
+
+ if (!path)
+ return -EINVAL;
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
+ BLUEZ_NETWORK_INTERFACE, CONNECT);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &uuid,
+ DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT * 10)) {
+ connman_error("Failed to connect service");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, connect_reply, g_strdup(path),
+ g_free);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static void disconnect_reply(DBusPendingCall *call, void *user_data)
+{
+ char *path = user_data;
+ struct connman_network *network;
+ DBusMessage *reply;
+ DBusError error;
+
+ network = g_hash_table_lookup(bluetooth_networks, path);
+ if (!network)
+ return;
+
+ DBG("network %p", network);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_get_args(reply, &error, DBUS_TYPE_INVALID)) {
+ if (dbus_error_is_set(&error)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ } else
+ connman_error("Wrong arguments for disconnect");
+ goto done;
+ }
+
+ connman_network_set_connected(network, false);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+
+ connman_network_unref(network);
+}
+
+static int pan_disconnect(struct connman_network *network, bool user_initiated)
+{
+ const char *path = connman_network_get_string(network, "Path");
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("network %p", network);
+
+ if (!path)
+ return -EINVAL;
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
+ BLUEZ_NETWORK_INTERFACE, DISCONNECT);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_append_args(message, DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ connman_error("Failed to disconnect service");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ connman_network_ref(network);
+
+ connman_network_set_associating(network, false);
+
+ dbus_pending_call_set_notify(call, disconnect_reply, g_strdup(path),
+ g_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+static struct connman_network_driver pan_driver = {
+ .name = "bluetooth_legacy-pan",
+ .type = CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN,
+ .priority = CONNMAN_NETWORK_PRIORITY_LOW,
+ .probe = pan_probe,
+ .remove = pan_remove,
+ .connect = pan_connect,
+ .disconnect = pan_disconnect,
+};
+
+static gboolean network_changed(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct connman_network *network;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ DBG("path %s", path);
+
+ network = g_hash_table_lookup(bluetooth_networks, path);
+ if (!network)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Connected")) {
+ dbus_bool_t connected;
+
+ dbus_message_iter_get_basic(&value, &connected);
+
+ if (connected)
+ return TRUE;
+
+ connman_network_set_associating(network, false);
+ connman_network_set_connected(network, false);
+ }
+
+ return TRUE;
+}
+
+static void extract_properties(DBusMessage *reply, const char **parent,
+ const char **address,
+ const char **name,
+ const char **alias,
+ dbus_bool_t *powered,
+ dbus_bool_t *scanning,
+ DBusMessageIter *uuids,
+ DBusMessageIter *networks)
+{
+ DBusMessageIter array, dict;
+
+ if (!dbus_message_iter_init(reply, &array))
+ return;
+
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Adapter")) {
+ if (parent)
+ dbus_message_iter_get_basic(&value, parent);
+ } else if (g_str_equal(key, "Address")) {
+ if (address)
+ dbus_message_iter_get_basic(&value, address);
+ } else if (g_str_equal(key, "Name")) {
+ if (name)
+ dbus_message_iter_get_basic(&value, name);
+ } else if (g_str_equal(key, "Alias")) {
+ if (alias)
+ dbus_message_iter_get_basic(&value, alias);
+ } else if (g_str_equal(key, "Powered")) {
+ if (powered)
+ dbus_message_iter_get_basic(&value, powered);
+ } else if (g_str_equal(key, "Discovering")) {
+ if (scanning)
+ dbus_message_iter_get_basic(&value, scanning);
+ } else if (g_str_equal(key, "Devices")) {
+ if (networks)
+ memcpy(networks, &value, sizeof(value));
+ } else if (g_str_equal(key, "UUIDs")) {
+ if (uuids)
+ memcpy(uuids, &value, sizeof(value));
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+}
+
+static dbus_bool_t has_pan(DBusMessageIter *array)
+{
+ DBusMessageIter value;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return FALSE;
+
+ dbus_message_iter_recurse(array, &value);
+
+ while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING) {
+ const char *uuid;
+
+ dbus_message_iter_get_basic(&value, &uuid);
+
+ if (g_strcmp0(uuid, UUID_NAP) == 0)
+ return TRUE;
+
+ dbus_message_iter_next(&value);
+ }
+
+ return FALSE;
+}
+
+static void network_properties_reply(DBusPendingCall *call, void *user_data)
+{
+ char *path = user_data;
+ struct connman_device *device;
+ struct connman_network *network;
+ DBusMessage *reply;
+ DBusMessageIter uuids;
+ const char *parent = NULL, *address = NULL, *name = NULL;
+ struct ether_addr addr;
+ char ident[13];
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ extract_properties(reply, &parent, &address, NULL, &name,
+ NULL, NULL, &uuids, NULL);
+
+ if (!parent)
+ goto done;
+
+ device = g_hash_table_lookup(bluetooth_devices, parent);
+ if (!device)
+ goto done;
+
+ if (!address)
+ goto done;
+
+ ether_aton_r(address, &addr);
+
+ snprintf(ident, 13, "%02x%02x%02x%02x%02x%02x",
+ addr.ether_addr_octet[0],
+ addr.ether_addr_octet[1],
+ addr.ether_addr_octet[2],
+ addr.ether_addr_octet[3],
+ addr.ether_addr_octet[4],
+ addr.ether_addr_octet[5]);
+
+ if (!has_pan(&uuids))
+ goto done;
+
+ network = connman_device_get_network(device, ident);
+ if (network)
+ goto done;
+
+ network = connman_network_create(ident,
+ CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN);
+ if (!network)
+ goto done;
+
+ connman_network_set_string(network, "Path", path);
+
+ connman_network_set_name(network, name);
+
+ g_hash_table_replace(bluetooth_networks, g_strdup(path), network);
+
+ connman_device_add_network(device, network);
+
+ connman_network_set_group(network, ident);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static void add_network(const char *path)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("path %s", path);
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
+ BLUEZ_DEVICE_INTERFACE, GET_PROPERTIES);
+ if (!message)
+ return;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ connman_error("Failed to get network properties for %s", path);
+ goto done;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ goto done;
+ }
+
+ dbus_pending_call_set_notify(call, network_properties_reply,
+ g_strdup(path), g_free);
+
+done:
+ dbus_message_unref(message);
+}
+
+static void check_networks(DBusMessageIter *array)
+{
+ DBusMessageIter value;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(array, &value);
+
+ while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_OBJECT_PATH) {
+ const char *path;
+
+ dbus_message_iter_get_basic(&value, &path);
+
+ add_network(path);
+
+ dbus_message_iter_next(&value);
+ }
+}
+
+static void check_pending_networks(const char *adapter)
+{
+ GSList *networks, *list;
+
+ networks = g_hash_table_lookup(pending_networks, adapter);
+ if (!networks)
+ return;
+
+ for (list = networks; list; list = list->next) {
+ char *path = list->data;
+
+ add_network(path);
+ }
+
+ g_hash_table_remove(pending_networks, adapter);
+}
+
+static gboolean adapter_changed(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct connman_device *device;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ DBG("path %s", path);
+
+ device = g_hash_table_lookup(bluetooth_devices, path);
+ if (!device)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Powered")) {
+ dbus_bool_t val;
+
+ dbus_message_iter_get_basic(&value, &val);
+ connman_device_set_powered(device, val);
+ if (val)
+ check_pending_networks(path);
+ } else if (g_str_equal(key, "Discovering")) {
+ dbus_bool_t val;
+
+ dbus_message_iter_get_basic(&value, &val);
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_BLUETOOTH, val);
+ } else if (g_str_equal(key, "Devices")) {
+ check_networks(&value);
+ }
+
+ return TRUE;
+}
+
+static gboolean device_removed(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ const char *network_path;
+ struct connman_network *network;
+ struct connman_device *device;
+ DBusMessageIter iter;
+
+ DBG("");
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &network_path);
+
+ network = g_hash_table_lookup(bluetooth_networks, network_path);
+ if (!network)
+ return TRUE;
+
+ device = connman_network_get_device(network);
+ if (!device)
+ return TRUE;
+
+ g_hash_table_remove(bluetooth_networks, network_path);
+
+ return TRUE;
+}
+
+static gboolean device_changed(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ DBusMessageIter iter, value;
+ const char *key;
+
+ DBG("path %s", path);
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ DBG("key %s", key);
+
+ if (g_str_equal(key, "UUIDs"))
+ add_network(path);
+
+ return TRUE;
+}
+
+static void remove_device_networks(struct connman_device *device)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ GSList *key_list = NULL;
+ GSList *list;
+
+ if (!bluetooth_networks)
+ return;
+
+ g_hash_table_iter_init(&iter, bluetooth_networks);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_network *network = value;
+
+ if (connman_network_get_device(network) != device)
+ continue;
+
+ key_list = g_slist_prepend(key_list, key);
+ }
+
+ for (list = key_list; list; list = list->next) {
+ const char *network_path = list->data;
+
+ g_hash_table_remove(bluetooth_networks, network_path);
+ }
+
+ g_slist_free(key_list);
+}
+
+static void add_pending_networks(const char *adapter, DBusMessageIter *array)
+{
+ DBusMessageIter value;
+ GSList *list = NULL;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(array, &value);
+
+ while (dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_OBJECT_PATH) {
+ const char *path;
+
+ dbus_message_iter_get_basic(&value, &path);
+
+ list = g_slist_prepend(list, g_strdup(path));
+
+ dbus_message_iter_next(&value);
+ }
+
+ if (!list)
+ return;
+
+ g_hash_table_replace(pending_networks, g_strdup(adapter), list);
+}
+
+static void adapter_properties_reply(DBusPendingCall *call, void *user_data)
+{
+ char *path = user_data;
+ struct connman_device *device;
+ DBusMessage *reply;
+ DBusMessageIter networks;
+ const char *address = NULL, *name = NULL;
+ dbus_bool_t powered = FALSE, scanning = FALSE;
+ struct ether_addr addr;
+ char ident[13];
+
+ DBG("path %s", path);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (!path)
+ goto done;
+
+ extract_properties(reply, NULL, &address, &name, NULL,
+ &powered, &scanning, NULL, &networks);
+
+ if (!address)
+ goto done;
+
+ if (g_strcmp0(address, "00:00:00:00:00:00") == 0)
+ goto done;
+
+ device = g_hash_table_lookup(bluetooth_devices, path);
+ if (device)
+ goto update;
+
+ ether_aton_r(address, &addr);
+
+ snprintf(ident, 13, "%02x%02x%02x%02x%02x%02x",
+ addr.ether_addr_octet[0],
+ addr.ether_addr_octet[1],
+ addr.ether_addr_octet[2],
+ addr.ether_addr_octet[3],
+ addr.ether_addr_octet[4],
+ addr.ether_addr_octet[5]);
+
+ device = connman_device_create("bluetooth_legacy",
+ CONNMAN_DEVICE_TYPE_BLUETOOTH);
+ if (!device)
+ goto done;
+
+ g_hash_table_insert(bluetooth_devices, g_strdup(path), device);
+
+ connman_device_set_ident(device, ident);
+
+ connman_device_set_string(device, "Path", path);
+
+ if (connman_device_register(device) < 0) {
+ connman_device_unref(device);
+ g_hash_table_remove(bluetooth_devices, path);
+ goto done;
+ }
+
+update:
+ connman_device_set_string(device, "Address", address);
+ connman_device_set_string(device, "Name", name);
+ connman_device_set_string(device, "Path", path);
+
+ connman_device_set_powered(device, powered);
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_BLUETOOTH, scanning);
+
+ if (!powered) {
+ remove_device_networks(device);
+ add_pending_networks(path, &networks);
+ } else
+ check_networks(&networks);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static void add_adapter(DBusConnection *conn, const char *path)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("path %s", path);
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
+ BLUEZ_ADAPTER_INTERFACE, GET_PROPERTIES);
+ if (!message)
+ return;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ if (!dbus_connection_send_with_reply(conn, message, &call, TIMEOUT)) {
+ connman_error("Failed to get adapter properties for %s", path);
+ goto done;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ goto done;
+ }
+
+ dbus_pending_call_set_notify(call, adapter_properties_reply,
+ g_strdup(path), g_free);
+
+done:
+ dbus_message_unref(message);
+}
+
+static gboolean adapter_added(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path;
+
+ dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+ add_adapter(conn, path);
+ return TRUE;
+}
+
+static void remove_adapter(DBusConnection *conn, const char *path)
+{
+ DBG("path %s", path);
+
+ g_hash_table_remove(bluetooth_devices, path);
+ g_hash_table_remove(pending_networks, path);
+}
+
+static gboolean adapter_removed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path;
+
+ dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+ remove_adapter(conn, path);
+ return TRUE;
+}
+
+static void list_adapters_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+ char **adapters;
+ int i, num_adapters;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_get_args(reply, &error, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_OBJECT_PATH, &adapters,
+ &num_adapters, DBUS_TYPE_INVALID)) {
+ if (dbus_error_is_set(&error)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ } else
+ connman_error("Wrong arguments for adapter list");
+ goto done;
+ }
+
+ for (i = 0; i < num_adapters; i++)
+ add_adapter(connection, adapters[i]);
+
+ g_strfreev(adapters);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static void unregister_device(gpointer data)
+{
+ struct connman_device *device = data;
+
+ DBG("");
+
+ remove_device_networks(device);
+
+ connman_device_unregister(device);
+ connman_device_unref(device);
+}
+
+static void remove_network(gpointer data)
+{
+ struct connman_network *network = data;
+ struct connman_device *device;
+
+ DBG("network %p", network);
+
+ device = connman_network_get_device(network);
+ if (device)
+ connman_device_remove_network(device, network);
+
+ connman_network_unref(network);
+}
+
+static void remove_pending_networks(gpointer data)
+{
+ GSList *list = data;
+
+ g_slist_free_full(list, g_free);
+}
+
+static void bluetooth_connect(DBusConnection *conn, void *user_data)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("connection %p", conn);
+
+ bluetooth_devices = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, unregister_device);
+
+ bluetooth_networks = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, remove_network);
+
+ pending_networks = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, remove_pending_networks);
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, "/",
+ BLUEZ_MANAGER_INTERFACE, LIST_ADAPTERS);
+ if (!message)
+ return;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ if (!dbus_connection_send_with_reply(conn, message, &call, TIMEOUT)) {
+ connman_error("Failed to get Bluetooth adapters");
+ goto done;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ goto done;
+ }
+
+ dbus_pending_call_set_notify(call, list_adapters_reply, NULL, NULL);
+
+done:
+ dbus_message_unref(message);
+}
+
+static void bluetooth_disconnect(DBusConnection *conn, void *user_data)
+{
+ DBG("connection %p", conn);
+
+ if (!bluetooth_devices)
+ return;
+
+ g_hash_table_destroy(bluetooth_networks);
+ bluetooth_networks = NULL;
+ g_hash_table_destroy(bluetooth_devices);
+ bluetooth_devices = NULL;
+ g_hash_table_destroy(pending_networks);
+ pending_networks = NULL;
+}
+
+static int bluetooth_probe(struct connman_device *device)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ DBG("device %p", device);
+
+ if (!bluetooth_devices)
+ return -ENOTSUP;
+
+ g_hash_table_iter_init(&iter, bluetooth_devices);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_device *device_pan = value;
+
+ if (device == device_pan)
+ return 0;
+ }
+
+ return -ENOTSUP;
+}
+
+static void bluetooth_remove(struct connman_device *device)
+{
+ DBG("device %p", device);
+}
+
+static void powered_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusError error;
+ DBusMessage *reply;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(call);
+ return;
+ }
+
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(call);
+
+ add_adapter(connection, user_data);
+}
+
+static int change_powered(DBusConnection *conn, const char *path,
+ dbus_bool_t powered)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+ DBusPendingCall *call;
+
+ DBG("");
+
+ if (!path)
+ return -EINVAL;
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
+ BLUEZ_ADAPTER_INTERFACE, SET_PROPERTY);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_iter_init_append(message, &iter);
+ connman_dbus_property_append_basic(&iter, "Powered",
+ DBUS_TYPE_BOOLEAN, &powered);
+
+ if (!dbus_connection_send_with_reply(conn, message, &call, TIMEOUT)) {
+ connman_error("Failed to change Powered property");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, powered_reply,
+ g_strdup(path), g_free);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static int bluetooth_enable(struct connman_device *device)
+{
+ const char *path = connman_device_get_string(device, "Path");
+
+ DBG("device %p", device);
+
+ return change_powered(connection, path, TRUE);
+}
+
+static int bluetooth_disable(struct connman_device *device)
+{
+ const char *path = connman_device_get_string(device, "Path");
+
+ DBG("device %p", device);
+
+ return change_powered(connection, path, FALSE);
+}
+
+static struct connman_device_driver bluetooth_driver = {
+ .name = "bluetooth_legacy",
+ .type = CONNMAN_DEVICE_TYPE_BLUETOOTH,
+ .probe = bluetooth_probe,
+ .remove = bluetooth_remove,
+ .enable = bluetooth_enable,
+ .disable = bluetooth_disable,
+};
+
+static int tech_probe(struct connman_technology *technology)
+{
+ return 0;
+}
+
+static void tech_remove(struct connman_technology *technology)
+{
+}
+
+static void server_register_reply(DBusPendingCall *call, void *user_data)
+{
+ struct connman_technology *technology = user_data;
+ DBusError error;
+ DBusMessage *reply;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(call);
+ return;
+ }
+
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(call);
+
+ connman_technology_tethering_notify(technology, true);
+}
+
+static void server_unregister_reply(DBusPendingCall *call, void *user_data)
+{
+ struct connman_technology *technology = user_data;
+ DBusError error;
+ DBusMessage *reply;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(call);
+ return;
+ }
+
+ dbus_message_unref(reply);
+ dbus_pending_call_unref(call);
+
+ connman_technology_tethering_notify(technology, false);
+}
+
+
+static void server_register(const char *path, const char *uuid,
+ struct connman_technology *technology,
+ const char *bridge, bool enabled)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+ char *command;
+
+ DBG("path %s enabled %d", path, enabled);
+
+ command = enabled ? REGISTER : UNREGISTER;
+
+ message = dbus_message_new_method_call(BLUEZ_SERVICE, path,
+ BLUEZ_NETWORK_SERVER, command);
+ if (!message)
+ return;
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &uuid,
+ DBUS_TYPE_INVALID);
+
+ if (enabled)
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &bridge,
+ DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ connman_error("Failed to enable PAN server");
+ dbus_message_unref(message);
+ return;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return;
+ }
+
+ if (enabled)
+ dbus_pending_call_set_notify(call, server_register_reply,
+ technology, NULL);
+ else
+ dbus_pending_call_set_notify(call, server_unregister_reply,
+ technology, NULL);
+
+ dbus_message_unref(message);
+}
+
+struct tethering_info {
+ struct connman_technology *technology;
+ const char *bridge;
+};
+
+static void enable_nap(gpointer key, gpointer value, gpointer user_data)
+{
+ struct tethering_info *info = user_data;
+ struct connman_device *device = value;
+ const char *path;
+
+ DBG("");
+
+ path = connman_device_get_string(device, "Path");
+
+ server_register(path, "nap", info->technology, info->bridge, true);
+}
+
+static void disable_nap(gpointer key, gpointer value, gpointer user_data)
+{
+ struct tethering_info *info = user_data;
+ struct connman_device *device = value;
+ const char *path;
+
+ DBG("");
+
+ path = connman_device_get_string(device, "Path");
+
+ server_register(path, "nap", info->technology, info->bridge, false);
+}
+
+static int tech_set_tethering(struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled)
+{
+ struct tethering_info info = {
+ .technology = technology,
+ .bridge = bridge,
+ };
+
+ DBG("bridge %s", bridge);
+
+ if (!bluetooth_devices)
+ return -ENOTCONN;
+
+ if (enabled)
+ g_hash_table_foreach(bluetooth_devices, enable_nap, &info);
+ else
+ g_hash_table_foreach(bluetooth_devices, disable_nap, &info);
+
+ return 0;
+}
+
+static struct connman_technology_driver tech_driver = {
+ .name = "bluetooth_legacy",
+ .type = CONNMAN_SERVICE_TYPE_BLUETOOTH,
+ .priority = -10,
+ .probe = tech_probe,
+ .remove = tech_remove,
+ .set_tethering = tech_set_tethering,
+};
+
+static guint watch;
+static guint added_watch;
+static guint removed_watch;
+static guint adapter_watch;
+static guint device_watch;
+static guint device_removed_watch;
+static guint network_watch;
+
+static int bluetooth_init(void)
+{
+ int err;
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ watch = g_dbus_add_service_watch(connection, BLUEZ_SERVICE,
+ bluetooth_connect, bluetooth_disconnect, NULL, NULL);
+
+ added_watch = g_dbus_add_signal_watch(connection, BLUEZ_SERVICE, NULL,
+ BLUEZ_MANAGER_INTERFACE,
+ ADAPTER_ADDED, adapter_added,
+ NULL, NULL);
+
+ removed_watch = g_dbus_add_signal_watch(connection, BLUEZ_SERVICE, NULL,
+ BLUEZ_MANAGER_INTERFACE,
+ ADAPTER_REMOVED, adapter_removed,
+ NULL, NULL);
+
+ adapter_watch = g_dbus_add_signal_watch(connection, BLUEZ_SERVICE,
+ NULL, BLUEZ_ADAPTER_INTERFACE,
+ PROPERTY_CHANGED, adapter_changed,
+ NULL, NULL);
+
+ device_removed_watch = g_dbus_add_signal_watch(connection,
+ BLUEZ_SERVICE, NULL,
+ BLUEZ_ADAPTER_INTERFACE,
+ DEVICE_REMOVED, device_removed,
+ NULL, NULL);
+
+ device_watch = g_dbus_add_signal_watch(connection, BLUEZ_SERVICE, NULL,
+ BLUEZ_DEVICE_INTERFACE,
+ PROPERTY_CHANGED, device_changed,
+ NULL, NULL);
+
+ network_watch = g_dbus_add_signal_watch(connection, BLUEZ_SERVICE,
+ NULL, BLUEZ_NETWORK_INTERFACE,
+ PROPERTY_CHANGED, network_changed,
+ NULL, NULL);
+
+ if (watch == 0 || added_watch == 0 || removed_watch == 0
+ || adapter_watch == 0 || network_watch == 0
+ || device_watch == 0
+ || device_removed_watch == 0) {
+ err = -EIO;
+ goto remove;
+ }
+
+ err = connman_network_driver_register(&pan_driver);
+ if (err < 0)
+ goto remove;
+
+ err = connman_device_driver_register(&bluetooth_driver);
+ if (err < 0) {
+ connman_network_driver_unregister(&pan_driver);
+ goto remove;
+ }
+
+ err = connman_technology_driver_register(&tech_driver);
+ if (err < 0) {
+ connman_device_driver_unregister(&bluetooth_driver);
+ connman_network_driver_unregister(&pan_driver);
+ goto remove;
+ }
+
+ return 0;
+
+remove:
+ g_dbus_remove_watch(connection, watch);
+ g_dbus_remove_watch(connection, added_watch);
+ g_dbus_remove_watch(connection, removed_watch);
+ g_dbus_remove_watch(connection, adapter_watch);
+ g_dbus_remove_watch(connection, device_removed_watch);
+ g_dbus_remove_watch(connection, device_watch);
+ g_dbus_remove_watch(connection, network_watch);
+
+ dbus_connection_unref(connection);
+
+ return err;
+}
+
+static void bluetooth_exit(void)
+{
+ g_dbus_remove_watch(connection, watch);
+ g_dbus_remove_watch(connection, added_watch);
+ g_dbus_remove_watch(connection, removed_watch);
+ g_dbus_remove_watch(connection, adapter_watch);
+ g_dbus_remove_watch(connection, device_removed_watch);
+ g_dbus_remove_watch(connection, device_watch);
+ g_dbus_remove_watch(connection, network_watch);
+
+ /*
+ * We unset the disabling of the Bluetooth device when shutting down
+ * so that non-PAN BT connections are not affected.
+ */
+ bluetooth_driver.disable = NULL;
+
+ bluetooth_disconnect(connection, NULL);
+
+ connman_technology_driver_unregister(&tech_driver);
+
+ connman_device_driver_unregister(&bluetooth_driver);
+ connman_network_driver_unregister(&pan_driver);
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(bluetooth_legacy, "Bluetooth technology plugin (legacy)",
+ VERSION, CONNMAN_PLUGIN_PRIORITY_LOW,
+ bluetooth_init, bluetooth_exit)
diff --git a/plugins/connman-nmcompat.conf b/plugins/connman-nmcompat.conf
new file mode 100644
index 0000000..5887a34
--- /dev/null
+++ b/plugins/connman-nmcompat.conf
@@ -0,0 +1,14 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <policy user="root">
+ <allow own="org.freedesktop.NetworkManager"/>
+ <allow send_destination="org.freedesktop.NetworkManager"/>
+ </policy>
+ <policy at_console="true">
+ <allow send_destination="org.freedesktop.NetworkManager"/>
+ </policy>
+ <policy context="default">
+ <deny send_destination="org.freedesktop.NetworkManager"/>
+ </policy>
+</busconfig>
diff --git a/plugins/dundee.c b/plugins/dundee.c
new file mode 100644
index 0000000..fd4e1eb
--- /dev/null
+++ b/plugins/dundee.c
@@ -0,0 +1,886 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/device.h>
+#include <connman/network.h>
+#include <connman/service.h>
+#include <connman/inet.h>
+#include <connman/dbus.h>
+
+#define DUNDEE_SERVICE "org.ofono.dundee"
+#define DUNDEE_MANAGER_INTERFACE DUNDEE_SERVICE ".Manager"
+#define DUNDEE_DEVICE_INTERFACE DUNDEE_SERVICE ".Device"
+
+#define DEVICE_ADDED "DeviceAdded"
+#define DEVICE_REMOVED "DeviceRemoved"
+#define PROPERTY_CHANGED "PropertyChanged"
+
+#define GET_PROPERTIES "GetProperties"
+#define SET_PROPERTY "SetProperty"
+#define GET_DEVICES "GetDevices"
+
+#define TIMEOUT 60000
+
+static DBusConnection *connection;
+
+static GHashTable *dundee_devices = NULL;
+
+struct dundee_data {
+ char *path;
+ char *name;
+
+ struct connman_device *device;
+ struct connman_network *network;
+
+ bool active;
+
+ int index;
+
+ /* IPv4 Settings */
+ enum connman_ipconfig_method method;
+ struct connman_ipaddress *address;
+ char *nameservers;
+
+ DBusPendingCall *call;
+};
+
+static char *get_ident(const char *path)
+{
+ char *pos;
+
+ if (*path != '/')
+ return NULL;
+
+ pos = strrchr(path, '/');
+ if (!pos)
+ return NULL;
+
+ return pos + 1;
+}
+
+static int create_device(struct dundee_data *info)
+{
+ struct connman_device *device;
+ char *ident;
+ int err;
+
+ DBG("%s", info->path);
+
+ ident = g_strdup(get_ident(info->path));
+ device = connman_device_create("dundee", CONNMAN_DEVICE_TYPE_BLUETOOTH);
+ if (!device) {
+ err = -ENOMEM;
+ goto out;
+ }
+
+ DBG("device %p", device);
+
+ connman_device_set_ident(device, ident);
+
+ connman_device_set_string(device, "Path", info->path);
+
+ connman_device_set_data(device, info);
+
+ err = connman_device_register(device);
+ if (err < 0) {
+ connman_error("Failed to register DUN device");
+ connman_device_unref(device);
+ goto out;
+ }
+
+ info->device = device;
+
+out:
+ g_free(ident);
+ return err;
+}
+
+static void destroy_device(struct dundee_data *info)
+{
+ connman_device_set_powered(info->device, false);
+
+ if (info->call)
+ dbus_pending_call_cancel(info->call);
+
+ if (info->network) {
+ connman_device_remove_network(info->device, info->network);
+ connman_network_unref(info->network);
+ info->network = NULL;
+ }
+
+ connman_device_unregister(info->device);
+ connman_device_unref(info->device);
+
+ info->device = NULL;
+}
+
+static void device_destroy(gpointer data)
+{
+ struct dundee_data *info = data;
+
+ if (info->device)
+ destroy_device(info);
+
+ g_free(info->path);
+ g_free(info->name);
+
+ g_free(info);
+}
+
+static int create_network(struct dundee_data *info)
+{
+ struct connman_network *network;
+ const char *group;
+ int err;
+
+ DBG("%s", info->path);
+
+ network = connman_network_create(info->path,
+ CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN);
+ if (!network)
+ return -ENOMEM;
+
+ DBG("network %p", network);
+
+ connman_network_set_data(network, info);
+
+ connman_network_set_string(network, "Path",
+ info->path);
+
+ connman_network_set_name(network, info->name);
+
+ group = get_ident(info->path);
+ connman_network_set_group(network, group);
+
+ err = connman_device_add_network(info->device, network);
+ if (err < 0) {
+ connman_network_unref(network);
+ return err;
+ }
+
+ info->network = network;
+
+ return 0;
+}
+
+static void set_connected(struct dundee_data *info)
+{
+ struct connman_service *service;
+
+ DBG("%s", info->path);
+
+ connman_inet_ifup(info->index);
+
+ service = connman_service_lookup_from_network(info->network);
+ if (!service)
+ return;
+
+ connman_service_create_ip4config(service, info->index);
+ connman_network_set_index(info->network, info->index);
+ connman_network_set_ipv4_method(info->network,
+ CONNMAN_IPCONFIG_METHOD_FIXED);
+ connman_network_set_ipaddress(info->network, info->address);
+ connman_network_set_nameservers(info->network, info->nameservers);
+
+ connman_network_set_connected(info->network, true);
+}
+
+static void set_disconnected(struct dundee_data *info)
+{
+ DBG("%s", info->path);
+
+ connman_network_set_connected(info->network, false);
+ connman_inet_ifdown(info->index);
+}
+
+static void set_property_reply(DBusPendingCall *call, void *user_data)
+{
+ struct dundee_data *info = user_data;
+ DBusMessage *reply;
+ DBusError error;
+
+ DBG("%s", info->path);
+
+ info->call = NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("Failed to change property: %s %s %s",
+ info->path, error.name, error.message);
+ dbus_error_free(&error);
+
+ connman_network_set_error(info->network,
+ CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
+ }
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int set_property(struct dundee_data *info,
+ const char *property, int type, void *value)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+
+ DBG("%s %s", info->path, property);
+
+ message = dbus_message_new_method_call(DUNDEE_SERVICE, info->path,
+ DUNDEE_DEVICE_INTERFACE, SET_PROPERTY);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+ connman_dbus_property_append_basic(&iter, property, type, value);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &info->call, TIMEOUT)) {
+ connman_error("Failed to change property: %s %s",
+ info->path, property);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!info->call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(info->call, set_property_reply,
+ info, NULL);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static int device_set_active(struct dundee_data *info)
+{
+ dbus_bool_t active = TRUE;
+
+ DBG("%s", info->path);
+
+ return set_property(info, "Active", DBUS_TYPE_BOOLEAN,
+ &active);
+}
+
+static int device_set_inactive(struct dundee_data *info)
+{
+ dbus_bool_t active = FALSE;
+ int err;
+
+ DBG("%s", info->path);
+
+ err = set_property(info, "Active", DBUS_TYPE_BOOLEAN,
+ &active);
+ if (err == -EINPROGRESS)
+ return 0;
+
+ return err;
+}
+
+static int network_probe(struct connman_network *network)
+{
+ DBG("network %p", network);
+
+ return 0;
+}
+
+static void network_remove(struct connman_network *network)
+{
+ DBG("network %p", network);
+}
+
+static int network_connect(struct connman_network *network)
+{
+ struct dundee_data *info = connman_network_get_data(network);
+
+ DBG("network %p", network);
+
+ return device_set_active(info);
+}
+
+static int network_disconnect(struct connman_network *network, bool user_initiated)
+{
+ struct dundee_data *info = connman_network_get_data(network);
+
+ DBG("network %p", network);
+
+ return device_set_inactive(info);
+}
+
+static struct connman_network_driver network_driver = {
+ .name = "network",
+ .type = CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN,
+ .probe = network_probe,
+ .remove = network_remove,
+ .connect = network_connect,
+ .disconnect = network_disconnect,
+};
+
+static int dundee_probe(struct connman_device *device)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ DBG("device %p", device);
+
+ if (!dundee_devices)
+ return -ENOTSUP;
+
+ g_hash_table_iter_init(&iter, dundee_devices);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct dundee_data *info = value;
+
+ if (device == info->device)
+ return 0;
+ }
+
+ return -ENOTSUP;
+}
+
+static void dundee_remove(struct connman_device *device)
+{
+ DBG("device %p", device);
+}
+
+static int dundee_enable(struct connman_device *device)
+{
+ DBG("device %p", device);
+
+ return 0;
+}
+
+static int dundee_disable(struct connman_device *device)
+{
+ DBG("device %p", device);
+
+ return 0;
+}
+
+static struct connman_device_driver dundee_driver = {
+ .name = "dundee",
+ .type = CONNMAN_DEVICE_TYPE_BLUETOOTH,
+ .probe = dundee_probe,
+ .remove = dundee_remove,
+ .enable = dundee_enable,
+ .disable = dundee_disable,
+};
+
+static char *extract_nameservers(DBusMessageIter *array)
+{
+ DBusMessageIter entry;
+ char *nameservers = NULL;
+ char *tmp;
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *nameserver;
+
+ dbus_message_iter_get_basic(&entry, &nameserver);
+
+ if (!nameservers) {
+ nameservers = g_strdup(nameserver);
+ } else {
+ tmp = nameservers;
+ nameservers = g_strdup_printf("%s %s", tmp, nameserver);
+ g_free(tmp);
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ return nameservers;
+}
+
+static void extract_settings(DBusMessageIter *array,
+ struct dundee_data *info)
+{
+ DBusMessageIter dict;
+ char *address = NULL, *gateway = NULL;
+ char *nameservers = NULL;
+ const char *interface = NULL;
+ int index = -1;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key, *val;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Interface")) {
+ dbus_message_iter_get_basic(&value, &interface);
+
+ DBG("Interface %s", interface);
+
+ index = connman_inet_ifindex(interface);
+
+ DBG("index %d", index);
+
+ if (index < 0)
+ break;
+ } else if (g_str_equal(key, "Address")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ address = g_strdup(val);
+
+ DBG("Address %s", address);
+ } else if (g_str_equal(key, "DomainNameServers")) {
+ nameservers = extract_nameservers(&value);
+
+ DBG("Nameservers %s", nameservers);
+ } else if (g_str_equal(key, "Gateway")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ gateway = g_strdup(val);
+
+ DBG("Gateway %s", gateway);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (index < 0)
+ goto out;
+
+ info->address = connman_ipaddress_alloc(CONNMAN_IPCONFIG_TYPE_IPV4);
+ if (!info->address)
+ goto out;
+
+ info->index = index;
+ connman_ipaddress_set_ipv4(info->address, address, NULL, gateway);
+
+ info->nameservers = nameservers;
+
+out:
+ if (info->nameservers != nameservers)
+ g_free(nameservers);
+
+ g_free(address);
+ g_free(gateway);
+}
+
+static gboolean device_changed(DBusConnection *conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct dundee_data *info = NULL;
+ DBusMessageIter iter, value;
+ const char *key;
+ const char *signature = DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING;
+
+ if (!dbus_message_has_signature(message, signature)) {
+ connman_error("dundee signature does not match");
+ return TRUE;
+ }
+
+ info = g_hash_table_lookup(dundee_devices, path);
+ if (!info)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ /*
+ * Dundee guarantees the ordering of Settings and
+ * Active. Settings will always be send before Active = True.
+ * That means we don't have to order here.
+ */
+ if (g_str_equal(key, "Active")) {
+ dbus_bool_t active;
+
+ dbus_message_iter_get_basic(&value, &active);
+ info->active = active;
+
+ DBG("%s Active %d", info->path, info->active);
+
+ if (info->active)
+ set_connected(info);
+ else
+ set_disconnected(info);
+ } else if (g_str_equal(key, "Settings")) {
+ DBG("%s Settings", info->path);
+
+ extract_settings(&value, info);
+ } else if (g_str_equal(key, "Name")) {
+ char *name;
+
+ dbus_message_iter_get_basic(&value, &name);
+
+ g_free(info->name);
+ info->name = g_strdup(name);
+
+ DBG("%s Name %s", info->path, info->name);
+
+ connman_network_set_name(info->network, info->name);
+ connman_network_update(info->network);
+ }
+
+ return TRUE;
+}
+
+static void add_device(const char *path, DBusMessageIter *properties)
+{
+ struct dundee_data *info;
+ int err;
+
+ info = g_hash_table_lookup(dundee_devices, path);
+ if (info)
+ return;
+
+ info = g_try_new0(struct dundee_data, 1);
+ if (!info)
+ return;
+
+ info->path = g_strdup(path);
+
+ while (dbus_message_iter_get_arg_type(properties) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(properties, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Active")) {
+ dbus_bool_t active;
+
+ dbus_message_iter_get_basic(&value, &active);
+ info->active = active;
+
+ DBG("%s Active %d", info->path, info->active);
+ } else if (g_str_equal(key, "Settings")) {
+ DBG("%s Settings", info->path);
+
+ extract_settings(&value, info);
+ } else if (g_str_equal(key, "Name")) {
+ char *name;
+
+ dbus_message_iter_get_basic(&value, &name);
+
+ info->name = g_strdup(name);
+
+ DBG("%s Name %s", info->path, info->name);
+ }
+
+ dbus_message_iter_next(properties);
+ }
+
+ g_hash_table_insert(dundee_devices, g_strdup(path), info);
+
+ err = create_device(info);
+ if (err < 0)
+ goto out;
+
+ err = create_network(info);
+ if (err < 0) {
+ destroy_device(info);
+ goto out;
+ }
+
+ if (info->active)
+ set_connected(info);
+
+ return;
+
+out:
+ g_hash_table_remove(dundee_devices, path);
+}
+
+static gboolean device_added(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ DBusMessageIter iter, properties;
+ const char *path;
+ const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
+
+ if (!dbus_message_has_signature(message, signature)) {
+ connman_error("dundee signature does not match");
+ return TRUE;
+ }
+
+ DBG("");
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &path);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &properties);
+
+ add_device(path, &properties);
+
+ return TRUE;
+}
+
+static void remove_device(DBusConnection *conn, const char *path)
+{
+ DBG("path %s", path);
+
+ g_hash_table_remove(dundee_devices, path);
+}
+
+static gboolean device_removed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path;
+ const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+
+ if (!dbus_message_has_signature(message, signature)) {
+ connman_error("dundee signature does not match");
+ return TRUE;
+ }
+
+ dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+ remove_device(conn, path);
+ return TRUE;
+}
+
+static void manager_get_devices_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+ DBusMessageIter array, dict;
+ const char *signature = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_OBJECT_PATH_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (!dbus_message_has_signature(reply, signature)) {
+ connman_error("dundee signature does not match");
+ goto done;
+ }
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_iter_init(reply, &array))
+ goto done;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter value, properties;
+ const char *path;
+
+ dbus_message_iter_recurse(&dict, &value);
+ dbus_message_iter_get_basic(&value, &path);
+
+ dbus_message_iter_next(&value);
+ dbus_message_iter_recurse(&value, &properties);
+
+ add_device(path, &properties);
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int manager_get_devices(void)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("");
+
+ message = dbus_message_new_method_call(DUNDEE_SERVICE, "/",
+ DUNDEE_MANAGER_INTERFACE, GET_DEVICES);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ connman_error("Failed to call GetDevices()");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, manager_get_devices_reply,
+ NULL, NULL);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static void dundee_connect(DBusConnection *conn, void *user_data)
+{
+ DBG("connection %p", conn);
+
+ dundee_devices = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, device_destroy);
+
+ manager_get_devices();
+}
+
+static void dundee_disconnect(DBusConnection *conn, void *user_data)
+{
+ DBG("connection %p", conn);
+
+ g_hash_table_destroy(dundee_devices);
+ dundee_devices = NULL;
+}
+
+static guint watch;
+static guint added_watch;
+static guint removed_watch;
+static guint device_watch;
+
+static int dundee_init(void)
+{
+ int err;
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ watch = g_dbus_add_service_watch(connection, DUNDEE_SERVICE,
+ dundee_connect, dundee_disconnect, NULL, NULL);
+
+ added_watch = g_dbus_add_signal_watch(connection, DUNDEE_SERVICE, NULL,
+ DUNDEE_MANAGER_INTERFACE,
+ DEVICE_ADDED, device_added,
+ NULL, NULL);
+
+ removed_watch = g_dbus_add_signal_watch(connection, DUNDEE_SERVICE,
+ NULL, DUNDEE_MANAGER_INTERFACE,
+ DEVICE_REMOVED, device_removed,
+ NULL, NULL);
+
+ device_watch = g_dbus_add_signal_watch(connection, DUNDEE_SERVICE,
+ NULL, DUNDEE_DEVICE_INTERFACE,
+ PROPERTY_CHANGED,
+ device_changed,
+ NULL, NULL);
+
+
+ if (watch == 0 || added_watch == 0 || removed_watch == 0 ||
+ device_watch == 0) {
+ err = -EIO;
+ goto remove;
+ }
+
+ err = connman_network_driver_register(&network_driver);
+ if (err < 0)
+ goto remove;
+
+ err = connman_device_driver_register(&dundee_driver);
+ if (err < 0) {
+ connman_network_driver_unregister(&network_driver);
+ goto remove;
+ }
+
+ return 0;
+
+remove:
+ g_dbus_remove_watch(connection, watch);
+ g_dbus_remove_watch(connection, added_watch);
+ g_dbus_remove_watch(connection, removed_watch);
+ g_dbus_remove_watch(connection, device_watch);
+
+ dbus_connection_unref(connection);
+
+ return err;
+}
+
+static void dundee_exit(void)
+{
+ g_dbus_remove_watch(connection, watch);
+ g_dbus_remove_watch(connection, added_watch);
+ g_dbus_remove_watch(connection, removed_watch);
+ g_dbus_remove_watch(connection, device_watch);
+
+ connman_device_driver_unregister(&dundee_driver);
+ connman_network_driver_unregister(&network_driver);
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(dundee, "Dundee plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, dundee_init, dundee_exit)
diff --git a/plugins/ethernet.c b/plugins/ethernet.c
new file mode 100644
index 0000000..64ef677
--- /dev/null
+++ b/plugins/ethernet.c
@@ -0,0 +1,413 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <net/if.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include <linux/if_vlan.h>
+#include <linux/sockios.h>
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/technology.h>
+#include <connman/plugin.h>
+#include <connman/device.h>
+#include <connman/inet.h>
+#include <connman/rtnl.h>
+#include <connman/log.h>
+#include <connman/setting.h>
+
+static bool eth_tethering = false;
+
+struct ethernet_data {
+ int index;
+ unsigned flags;
+ unsigned int watch;
+ struct connman_network *network;
+};
+
+
+static int get_vlan_vid(const char *ifname)
+{
+ struct vlan_ioctl_args vifr;
+ int vid;
+ int sk;
+
+ memset(&vifr, 0, sizeof(vifr));
+
+ sk = socket(AF_INET, SOCK_STREAM, 0);
+ if (sk < 0)
+ return -errno;
+
+ vifr.cmd = GET_VLAN_VID_CMD;
+ strncpy(vifr.device1, ifname, sizeof(vifr.device1));
+
+ if(ioctl(sk, SIOCSIFVLAN, &vifr) >= 0)
+ vid = vifr.u.VID;
+ else
+ vid = -errno;
+
+ close(sk);
+
+ return vid;
+}
+
+static int eth_network_probe(struct connman_network *network)
+{
+ DBG("network %p", network);
+
+ return 0;
+}
+
+static void eth_network_remove(struct connman_network *network)
+{
+ DBG("network %p", network);
+}
+
+static int eth_network_connect(struct connman_network *network)
+{
+ DBG("network %p", network);
+
+ connman_network_set_connected(network, true);
+
+ return 0;
+}
+
+static int eth_network_disconnect(struct connman_network *network, bool user_initiated)
+{
+ DBG("network %p", network);
+
+ connman_network_set_connected(network, false);
+
+ return 0;
+}
+
+static struct connman_network_driver eth_network_driver = {
+ .name = "cable",
+ .type = CONNMAN_NETWORK_TYPE_ETHERNET,
+ .probe = eth_network_probe,
+ .remove = eth_network_remove,
+ .connect = eth_network_connect,
+ .disconnect = eth_network_disconnect,
+};
+
+static void add_network(struct connman_device *device,
+ struct ethernet_data *ethernet)
+{
+ struct connman_network *network;
+ int index, vid;
+ char *ifname;
+
+ network = connman_network_create("carrier",
+ CONNMAN_NETWORK_TYPE_ETHERNET);
+ if (!network)
+ return;
+
+ index = connman_device_get_index(device);
+ connman_network_set_index(network, index);
+ ifname = connman_inet_ifname(index);
+ if (!ifname)
+ return;
+ vid = get_vlan_vid(ifname);
+
+ connman_network_set_name(network, "Wired");
+
+ if (connman_device_add_network(device, network) < 0) {
+ connman_network_unref(network);
+ return;
+ }
+
+ if (!eth_tethering) {
+ char group[10] = "cable";
+ /*
+ * Prevent service from starting the reconnect
+ * procedure as we do not want the DHCP client
+ * to run when tethering.
+ */
+ if (vid >= 0)
+ snprintf(group, sizeof(group), "%03x_cable", vid);
+
+ connman_network_set_group(network, group);
+ }
+
+ ethernet->network = network;
+ g_free(ifname);
+}
+
+static void remove_network(struct connman_device *device,
+ struct ethernet_data *ethernet)
+{
+ if (!ethernet->network)
+ return;
+
+ connman_device_remove_network(device, ethernet->network);
+ connman_network_unref(ethernet->network);
+
+ ethernet->network = NULL;
+}
+
+static void ethernet_newlink(unsigned flags, unsigned change, void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct ethernet_data *ethernet = connman_device_get_data(device);
+
+ DBG("index %d flags %d change %d", ethernet->index, flags, change);
+
+ if ((ethernet->flags & IFF_UP) != (flags & IFF_UP)) {
+ if (flags & IFF_UP) {
+ DBG("power on");
+ connman_device_set_powered(device, true);
+ } else {
+ DBG("power off");
+ connman_device_set_powered(device, false);
+ }
+ }
+
+ if ((ethernet->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
+ if (flags & IFF_LOWER_UP) {
+ DBG("carrier on");
+ add_network(device, ethernet);
+ } else {
+ DBG("carrier off");
+ remove_network(device, ethernet);
+ }
+ }
+
+ ethernet->flags = flags;
+}
+
+static int eth_dev_probe(struct connman_device *device)
+{
+ struct ethernet_data *ethernet;
+
+ DBG("device %p", device);
+
+ ethernet = g_try_new0(struct ethernet_data, 1);
+ if (!ethernet)
+ return -ENOMEM;
+
+ connman_device_set_data(device, ethernet);
+
+ ethernet->index = connman_device_get_index(device);
+ ethernet->flags = 0;
+
+ ethernet->watch = connman_rtnl_add_newlink_watch(ethernet->index,
+ ethernet_newlink, device);
+
+ return 0;
+}
+
+static void eth_dev_remove(struct connman_device *device)
+{
+ struct ethernet_data *ethernet = connman_device_get_data(device);
+
+ DBG("device %p", device);
+
+ connman_device_set_data(device, NULL);
+
+ connman_rtnl_remove_watch(ethernet->watch);
+
+ remove_network(device, ethernet);
+
+ g_free(ethernet);
+}
+
+static int eth_dev_enable(struct connman_device *device)
+{
+ struct ethernet_data *ethernet = connman_device_get_data(device);
+
+ DBG("device %p", device);
+
+ return connman_inet_ifup(ethernet->index);
+}
+
+static int eth_dev_disable(struct connman_device *device)
+{
+ struct ethernet_data *ethernet = connman_device_get_data(device);
+
+ DBG("device %p", device);
+
+ return connman_inet_ifdown(ethernet->index);
+}
+
+static struct connman_device_driver eth_dev_driver = {
+ .name = "ethernet",
+ .type = CONNMAN_DEVICE_TYPE_ETHERNET,
+ .probe = eth_dev_probe,
+ .remove = eth_dev_remove,
+ .enable = eth_dev_enable,
+ .disable = eth_dev_disable,
+};
+
+static int eth_tech_probe(struct connman_technology *technology)
+{
+ return 0;
+}
+
+static void eth_tech_remove(struct connman_technology *technology)
+{
+ DBG("");
+}
+
+static GList *eth_interface_list = NULL;
+
+static void eth_tech_add_interface(struct connman_technology *technology,
+ int index, const char *name, const char *ident)
+{
+ DBG("index %d name %s ident %s", index, name, ident);
+
+ if (g_list_find(eth_interface_list, GINT_TO_POINTER((int)index)))
+ return;
+
+ eth_interface_list = g_list_prepend(eth_interface_list,
+ (GINT_TO_POINTER((int) index)));
+}
+
+static void eth_tech_remove_interface(struct connman_technology *technology,
+ int index)
+{
+ DBG("index %d", index);
+
+ eth_interface_list = g_list_remove(eth_interface_list,
+ GINT_TO_POINTER((int) index));
+}
+
+static void eth_tech_enable_tethering(struct connman_technology *technology,
+ const char *bridge)
+{
+ GList *list;
+ struct ethernet_data *ethernet;
+
+ for (list = eth_interface_list; list; list = list->next) {
+ int index = GPOINTER_TO_INT(list->data);
+ struct connman_device *device =
+ connman_device_find_by_index(index);
+
+ if (device) {
+ ethernet = connman_device_get_data(device);
+ if (ethernet)
+ remove_network(device, ethernet);
+ }
+
+ connman_technology_tethering_notify(technology, true);
+
+ connman_inet_ifup(index);
+
+ connman_inet_add_to_bridge(index, bridge);
+
+ eth_tethering = true;
+ }
+}
+
+static void eth_tech_disable_tethering(struct connman_technology *technology,
+ const char *bridge)
+{
+ GList *list;
+
+ for (list = eth_interface_list; list; list = list->next) {
+ int index = GPOINTER_TO_INT(list->data);
+ struct connman_device *device =
+ connman_device_find_by_index(index);
+
+ connman_inet_remove_from_bridge(index, bridge);
+
+ connman_technology_tethering_notify(technology, false);
+
+ if (device)
+ connman_device_reconnect_service(device);
+
+ eth_tethering = false;
+ }
+}
+
+static int eth_tech_set_tethering(struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled)
+{
+ if (!connman_technology_is_tethering_allowed(
+ CONNMAN_SERVICE_TYPE_ETHERNET))
+ return 0;
+
+ DBG("bridge %s enabled %d", bridge, enabled);
+
+ if (enabled)
+ eth_tech_enable_tethering(technology, bridge);
+ else
+ eth_tech_disable_tethering(technology, bridge);
+
+ return 0;
+}
+
+static struct connman_technology_driver eth_tech_driver = {
+ .name = "ethernet",
+ .type = CONNMAN_SERVICE_TYPE_ETHERNET,
+ .probe = eth_tech_probe,
+ .remove = eth_tech_remove,
+ .add_interface = eth_tech_add_interface,
+ .remove_interface = eth_tech_remove_interface,
+ .set_tethering = eth_tech_set_tethering,
+};
+
+static int ethernet_init(void)
+{
+ int err;
+
+ err = connman_technology_driver_register(ð_tech_driver);
+ if (err < 0)
+ return err;
+
+ err = connman_network_driver_register(ð_network_driver);
+ if (err < 0)
+ return err;
+
+ err = connman_device_driver_register(ð_dev_driver);
+ if (err < 0) {
+ connman_network_driver_unregister(ð_network_driver);
+ return err;
+ }
+
+ return 0;
+}
+
+static void ethernet_exit(void)
+{
+ connman_technology_driver_unregister(ð_tech_driver);
+
+ connman_network_driver_unregister(ð_network_driver);
+
+ connman_device_driver_unregister(ð_dev_driver);
+}
+
+CONNMAN_PLUGIN_DEFINE(ethernet, "Ethernet interface plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, ethernet_init, ethernet_exit)
diff --git a/plugins/gadget.c b/plugins/gadget.c
new file mode 100644
index 0000000..40660e8
--- /dev/null
+++ b/plugins/gadget.c
@@ -0,0 +1,358 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <net/if.h>
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/technology.h>
+#include <connman/plugin.h>
+#include <connman/device.h>
+#include <connman/rtnl.h>
+#include <connman/inet.h>
+#include <connman/log.h>
+
+static bool gadget_tethering = false;
+
+struct gadget_data {
+ int index;
+ unsigned flags;
+ unsigned int watch;
+ struct connman_network *network;
+};
+
+static int gadget_network_probe(struct connman_network *network)
+{
+ DBG("network %p", network);
+
+ return 0;
+}
+
+static void gadget_network_remove(struct connman_network *network)
+{
+ DBG("network %p", network);
+}
+
+static int gadget_network_connect(struct connman_network *network)
+{
+ DBG("network %p", network);
+
+ connman_network_set_connected(network, true);
+
+ return 0;
+}
+
+static int gadget_network_disconnect(struct connman_network *network, bool user_initiated)
+{
+ DBG("network %p", network);
+
+ connman_network_set_connected(network, false);
+
+ return 0;
+}
+
+static struct connman_network_driver gadget_network_driver = {
+ .name = "usb",
+ .type = CONNMAN_NETWORK_TYPE_GADGET,
+ .probe = gadget_network_probe,
+ .remove = gadget_network_remove,
+ .connect = gadget_network_connect,
+ .disconnect = gadget_network_disconnect,
+};
+
+static void add_network(struct connman_device *device,
+ struct gadget_data *gadget)
+{
+ struct connman_network *network;
+ int index;
+
+ network = connman_network_create("gadget",
+ CONNMAN_NETWORK_TYPE_GADGET);
+ if (!network)
+ return;
+
+ index = connman_device_get_index(device);
+ connman_network_set_index(network, index);
+
+ connman_network_set_name(network, "Wired");
+
+ if (connman_device_add_network(device, network) < 0) {
+ connman_network_unref(network);
+ return;
+ }
+
+ if (!gadget_tethering)
+ /*
+ * Prevent service from starting the reconnect
+ * procedure as we do not want the DHCP client
+ * to run when tethering.
+ */
+ connman_network_set_group(network, "usb");
+
+ gadget->network = network;
+}
+
+static void remove_network(struct connman_device *device,
+ struct gadget_data *gadget)
+{
+ if (!gadget->network)
+ return;
+
+ connman_device_remove_network(device, gadget->network);
+ connman_network_unref(gadget->network);
+
+ gadget->network = NULL;
+}
+
+static void gadget_newlink(unsigned flags, unsigned change, void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct gadget_data *gadget = connman_device_get_data(device);
+
+ DBG("index %d flags %d change %d", gadget->index, flags, change);
+
+ if ((gadget->flags & IFF_UP) != (flags & IFF_UP)) {
+ if (flags & IFF_UP) {
+ DBG("power on");
+ connman_device_set_powered(device, true);
+ } else {
+ DBG("power off");
+ connman_device_set_powered(device, false);
+ }
+ }
+
+ if ((gadget->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
+ if (flags & IFF_LOWER_UP) {
+ DBG("carrier on");
+ add_network(device, gadget);
+ } else {
+ DBG("carrier off");
+ remove_network(device, gadget);
+ }
+ }
+
+ gadget->flags = flags;
+}
+
+static int gadget_dev_probe(struct connman_device *device)
+{
+ struct gadget_data *gadget;
+
+ DBG("device %p", device);
+
+ gadget = g_try_new0(struct gadget_data, 1);
+ if (!gadget)
+ return -ENOMEM;
+
+ connman_device_set_data(device, gadget);
+
+ gadget->index = connman_device_get_index(device);
+ gadget->flags = 0;
+
+ gadget->watch = connman_rtnl_add_newlink_watch(gadget->index,
+ gadget_newlink, device);
+
+ return 0;
+}
+
+static void gadget_dev_remove(struct connman_device *device)
+{
+ struct gadget_data *gadget = connman_device_get_data(device);
+
+ DBG("device %p", device);
+
+ connman_device_set_data(device, NULL);
+
+ connman_rtnl_remove_watch(gadget->watch);
+
+ remove_network(device, gadget);
+
+ g_free(gadget);
+}
+
+static int gadget_dev_enable(struct connman_device *device)
+{
+ struct gadget_data *gadget = connman_device_get_data(device);
+
+ DBG("device %p", device);
+
+ return connman_inet_ifup(gadget->index);
+}
+
+static int gadget_dev_disable(struct connman_device *device)
+{
+ struct gadget_data *gadget = connman_device_get_data(device);
+
+ DBG("device %p", device);
+
+ return connman_inet_ifdown(gadget->index);
+}
+
+static struct connman_device_driver gadget_dev_driver = {
+ .name = "gadget",
+ .type = CONNMAN_DEVICE_TYPE_GADGET,
+ .probe = gadget_dev_probe,
+ .remove = gadget_dev_remove,
+ .enable = gadget_dev_enable,
+ .disable = gadget_dev_disable,
+};
+
+static GList *cdc_interface_list = NULL;
+
+static void gadget_tech_add_interface(struct connman_technology *technology,
+ int index, const char *name, const char *ident)
+{
+ DBG("index %d name %s ident %s", index, name, ident);
+
+ if (g_list_find(cdc_interface_list, GINT_TO_POINTER((int)index)))
+ return;
+
+ cdc_interface_list = g_list_prepend(cdc_interface_list,
+ (GINT_TO_POINTER((int) index)));
+}
+
+static void gadget_tech_remove_interface(struct connman_technology *technology,
+ int index)
+{
+ DBG("index %d", index);
+
+ cdc_interface_list = g_list_remove(cdc_interface_list,
+ GINT_TO_POINTER((int) index));
+}
+
+static void gadget_tech_enable_tethering(struct connman_technology *technology,
+ const char *bridge)
+{
+ GList *list;
+
+ for (list = cdc_interface_list; list; list = list->next) {
+ int index = GPOINTER_TO_INT(list->data);
+ struct connman_device *device =
+ connman_device_find_by_index(index);
+ struct gadget_data *gadget;
+
+ if (device) {
+ gadget = connman_device_get_data(device);
+ if (gadget)
+ remove_network(device, gadget);
+ }
+
+ connman_technology_tethering_notify(technology, true);
+
+ connman_inet_ifup(index);
+
+ connman_inet_add_to_bridge(index, bridge);
+ }
+}
+
+static void gadget_tech_disable_tethering(struct connman_technology *technology,
+ const char *bridge)
+{
+ GList *list;
+
+ for (list = cdc_interface_list; list; list = list->next) {
+ int index = GPOINTER_TO_INT(list->data);
+
+ connman_inet_remove_from_bridge(index, bridge);
+
+ connman_inet_ifdown(index);
+
+ connman_technology_tethering_notify(technology, false);
+ }
+}
+
+static int gadget_tech_set_tethering(struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled)
+{
+ DBG("bridge %s enabled %d", bridge, enabled);
+
+ if (enabled)
+ gadget_tech_enable_tethering(technology, bridge);
+ else
+ gadget_tech_disable_tethering(technology, bridge);
+
+ return 0;
+}
+
+static int gadget_tech_probe(struct connman_technology *technology)
+{
+ return 0;
+}
+
+static void gadget_tech_remove(struct connman_technology *technology)
+{
+ g_list_free(cdc_interface_list);
+
+ cdc_interface_list = NULL;
+}
+
+static struct connman_technology_driver gadget_tech_driver = {
+ .name = "cdc_ethernet",
+ .type = CONNMAN_SERVICE_TYPE_GADGET,
+ .probe = gadget_tech_probe,
+ .remove = gadget_tech_remove,
+ .add_interface = gadget_tech_add_interface,
+ .remove_interface = gadget_tech_remove_interface,
+ .set_tethering = gadget_tech_set_tethering,
+};
+
+static int gadget_init(void)
+{
+ int err;
+
+ err = connman_technology_driver_register(&gadget_tech_driver);
+ if (err < 0) {
+ return err;
+ }
+
+ err = connman_network_driver_register(&gadget_network_driver);
+ if (err < 0)
+ return err;
+
+ err = connman_device_driver_register(&gadget_dev_driver);
+ if (err < 0) {
+ connman_technology_driver_unregister(&gadget_tech_driver);
+ return err;
+ }
+
+ return 0;
+}
+
+static void gadget_exit(void)
+{
+ connman_technology_driver_unregister(&gadget_tech_driver);
+ connman_network_driver_unregister(&gadget_network_driver);
+ connman_device_driver_unregister(&gadget_dev_driver);
+}
+
+CONNMAN_PLUGIN_DEFINE(gadget, "Gadget interface plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, gadget_init, gadget_exit)
diff --git a/plugins/hh2serial-gps.c b/plugins/hh2serial-gps.c
new file mode 100644
index 0000000..99394e1
--- /dev/null
+++ b/plugins/hh2serial-gps.c
@@ -0,0 +1,124 @@
+/*
+ *
+ * hh2serial GPS
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/device.h>
+#include <connman/log.h>
+
+static struct connman_device *hh2serial_device;
+
+static int set_reg(char *key, char *value)
+{
+ FILE *reg_file;
+
+ reg_file = fopen(key, "w");
+ if (!reg_file)
+ return -errno;
+
+ fprintf(reg_file, "%s", value);
+ fclose(reg_file);
+ return 0;
+}
+
+static int hh2serial_probe(struct connman_device *device)
+{
+ return 0;
+}
+
+static void hh2serial_remove(struct connman_device *device)
+{
+}
+
+static int hh2serial_enable(struct connman_device *device)
+{
+ DBG("");
+
+ set_reg("/sys/class/gpio/expo_rt", "85");
+ set_reg("/sys/class/gpio/gpio85/direction", "out");
+ set_reg("/sys/class/gpio/gpio85/value", "1");
+
+ return 0;
+}
+
+static int hh2serial_disable(struct connman_device *device)
+{
+ DBG("");
+
+ set_reg("/sys/class/gpio/expo_rt", "85");
+ set_reg("/sys/class/gpio/gpio85/direction", "out");
+ set_reg("/sys/class/gpio/gpio85/value", "0");
+
+ return 0;
+}
+
+static struct connman_device_driver hh2serial_device_driver = {
+ .name = "hh2serial GPS",
+ .type = CONNMAN_DEVICE_TYPE_GPS,
+ .enable = hh2serial_enable,
+ .disable = hh2serial_disable,
+ .probe = hh2serial_probe,
+ .remove = hh2serial_remove,
+};
+
+static int hh2serial_init(void)
+{
+ int err;
+
+ err = connman_device_driver_register(&hh2serial_device_driver);
+ if (err < 0)
+ return err;
+
+ hh2serial_device = connman_device_create("hh2serial_gps",
+ CONNMAN_DEVICE_TYPE_GPS);
+ if (!hh2serial_device) {
+ connman_device_driver_unregister(&hh2serial_device_driver);
+ return -ENODEV;
+ }
+
+ err = connman_device_register(hh2serial_device);
+ if (err < 0) {
+ connman_device_unref(hh2serial_device);
+ return err;
+ }
+
+ return 0;
+}
+
+static void hh2serial_exit(void)
+{
+ if (hh2serial_device) {
+ connman_device_unregister(hh2serial_device);
+ connman_device_unref(hh2serial_device);
+ }
+
+ connman_device_driver_unregister(&hh2serial_device_driver);
+}
+
+CONNMAN_PLUGIN_DEFINE(hh2serial_gps, "hh2serial GPS", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_LOW, hh2serial_init, hh2serial_exit)
diff --git a/plugins/iospm.c b/plugins/iospm.c
new file mode 100644
index 0000000..fcb4cea
--- /dev/null
+++ b/plugins/iospm.c
@@ -0,0 +1,111 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/notifier.h>
+#include <connman/dbus.h>
+#include <connman/log.h>
+
+#define IOSPM_SERVICE "com.intel.mid.ospm"
+#define IOSPM_INTERFACE IOSPM_SERVICE ".Comms"
+
+#define IOSPM_BLUETOOTH "/com/intel/mid/ospm/bluetooth"
+#define IOSPM_FLIGHT_MODE "/com/intel/mid/ospm/flight_mode"
+
+static DBusConnection *connection;
+
+static void send_indication(const char *path, bool enabled)
+{
+ DBusMessage *message;
+ const char *method;
+
+ DBG("path %s enabled %d", path, enabled);
+
+ if (enabled)
+ method = "IndicateStart";
+ else
+ method = "IndicateStop";
+
+ message = dbus_message_new_method_call(IOSPM_SERVICE, path,
+ IOSPM_INTERFACE, method);
+ if (!message)
+ return;
+
+ dbus_message_set_no_reply(message, TRUE);
+
+ dbus_connection_send(connection, message, NULL);
+
+ dbus_message_unref(message);
+}
+
+static void iospm_service_enabled(enum connman_service_type type,
+ bool enabled)
+{
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ send_indication(IOSPM_BLUETOOTH, enabled);
+ break;
+ }
+}
+
+static void iospm_offline_mode(bool enabled)
+{
+ send_indication(IOSPM_FLIGHT_MODE, enabled);
+}
+
+static struct connman_notifier iospm_notifier = {
+ .name = "iospm",
+ .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
+ .service_enabled= iospm_service_enabled,
+ .offline_mode = iospm_offline_mode,
+};
+
+static int iospm_init(void)
+{
+ connection = connman_dbus_get_connection();
+
+ return connman_notifier_register(&iospm_notifier);
+}
+
+static void iospm_exit(void)
+{
+ connman_notifier_unregister(&iospm_notifier);
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(ospm, "Intel OSPM notification plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, iospm_init, iospm_exit)
diff --git a/plugins/loopback.c b/plugins/loopback.c
new file mode 100644
index 0000000..e113887
--- /dev/null
+++ b/plugins/loopback.c
@@ -0,0 +1,282 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <limits.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/inotify.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/utsname.h>
+#include <connman/log.h>
+#include <connman/inet.h>
+
+static in_addr_t loopback_address;
+static in_addr_t loopback_netmask;
+
+static char system_hostname[HOST_NAME_MAX + 1];
+
+static void create_hostname(void)
+{
+ const char *name = "localhost";
+
+ if (sethostname(name, strlen(name)) < 0)
+ connman_error("Failed to set hostname to %s", name);
+
+ strncpy(system_hostname, name, HOST_NAME_MAX);
+}
+
+static int setup_hostname(void)
+{
+ char name[HOST_NAME_MAX + 1];
+
+ memset(system_hostname, 0, sizeof(system_hostname));
+
+ if (gethostname(system_hostname, HOST_NAME_MAX) < 0) {
+ connman_error("Failed to get current hostname");
+ return -EIO;
+ }
+
+ if (strlen(system_hostname) > 0 &&
+ strcmp(system_hostname, "(none)") != 0)
+ connman_info("System hostname is %s", system_hostname);
+ else
+ create_hostname();
+
+ memset(name, 0, sizeof(name));
+
+ if (getdomainname(name, HOST_NAME_MAX) < 0) {
+ connman_error("Failed to get current domainname");
+ return -EIO;
+ }
+
+ if (strlen(name) > 0 && strcmp(name, "(none)") != 0)
+ connman_info("System domainname is %s", name);
+
+ return 0;
+}
+
+static bool valid_loopback(int sk, struct ifreq *ifr)
+{
+ struct sockaddr_in *addr;
+ int err;
+ char buf[INET_ADDRSTRLEN];
+
+ /* It is possible to end up in situations in which the
+ * loopback interface is up but has no valid address. In that
+ * case, we expect EADDRNOTAVAIL and should return FALSE.
+ */
+
+ err = ioctl(sk, SIOCGIFADDR, ifr);
+ if (err < 0) {
+ err = -errno;
+ connman_error("Getting address failed (%s)", strerror(-err));
+ return err != -EADDRNOTAVAIL ? TRUE : FALSE;
+ }
+
+ addr = (struct sockaddr_in *) &ifr->ifr_addr;
+ if (addr->sin_addr.s_addr != loopback_address) {
+ connman_warn("Invalid loopback address %s",
+ inet_ntop(AF_INET, &addr->sin_addr, buf, sizeof(buf)));
+ return false;
+ }
+
+ err = ioctl(sk, SIOCGIFNETMASK, ifr);
+ if (err < 0) {
+ err = -errno;
+ connman_error("Getting netmask failed (%s)", strerror(-err));
+ return true;
+ }
+
+ addr = (struct sockaddr_in *) &ifr->ifr_netmask;
+ if (addr->sin_addr.s_addr != loopback_netmask) {
+ connman_warn("Invalid loopback netmask %s",
+ inet_ntop(AF_INET, &addr->sin_addr, buf, sizeof(buf)));
+ return false;
+ }
+
+ return true;
+}
+
+static int setup_loopback(void)
+{
+ struct ifreq ifr;
+ struct sockaddr_in addr;
+ int sk, err;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -errno;
+
+ memset(&ifr, 0, sizeof(ifr));
+ strcpy(ifr.ifr_name, "lo");
+
+ if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ if (ifr.ifr_flags & IFF_UP) {
+ connman_info("Checking loopback interface settings");
+ if (valid_loopback(sk, &ifr)) {
+ err = -EALREADY;
+ goto done;
+ }
+
+ connman_warn("Correcting wrong loopback settings");
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = loopback_address;
+ memcpy(&ifr.ifr_addr, &addr, sizeof(ifr.ifr_addr));
+
+ err = ioctl(sk, SIOCSIFADDR, &ifr);
+ if (err < 0) {
+ err = -errno;
+ connman_error("Setting address failed (%s)", strerror(-err));
+ goto done;
+ }
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = loopback_netmask;
+ memcpy(&ifr.ifr_netmask, &addr, sizeof(ifr.ifr_netmask));
+
+ err = ioctl(sk, SIOCSIFNETMASK, &ifr);
+ if (err < 0) {
+ err = -errno;
+ connman_error("Setting netmask failed (%s)", strerror(-err));
+ goto done;
+ }
+
+ if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ ifr.ifr_flags |= IFF_UP;
+
+ if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ connman_error("Activating loopback interface failed (%s)",
+ strerror(-err));
+ goto done;
+ }
+
+done:
+ close(sk);
+
+ return err;
+}
+
+static const char *loopback_get_hostname(void)
+{
+ return system_hostname;
+}
+
+static int loopback_set_hostname(const char *hostname)
+{
+ const char *ptr;
+ int err, len;
+
+ if (g_strcmp0(hostname, "<hostname>") == 0)
+ return 0;
+
+ len = strlen(hostname);
+
+ if (!connman_inet_check_hostname(hostname, len))
+ return -EINVAL;
+
+ if ((ptr = strstr(hostname, ".")))
+ len = ptr - hostname;
+
+ if (sethostname(hostname, len) < 0) {
+ err = -errno;
+ connman_error("Failed to set hostname to %s", hostname);
+ return err;
+ }
+
+ connman_info("Setting hostname to %s", hostname);
+
+ return 0;
+}
+
+static int loopback_set_domainname(const char *domainname)
+{
+ int err, len;
+
+ len = strlen(domainname);
+
+ if (!connman_inet_check_hostname(domainname, len))
+ return -EINVAL;
+
+ if (setdomainname(domainname, len) < 0) {
+ err = -errno;
+ connman_error("Failed to set domainname to %s", domainname);
+ return err;
+ }
+
+ connman_info("Setting domainname to %s", domainname);
+
+ return 0;
+}
+
+static struct connman_utsname_driver loopback_driver = {
+ .name = "loopback",
+ .get_hostname = loopback_get_hostname,
+ .set_hostname = loopback_set_hostname,
+ .set_domainname = loopback_set_domainname,
+};
+
+static int loopback_init(void)
+{
+ loopback_address = inet_addr("127.0.0.1");
+ loopback_netmask = inet_addr("255.0.0.0");
+
+ setup_loopback();
+
+ setup_hostname();
+
+ connman_utsname_driver_register(&loopback_driver);
+
+ return 0;
+}
+
+static void loopback_exit(void)
+{
+ connman_utsname_driver_unregister(&loopback_driver);
+}
+
+CONNMAN_PLUGIN_DEFINE(loopback, "Loopback device plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_HIGH, loopback_init, loopback_exit)
diff --git a/plugins/mcc.h b/plugins/mcc.h
new file mode 100644
index 0000000..0e0407c
--- /dev/null
+++ b/plugins/mcc.h
@@ -0,0 +1,475 @@
+/*
+ * Mobile country code list from
+ * "LIST OF MOBILE COUNTRY OR GEOGRAPHICAL AREA CODES"
+ * (http://www.itu.int/publ/T-SP-E.212A-2007)
+ * combined with ISO 3166-1 alpha-2 list for two letter country codes
+ */
+
+char *mcc_country_codes[] = {
+ NULL, /* 200 */
+ NULL,
+ NULL,
+ NULL,
+ "NL",
+ NULL,
+ "BE",
+ NULL,
+ "FR",
+ NULL,
+ NULL,
+ NULL,
+ "MC",
+ "AD",
+ "ES",
+ NULL,
+ "HU",
+ NULL,
+ "BA",
+ "HR",
+ "RS",
+ NULL,
+ "IT",
+ NULL,
+ NULL,
+ "VA",
+ "RO",
+ NULL,
+ "CH",
+ NULL,
+ "CZ",
+ "SK",
+ "AT",
+ NULL,
+ "GB",
+ "GB",
+ NULL,
+ NULL,
+ "DK",
+ NULL,
+ "SE",
+ NULL,
+ "NO",
+ NULL,
+ "FI",
+ NULL,
+ "LT",
+ "LV",
+ "EE",
+ NULL,
+ "RU",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "UA",
+ NULL,
+ "BY",
+ NULL,
+ "MD",
+ "PL",
+ NULL,
+ "DE",
+ NULL,
+ NULL,
+ NULL,
+ "GI",
+ NULL,
+ "PT",
+ NULL,
+ "LU",
+ NULL,
+ "IE",
+ NULL,
+ "IS",
+ NULL,
+ "AL",
+ NULL,
+ "MT",
+ NULL,
+ "CY",
+ NULL,
+ "GE",
+ "AM",
+ "BG",
+ NULL,
+ "TR",
+ NULL,
+ "FO",
+ NULL,
+ "GL",
+ NULL,
+ "SM",
+ "SI",
+ "MK",
+ "LI",
+ NULL,
+ "ME",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "CA",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "PM",
+ NULL,
+ "US",
+ "US",
+ "US",
+ "US",
+ "US",
+ "US",
+ "US",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "PR",
+ NULL,
+ "VI",
+ NULL,
+ "MX",
+ NULL,
+ NULL,
+ NULL,
+ "JM",
+ NULL,
+ "MQ",
+ NULL,
+ "BB",
+ NULL,
+ "AG",
+ NULL,
+ "KY",
+ NULL,
+ "VG",
+ NULL,
+ "BM",
+ NULL,
+ "GD",
+ NULL,
+ "MS",
+ NULL,
+ "KN",
+ NULL,
+ "LC",
+ NULL,
+ "VC",
+ NULL,
+ "AN",
+ "AW",
+ "BS",
+ "AI",
+ "DM",
+ NULL,
+ "CU",
+ NULL,
+ "DO",
+ NULL,
+ "HT",
+ NULL,
+ "TT",
+ NULL,
+ "TC",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "AZ",
+ "KZ",
+ "BT",
+ NULL,
+ "IN",
+ "IN",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "PK",
+ NULL,
+ "AF",
+ "LK",
+ "MM",
+ "LB",
+ "JO",
+ "SY",
+ "IQ",
+ "KW",
+ "SA",
+ "YE",
+ "OM",
+ NULL,
+ "AE",
+ "IL",
+ "BH",
+ "QA",
+ "MN",
+ "NP",
+ "AE",
+ "AE",
+ "IR",
+ NULL,
+ "UZ",
+ NULL,
+ "TJ",
+ "KG",
+ "TM",
+ NULL,
+ "JP",
+ "JP",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "KR",
+ NULL,
+ "VN",
+ NULL,
+ "HK",
+ "MO",
+ "KH",
+ "LA",
+ NULL,
+ NULL,
+ "CN",
+ "CN",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "TW",
+ "KP",
+ NULL,
+ NULL,
+ "BD",
+ NULL,
+ "MV",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 500 */
+ NULL,
+ "MY",
+ NULL,
+ NULL,
+ "AU",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "ID",
+ NULL,
+ NULL,
+ NULL,
+ "TL",
+ "PH",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "TH",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "SG",
+ NULL,
+ NULL,
+ "BN",
+ NULL,
+ "NZ",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "NR",
+ "PG",
+ NULL,
+ "TO",
+ "SB",
+ "VU",
+ "FJ",
+ "WF",
+ "AS",
+ "KI",
+ "NC",
+ "PF",
+ "CK",
+ "WS",
+ "FM",
+ "MH",
+ "PW",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 600 */
+ NULL,
+ "EG",
+ "DZ",
+ "MA",
+ "TN",
+ "LY",
+ "GM",
+ "SN",
+ "MR",
+ "ML",
+ "GN",
+ "CI",
+ "BF",
+ "NE",
+ "TG",
+ "BJ",
+ "MU",
+ "LR",
+ "SL",
+ "GH",
+ "NG",
+ "TD",
+ "CF",
+ "CM",
+ "CV",
+ "ST",
+ "GQ",
+ "GA",
+ "CG",
+ "CD",
+ "AO",
+ "GW",
+ "SC",
+ "SD",
+ "RW",
+ "ET",
+ "SO",
+ "DJ",
+ "KE",
+ "TZ",
+ "UG",
+ "BI",
+ "MZ",
+ NULL,
+ "ZM",
+ "MG",
+ "TF",
+ "ZW",
+ "NA",
+ "MW",
+ "LS",
+ "BW",
+ "SZ",
+ "KM",
+ "ZA",
+ NULL,
+ "ER",
+ NULL,
+ NULL,
+ NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 700 */
+ NULL,
+ "BZ",
+ NULL,
+ "GT",
+ NULL,
+ "SV",
+ NULL,
+ "HN",
+ NULL,
+ "NI",
+ NULL,
+ "CR",
+ NULL,
+ "PA",
+ NULL,
+ "PE",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "AR",
+ NULL,
+ "BR",
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ "CL",
+ NULL,
+ "CO",
+ NULL,
+ "VE",
+ NULL,
+ "BO",
+ NULL,
+ "GY",
+ NULL,
+ "EC",
+ NULL,
+ "GF",
+ NULL,
+ "PY",
+ NULL,
+ "SR",
+ NULL,
+ "UY",
+ NULL,
+ "FK",
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+ NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, /* 799 */
+};
diff --git a/plugins/neard.c b/plugins/neard.c
new file mode 100644
index 0000000..1a0fc1c
--- /dev/null
+++ b/plugins/neard.c
@@ -0,0 +1,628 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <string.h>
+#include <arpa/inet.h>
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/dbus.h>
+#include <connman/technology.h>
+#include <connman/provision.h>
+
+#include <gdbus.h>
+
+#define TIMEOUT 30000
+
+#define NEARD_SERVICE "org.neard"
+#define NEARD_PATH "/"
+#define NEARD_MANAGER_INTERFACE "org.neard.Manager"
+#define NEARD_AGENT_INTERFACE "org.neard.HandoverAgent"
+#define NEARD_ERROR_INTERFACE "org.neard.HandoverAgent.Error"
+
+#define AGENT_PATH "/net/connman/neard_handover_agent"
+#define AGENT_TYPE "wifi"
+
+#define NEARD_SERVICE_GROUP "service_neard_provision"
+
+/* Configuration keys */
+#define SERVICE_KEY_TYPE "Type"
+#define SERVICE_KEY_SSID "SSID"
+#define SERVICE_KEY_PASSPHRASE "Passphrase"
+#define SERVICE_KEY_HIDDEN "Hidden"
+
+struct data_elements {
+ unsigned int value;
+ unsigned int length;
+ bool fixed_length;
+};
+
+typedef enum {
+ DE_AUTHENTICATION_TYPE = 0,
+ DE_NETWORK_KEY = 1,
+ DE_SSID = 2,
+ DE_MAX = 3,
+} DEid;
+
+static const struct data_elements DEs[DE_MAX] = {
+ { 0x1003, 2, TRUE },
+ { 0x1027, 64, FALSE },
+ { 0x1045, 32, FALSE },
+};
+
+#define DE_VAL_OPEN 0x0001
+#define DE_VAL_PSK 0x0022
+
+struct wifi_sc {
+ gchar *ssid;
+ gchar *passphrase;
+};
+
+static DBusConnection *connection = NULL;
+DBusPendingCall *register_call = NULL;
+bool agent_registered = false;
+static guint watch_id = 0;
+
+static int set_2b_into_tlv(uint8_t *tlv_msg, uint16_t val)
+{
+ uint16_t ne_val;
+ uint8_t *ins;
+
+ ins = (uint8_t *) &ne_val;
+
+ ne_val = htons(val);
+ tlv_msg[0] = ins[0];
+ tlv_msg[1] = ins[1];
+
+ return 2;
+}
+
+static int set_byte_array_into_tlv(uint8_t *tlv_msg,
+ uint8_t *array, int length)
+{
+ memcpy((void *)tlv_msg, (void *)array, length);
+ return length;
+}
+
+static uint8_t *encode_to_tlv(const char *ssid, const char *psk, int *length)
+{
+ uint16_t ssid_len, psk_len;
+ uint8_t *tlv_msg;
+ int pos = 0;
+
+ if (!ssid || !length)
+ return NULL;
+
+ ssid_len = strlen(ssid);
+
+ *length = 6 + 4 + ssid_len;
+ if (psk) {
+ psk_len = strlen(psk);
+ *length += 4 + psk_len;
+ } else
+ psk_len = 0;
+
+ tlv_msg = g_try_malloc0(sizeof(uint8_t) * (*length));
+ if (!tlv_msg)
+ return NULL;
+
+ pos += set_2b_into_tlv(tlv_msg+pos, DEs[DE_SSID].value);
+ pos += set_2b_into_tlv(tlv_msg+pos, ssid_len);
+ pos += set_byte_array_into_tlv(tlv_msg+pos, (uint8_t *)ssid, ssid_len);
+
+ pos += set_2b_into_tlv(tlv_msg+pos, DEs[DE_AUTHENTICATION_TYPE].value);
+ pos += set_2b_into_tlv(tlv_msg+pos,
+ DEs[DE_AUTHENTICATION_TYPE].length);
+ if (psk) {
+ pos += set_2b_into_tlv(tlv_msg+pos, DE_VAL_PSK);
+ pos += set_2b_into_tlv(tlv_msg+pos, DEs[DE_NETWORK_KEY].value);
+ pos += set_2b_into_tlv(tlv_msg+pos, psk_len);
+ pos += set_byte_array_into_tlv(tlv_msg+pos,
+ (uint8_t *)psk, psk_len);
+ } else
+ pos += set_2b_into_tlv(tlv_msg+pos, DE_VAL_OPEN);
+
+ return tlv_msg;
+}
+
+static DBusMessage *get_reply_on_error(DBusMessage *message, int error)
+{
+ if (error == ENOTSUP)
+ return g_dbus_create_error(message,
+ NEARD_ERROR_INTERFACE ".NotSupported",
+ "Operation is not supported");
+
+ return g_dbus_create_error(message,
+ NEARD_ERROR_INTERFACE ".Failed", "Invalid parameters");
+}
+
+static int parse_request_oob_params(DBusMessage *message,
+ const uint8_t **tlv_msg, int *length)
+{
+ DBusMessageIter iter;
+ DBusMessageIter array;
+ DBusMessageIter dict_entry;
+ const char *key;
+ int arg_type;
+
+ if (!tlv_msg || !length)
+ return -EINVAL;
+
+ dbus_message_iter_init(message, &iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(&iter, &array);
+ arg_type = dbus_message_iter_get_arg_type(&array);
+ if (arg_type != DBUS_TYPE_DICT_ENTRY)
+ return -EINVAL;
+
+ while (arg_type != DBUS_TYPE_INVALID) {
+ dbus_message_iter_recurse(&array, &dict_entry);
+ if (dbus_message_iter_get_arg_type(&dict_entry) !=
+ DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&dict_entry, &key);
+ if (g_strcmp0(key, "WSC") == 0) {
+ DBusMessageIter value;
+ DBusMessageIter fixed_array;
+
+ dbus_message_iter_next(&dict_entry);
+ dbus_message_iter_recurse(&dict_entry, &value);
+
+ if (dbus_message_iter_get_arg_type(&value) !=
+ DBUS_TYPE_ARRAY)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(&value, &fixed_array);
+ dbus_message_iter_get_fixed_array(&fixed_array,
+ tlv_msg, length);
+ return 0;
+ }
+
+ dbus_message_iter_next(&array);
+ arg_type = dbus_message_iter_get_arg_type(&array);
+ }
+
+ return -EINVAL;
+}
+
+static DBusMessage *create_request_oob_reply(DBusMessage *message)
+{
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ const char *ssid, *psk;
+ uint8_t *tlv_msg;
+ int length;
+
+ if (!connman_technology_get_wifi_tethering(&ssid, &psk))
+ return get_reply_on_error(message, ENOTSUP);
+
+ tlv_msg = encode_to_tlv(ssid, psk, &length);
+ if (!tlv_msg)
+ return get_reply_on_error(message, ENOTSUP);
+
+ reply = dbus_message_new_method_return(message);
+ if (!reply)
+ goto out;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ connman_dbus_dict_append_fixed_array(&dict, "WSC",
+ DBUS_TYPE_BYTE, &tlv_msg, length);
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+out:
+ g_free(tlv_msg);
+
+ return reply;
+}
+
+static DBusMessage *request_oob_method(DBusConnection *dbus_conn,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter;
+
+ DBG("");
+
+ dbus_message_iter_init(message, &iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+ return get_reply_on_error(message, EINVAL);
+
+ return create_request_oob_reply(message);
+}
+
+static void free_wifi_sc(struct wifi_sc *wsc)
+{
+ if (!wsc)
+ return;
+
+ g_free(wsc->ssid);
+ g_free(wsc->passphrase);
+
+ g_free(wsc);
+}
+
+static inline int get_2b_from_tlv(const uint8_t *tlv_msg, uint16_t *val)
+{
+ *val = ntohs(tlv_msg[0] | (tlv_msg[1] << 8));
+
+ return 2;
+}
+
+static uint8_t *get_byte_array_from_tlv(const uint8_t *tlv_msg, int length)
+{
+ uint8_t *array;
+
+ array = g_try_malloc0(sizeof(uint8_t) * length);
+ if (!array)
+ return NULL;
+
+ memcpy((void *)array, (void *)tlv_msg, length*sizeof(uint8_t));
+
+ return array;
+}
+
+static char *get_string_from_tlv(const uint8_t *tlv_msg, int length)
+{
+ char *str;
+
+ str = g_try_malloc0((sizeof(char) * length) + 1);
+ if (!str)
+ return NULL;
+
+ memcpy((void *)str, (void *)tlv_msg, length*sizeof(char));
+
+ return str;
+}
+
+static inline DEid get_de_id(uint16_t attr)
+{
+ int i;
+
+ for (i = 0; i < DE_MAX && DEs[i].value != 0; i++) {
+ if (attr == DEs[i].value)
+ return i;
+ }
+
+ return DE_MAX;
+}
+
+static inline bool is_de_length_fine(DEid id, uint16_t length)
+{
+ if (DEs[id].fixed_length)
+ return (length == DEs[id].length);
+
+ return (length <= DEs[id].length);
+}
+
+static char *get_hexstr_from_byte_array(const uint8_t *bt, int length)
+{
+ char *hex_str;
+ int i, j;
+
+ hex_str = g_try_malloc0(((length*2)+1) * sizeof(char));
+ if (!hex_str)
+ return NULL;
+
+ for (i = 0, j = 0; i < length; i++, j += 2)
+ snprintf(hex_str+j, 3, "%02x", bt[i]);
+
+ return hex_str;
+}
+
+static struct wifi_sc *decode_from_tlv(const uint8_t *tlv_msg, int length)
+{
+ struct wifi_sc *wsc;
+ uint16_t attr, len;
+ uint8_t *bt;
+ int pos;
+ DEid id;
+
+ if (!tlv_msg || length == 0)
+ return NULL;
+
+ wsc = g_try_malloc0(sizeof(struct wifi_sc));
+ if (!wsc)
+ return NULL;
+
+ pos = 0;
+ while (pos < length) {
+ pos += get_2b_from_tlv(tlv_msg+pos, &attr);
+ pos += get_2b_from_tlv(tlv_msg+pos, &len);
+
+ if (len > length - pos)
+ goto error;
+
+ id = get_de_id(attr);
+ if (id == DE_MAX) {
+ pos += len;
+ continue;
+ }
+
+ if (!is_de_length_fine(id, len))
+ goto error;
+
+ switch (id) {
+ case DE_AUTHENTICATION_TYPE:
+ break;
+ case DE_NETWORK_KEY:
+ wsc->passphrase = get_string_from_tlv(tlv_msg+pos,
+ len);
+ break;
+ case DE_SSID:
+ bt = get_byte_array_from_tlv(tlv_msg+pos, len);
+ wsc->ssid = get_hexstr_from_byte_array(bt, len);
+ g_free(bt);
+
+ break;
+ case DE_MAX:
+ /* Falling back. Should never happen though. */
+ default:
+ break;
+ }
+
+ pos += len;
+ }
+
+ return wsc;
+
+error:
+ free_wifi_sc(wsc);
+ return NULL;
+}
+
+static int handle_wcs_data(const uint8_t *tlv_msg, int length)
+{
+ struct wifi_sc *wsc = NULL;
+ GKeyFile *keyfile = NULL;
+ int ret = -EINVAL;
+
+ wsc = decode_from_tlv(tlv_msg, length);
+ if (!wsc)
+ return -EINVAL;
+
+ if (!wsc->ssid)
+ goto out;
+
+ keyfile = g_key_file_new();
+ if (!keyfile) {
+ ret = -ENOMEM;
+ goto out;
+ }
+
+ g_key_file_set_string(keyfile, NEARD_SERVICE_GROUP,
+ SERVICE_KEY_TYPE, "wifi");
+ g_key_file_set_string(keyfile, NEARD_SERVICE_GROUP,
+ SERVICE_KEY_SSID, wsc->ssid);
+ g_key_file_set_boolean(keyfile, NEARD_SERVICE_GROUP,
+ SERVICE_KEY_HIDDEN, TRUE);
+
+ if (wsc->passphrase)
+ g_key_file_set_string(keyfile, NEARD_SERVICE_GROUP,
+ SERVICE_KEY_PASSPHRASE, wsc->passphrase);
+
+ ret = connman_config_provision_mutable_service(keyfile);
+
+out:
+ g_key_file_free(keyfile);
+ free_wifi_sc(wsc);
+ return ret;
+}
+
+static DBusMessage *push_oob_method(DBusConnection *dbus_conn,
+ DBusMessage *message, void *user_data)
+{
+ const uint8_t *tlv_msg;
+ int err = EINVAL;
+ int length;
+
+ DBG("");
+
+ if (parse_request_oob_params(message, &tlv_msg, &length) != 0)
+ return get_reply_on_error(message, err);
+
+ err = handle_wcs_data(tlv_msg, length);
+ if (err != 0)
+ return get_reply_on_error(message, err);
+
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *release_method(DBusConnection *dbus_conn,
+ DBusMessage *message, void *user_data)
+{
+ DBG("");
+
+ agent_registered = false;
+ g_dbus_unregister_interface(connection,
+ AGENT_PATH, NEARD_AGENT_INTERFACE);
+
+ return g_dbus_create_reply(message, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable neard_methods[] = {
+ { GDBUS_ASYNC_METHOD("RequestOOB",
+ GDBUS_ARGS({ "data", "a{sv}" }),
+ GDBUS_ARGS({ "data", "a{sv}" }), request_oob_method) },
+ { GDBUS_ASYNC_METHOD("PushOOB",
+ GDBUS_ARGS({ "data", "a{sv}"}), NULL, push_oob_method) },
+ { GDBUS_METHOD("Release", NULL, NULL, release_method) },
+ { },
+};
+
+static void cleanup_register_call(void)
+{
+ if (register_call) {
+ dbus_pending_call_cancel(register_call);
+ dbus_pending_call_unref(register_call);
+ register_call = NULL;
+ }
+}
+
+static void register_agent_cb(DBusPendingCall *pending, void *user_data)
+{
+ DBusMessage *reply;
+
+ if (!dbus_pending_call_get_completed(pending))
+ return;
+
+ register_call = NULL;
+
+ reply = dbus_pending_call_steal_reply(pending);
+ if (!reply)
+ goto out;
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ g_dbus_unregister_interface(connection,
+ AGENT_PATH, NEARD_AGENT_INTERFACE);
+ } else
+ agent_registered = true;
+
+ dbus_message_unref(reply);
+out:
+ dbus_pending_call_unref(pending);
+}
+
+static void register_agent(void)
+{
+ const char *path = AGENT_PATH;
+ const char *type = AGENT_TYPE;
+ DBusMessage *message;
+
+ message = dbus_message_new_method_call(NEARD_SERVICE, NEARD_PATH,
+ NEARD_MANAGER_INTERFACE,
+ "RegisterHandoverAgent");
+ if (!message)
+ return;
+
+ dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH,
+ &path, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ ®ister_call, TIMEOUT)) {
+ dbus_message_unref(message);
+ goto out;
+ }
+
+ if (!dbus_pending_call_set_notify(register_call,
+ register_agent_cb, NULL, NULL))
+ cleanup_register_call();
+
+out:
+ dbus_message_unref(message);
+}
+
+static void unregister_agent(void)
+{
+ const char *path = AGENT_PATH;
+ const char *type = AGENT_TYPE;
+ DBusMessage *message;
+
+ if (!agent_registered)
+ return cleanup_register_call();
+
+ agent_registered = false;
+
+ message = dbus_message_new_method_call(NEARD_SERVICE, NEARD_PATH,
+ NEARD_MANAGER_INTERFACE,
+ "UnregisterHandoverAgent");
+ if (message) {
+ dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH,
+ &path, DBUS_TYPE_STRING, &type, DBUS_TYPE_INVALID);
+ g_dbus_send_message(connection, message);
+ }
+
+ g_dbus_unregister_interface(connection,
+ AGENT_PATH, NEARD_AGENT_INTERFACE);
+}
+
+static void neard_is_present(DBusConnection *conn, void *user_data)
+{
+ DBG("");
+
+ if (agent_registered)
+ return;
+
+ if (g_dbus_register_interface(connection, AGENT_PATH,
+ NEARD_AGENT_INTERFACE, neard_methods,
+ NULL, NULL, NULL, NULL))
+ register_agent();
+}
+
+static void neard_is_out(DBusConnection *conn, void *user_data)
+{
+ DBG("");
+
+ if (agent_registered) {
+ g_dbus_unregister_interface(connection,
+ AGENT_PATH, NEARD_AGENT_INTERFACE);
+ agent_registered = false;
+ }
+
+ cleanup_register_call();
+}
+
+static int neard_init(void)
+{
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ watch_id = g_dbus_add_service_watch(connection, NEARD_SERVICE,
+ neard_is_present, neard_is_out,
+ NULL, NULL);
+ if (watch_id == 0) {
+ dbus_connection_unref(connection);
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+static void neard_exit(void)
+{
+ unregister_agent();
+
+ if (watch_id != 0)
+ g_dbus_remove_watch(connection, watch_id);
+ if (connection)
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(neard, "Neard handover plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, neard_init, neard_exit)
diff --git a/plugins/nmcompat.c b/plugins/nmcompat.c
new file mode 100644
index 0000000..883ce9b
--- /dev/null
+++ b/plugins/nmcompat.c
@@ -0,0 +1,284 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/log.h>
+#include <connman/notifier.h>
+#include <connman/dbus.h>
+
+enum {
+ NM_STATE_UNKNOWN = 0,
+ NM_STATE_ASLEEP = 10,
+ NM_STATE_DISCONNECTED = 20,
+ NM_STATE_DISCONNECTING = 30,
+ NM_STATE_CONNECTING = 40,
+ NM_STATE_CONNECTED_LOCAL = 50,
+ NM_STATE_CONNECTED_SITE = 60,
+ NM_STATE_CONNECTED_GLOBAL = 70
+};
+
+#define NM_SERVICE "org.freedesktop.NetworkManager"
+#define NM_PATH "/org/freedesktop/NetworkManager"
+#define NM_INTERFACE NM_SERVICE
+
+#define DBUS_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties"
+
+static DBusConnection *connection = NULL;
+static struct connman_service *current_service = NULL;
+static dbus_uint32_t nm_state = NM_STATE_UNKNOWN;
+
+static void state_changed(dbus_uint32_t state)
+{
+ DBusMessage *signal;
+
+ DBG("state %d", state);
+
+ signal = dbus_message_new_signal(NM_PATH, NM_INTERFACE,
+ "StateChanged");
+ if (!signal)
+ return;
+
+ dbus_message_append_args(signal, DBUS_TYPE_UINT32, &state,
+ DBUS_TYPE_INVALID);
+
+ g_dbus_send_message(connection, signal);
+}
+
+static void properties_changed(dbus_uint32_t state)
+{
+ const char *key = "State";
+ DBusMessageIter iter, dict, dict_entry, dict_val;
+ DBusMessage *signal;
+
+ DBG("state %d", state);
+
+ signal = dbus_message_new_signal(NM_PATH, NM_INTERFACE,
+ "PropertiesChanged");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
+ &dict);
+
+ dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &dict_entry);
+
+ dbus_message_iter_append_basic(&dict_entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(&dict_entry, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_UINT32_AS_STRING, &dict_val);
+
+ dbus_message_iter_append_basic(&dict_val, DBUS_TYPE_UINT32, &state);
+
+ dbus_message_iter_close_container(&dict_entry, &dict_val);
+ dbus_message_iter_close_container(&dict, &dict_entry);
+ dbus_message_iter_close_container(&iter, &dict);
+
+ g_dbus_send_message(connection, signal);
+}
+
+static void default_changed(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ if (!service)
+ nm_state = NM_STATE_DISCONNECTED;
+ else
+ nm_state = NM_STATE_CONNECTED_LOCAL;
+
+ state_changed(nm_state);
+ properties_changed(nm_state);
+
+ current_service = service;
+}
+
+static void service_state_changed(struct connman_service *service,
+ enum connman_service_state state)
+{
+ DBG("service %p state %d", service, state);
+
+ if (!current_service || current_service != service)
+ return;
+
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ nm_state = NM_STATE_UNKNOWN;
+ break;
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ nm_state = NM_STATE_DISCONNECTED;
+ break;
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ nm_state = NM_STATE_CONNECTING;
+ break;
+ case CONNMAN_SERVICE_STATE_READY:
+ nm_state = NM_STATE_CONNECTED_LOCAL;
+ break;
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ nm_state = NM_STATE_CONNECTED_GLOBAL;
+ break;
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ nm_state = NM_STATE_DISCONNECTING;
+ break;
+ }
+
+ state_changed(nm_state);
+ properties_changed(nm_state);
+}
+
+static void offline_mode(bool enabled)
+{
+ DBG("enabled %d", enabled);
+
+ if (enabled)
+ nm_state = NM_STATE_ASLEEP;
+ else
+ nm_state = NM_STATE_DISCONNECTED;
+
+ state_changed(nm_state);
+ properties_changed(nm_state);
+
+ current_service = NULL;
+}
+
+static struct connman_notifier notifier = {
+ .name = "nmcompat",
+ .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
+ .default_changed = default_changed,
+ .service_state_changed = service_state_changed,
+ .offline_mode = offline_mode,
+};
+
+static DBusMessage *property_get(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *interface, *key;
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &interface,
+ DBUS_TYPE_STRING, &key, DBUS_TYPE_INVALID);
+
+ DBG("interface %s property %s", interface, key);
+
+ if (!g_str_equal(interface, NM_INTERFACE))
+ return dbus_message_new_error(msg, DBUS_ERROR_FAILED,
+ "Unsupported interface");
+
+ if (g_str_equal(key, "State")) {
+ DBusMessage *reply;
+ DBusMessageIter iter, value;
+
+ DBG("state %d", nm_state);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_UINT32_AS_STRING, &value);
+ dbus_message_iter_append_basic(&value,
+ DBUS_TYPE_UINT32, &nm_state);
+ dbus_message_iter_close_container(&iter, &value);
+
+ return reply;
+ }
+
+ return dbus_message_new_error(msg, DBUS_ERROR_FAILED,
+ "Unsupported property");
+}
+
+static const GDBusMethodTable methods[] = {
+ { GDBUS_METHOD("Get",
+ GDBUS_ARGS({ "interface", "s" }, { "key", "s" }),
+ GDBUS_ARGS({ "property", "v" }), property_get) },
+ { },
+};
+
+static const GDBusSignalTable signals[] = {
+ { GDBUS_SIGNAL("PropertiesChanged",
+ GDBUS_ARGS({ "properties", "a{sv}" })) },
+ { GDBUS_SIGNAL("StateChanged",
+ GDBUS_ARGS({ "state", "u" })) },
+ { },
+};
+
+static int nmcompat_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ if (!g_dbus_request_name(connection, NM_SERVICE, NULL)) {
+ connman_error("nmcompat: failed to register service");
+ return -1;
+ }
+
+ if (connman_notifier_register(¬ifier) < 0) {
+ connman_error("nmcompat: failed to register notifier");
+ return -1;
+ }
+
+ if (!g_dbus_register_interface(connection, NM_PATH,
+ DBUS_PROPERTIES_INTERFACE, methods,
+ signals, NULL, NULL, NULL)) {
+ connman_error("nmcompat: failed to register "
+ DBUS_PROPERTIES_INTERFACE);
+ return -1;
+ }
+
+ return 0;
+}
+
+static void nmcompat_exit(void)
+{
+ DBG("");
+
+ connman_notifier_unregister(¬ifier);
+
+ if (!connection)
+ return;
+
+ g_dbus_unregister_interface(connection, NM_PATH,
+ DBUS_PROPERTIES_INTERFACE);
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(nmcompat, "NetworkManager compatibility interfaces",
+ VERSION, CONNMAN_PLUGIN_PRIORITY_DEFAULT,
+ nmcompat_init, nmcompat_exit)
diff --git a/plugins/ofono.c b/plugins/ofono.c
new file mode 100644
index 0000000..e66a708
--- /dev/null
+++ b/plugins/ofono.c
@@ -0,0 +1,2828 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2011-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+
+#include <gdbus.h>
+#include <string.h>
+#include <stdint.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/device.h>
+#include <connman/network.h>
+#include <connman/inet.h>
+#include <connman/dbus.h>
+#include <connman/log.h>
+#include <connman/technology.h>
+
+#include "mcc.h"
+
+#define OFONO_SERVICE "org.ofono"
+
+#define OFONO_MANAGER_INTERFACE OFONO_SERVICE ".Manager"
+#define OFONO_MODEM_INTERFACE OFONO_SERVICE ".Modem"
+#define OFONO_SIM_INTERFACE OFONO_SERVICE ".SimManager"
+#define OFONO_NETREG_INTERFACE OFONO_SERVICE ".NetworkRegistration"
+#define OFONO_CM_INTERFACE OFONO_SERVICE ".ConnectionManager"
+#define OFONO_CONTEXT_INTERFACE OFONO_SERVICE ".ConnectionContext"
+#define OFONO_CDMA_CM_INTERFACE OFONO_SERVICE ".cdma.ConnectionManager"
+#define OFONO_CDMA_NETREG_INTERFACE OFONO_SERVICE ".cdma.NetworkRegistration"
+
+#define MODEM_ADDED "ModemAdded"
+#define MODEM_REMOVED "ModemRemoved"
+#define PROPERTY_CHANGED "PropertyChanged"
+#define CONTEXT_ADDED "ContextAdded"
+#define CONTEXT_REMOVED "ContextRemoved"
+
+#define GET_PROPERTIES "GetProperties"
+#define SET_PROPERTY "SetProperty"
+#define GET_MODEMS "GetModems"
+#define GET_CONTEXTS "GetContexts"
+
+#define TIMEOUT 40000
+
+enum ofono_api {
+ OFONO_API_SIM = 0x1,
+ OFONO_API_NETREG = 0x2,
+ OFONO_API_CM = 0x4,
+ OFONO_API_CDMA_NETREG = 0x8,
+ OFONO_API_CDMA_CM = 0x10,
+};
+
+/*
+ * The way this plugin works is following:
+ *
+ * powered -> SubscriberIdentity or Online = True -> gprs, context ->
+ * attached -> netreg -> ready
+ *
+ * Depending on the modem type, this plugin will behave differently.
+ *
+ * GSM working flow:
+ *
+ * When a new modem appears, the plugin always powers it up. This
+ * allows the plugin to create a connman_device. The core will call
+ * modem_enable() if the technology is enabled. modem_enable() will
+ * then set the modem online. If the technology is disabled then
+ * modem_disable() will just set the modem offline. The modem is
+ * always kept powered all the time.
+ *
+ * After setting the modem online the plugin waits for the
+ * ConnectionManager and ConnectionContext to appear. When the context
+ * signals that it is attached and the NetworkRegistration interface
+ * appears, a new Service will be created and registered at the core.
+ *
+ * When asked to connect to the network (network_connect()) the plugin
+ * will set the Active property on the context. If this operation is
+ * successful the modem is connected to the network. oFono will inform
+ * the plugin about IP configuration through the updating the context's
+ * properties.
+ *
+ * CDMA working flow:
+ *
+ * When a new modem appears, the plugin always powers it up. This
+ * allows the plugin to create connman_device either using IMSI either
+ * using modem Serial if the modem got a SIM interface or not.
+ *
+ * As for GSM, the core will call modem_enable() if the technology
+ * is enabled. modem_enable() will then set the modem online.
+ * If the technology is disabled then modem_disable() will just set the
+ * modem offline. The modem is always kept powered all the time.
+ *
+ * After setting the modem online the plugin waits for CdmaConnectionManager
+ * interface to appear. Then, once CdmaNetworkRegistration appears, a new
+ * Service will be created and registered at the core.
+ *
+ * When asked to connect to the network (network_connect()) the plugin
+ * will power up the CdmaConnectionManager interface.
+ * If the operation is successful the modem is connected to the network.
+ * oFono will inform the plugin about IP configuration through the
+ * updating CdmaConnectionManager settings properties.
+ */
+
+static DBusConnection *connection;
+
+static GHashTable *modem_hash;
+static GHashTable *context_hash;
+
+struct network_context {
+ char *path;
+ int index;
+
+ enum connman_ipconfig_method ipv4_method;
+ struct connman_ipaddress *ipv4_address;
+ char *ipv4_nameservers;
+
+ enum connman_ipconfig_method ipv6_method;
+ struct connman_ipaddress *ipv6_address;
+ char *ipv6_nameservers;
+};
+
+struct modem_data {
+ char *path;
+
+ struct connman_device *device;
+ struct connman_network *network;
+
+ struct network_context *context;
+
+ /* Modem Interface */
+ char *serial;
+ bool powered;
+ bool online;
+ uint8_t interfaces;
+ bool ignore;
+
+ bool set_powered;
+
+ /* CDMA ConnectionManager Interface */
+ bool cdma_cm_powered;
+
+ /* ConnectionManager Interface */
+ bool attached;
+ bool cm_powered;
+
+ /* ConnectionContext Interface */
+ bool active;
+ bool valid_apn; /* APN is 'valid' if length > 0 */
+
+ /* SimManager Interface */
+ char *imsi;
+
+ /* Netreg Interface */
+ char *name;
+ uint8_t strength;
+ uint8_t data_strength; /* 1xEVDO signal strength */
+ bool registered;
+ bool roaming;
+
+ /* pending calls */
+ DBusPendingCall *call_set_property;
+ DBusPendingCall *call_get_properties;
+ DBusPendingCall *call_get_contexts;
+};
+
+static const char *api2string(enum ofono_api api)
+{
+ switch (api) {
+ case OFONO_API_SIM:
+ return "sim";
+ case OFONO_API_NETREG:
+ return "netreg";
+ case OFONO_API_CM:
+ return "cm";
+ case OFONO_API_CDMA_NETREG:
+ return "cdma-netreg";
+ case OFONO_API_CDMA_CM:
+ return "cmda-cm";
+ }
+
+ return "unknown";
+}
+
+static char *get_ident(const char *path)
+{
+ char *pos;
+
+ if (*path != '/')
+ return NULL;
+
+ pos = strrchr(path, '/');
+ if (!pos)
+ return NULL;
+
+ return pos + 1;
+}
+
+static struct network_context *network_context_alloc(const char *path)
+{
+ struct network_context *context;
+
+ context = g_try_new0(struct network_context, 1);
+ if (!context)
+ return NULL;
+
+ context->path = g_strdup(path);
+ context->index = -1;
+
+ context->ipv4_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ context->ipv4_address = NULL;
+ context->ipv4_nameservers = NULL;
+
+ context->ipv6_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ context->ipv6_address = NULL;
+ context->ipv6_nameservers = NULL;
+
+ return context;
+}
+
+static void network_context_free(struct network_context *context)
+{
+ g_free(context->path);
+
+ connman_ipaddress_free(context->ipv4_address);
+ g_free(context->ipv4_nameservers);
+
+ connman_ipaddress_free(context->ipv6_address);
+ g_free(context->ipv6_nameservers);
+
+ free(context);
+}
+
+static void set_connected(struct modem_data *modem)
+{
+ struct connman_service *service;
+ bool setip = false;
+ enum connman_ipconfig_method method;
+ char *nameservers;
+ int index;
+
+ DBG("%s", modem->path);
+
+ index = modem->context->index;
+
+ method = modem->context->ipv4_method;
+ if (index < 0 || (!modem->context->ipv4_address &&
+ method == CONNMAN_IPCONFIG_METHOD_FIXED)) {
+ connman_error("Invalid index and/or address");
+ return;
+ }
+
+ service = connman_service_lookup_from_network(modem->network);
+ if (!service)
+ return;
+
+ connman_service_create_ip4config(service, index);
+ connman_network_set_ipv4_method(modem->network, method);
+
+ if (method == CONNMAN_IPCONFIG_METHOD_FIXED ||
+ method == CONNMAN_IPCONFIG_METHOD_DHCP) {
+ setip = true;
+ }
+
+ if (method == CONNMAN_IPCONFIG_METHOD_FIXED) {
+ connman_network_set_ipaddress(modem->network,
+ modem->context->ipv4_address);
+ }
+
+ method = modem->context->ipv6_method;
+ connman_service_create_ip6config(service, index);
+ connman_network_set_ipv6_method(modem->network, method);
+
+ if (method == CONNMAN_IPCONFIG_METHOD_AUTO) {
+ setip = true;
+ }
+
+ /* Set the nameservers */
+ if (modem->context->ipv4_nameservers &&
+ modem->context->ipv6_nameservers) {
+ nameservers = g_strdup_printf("%s %s",
+ modem->context->ipv4_nameservers,
+ modem->context->ipv6_nameservers);
+ connman_network_set_nameservers(modem->network, nameservers);
+ g_free(nameservers);
+ } else if (modem->context->ipv4_nameservers) {
+ connman_network_set_nameservers(modem->network,
+ modem->context->ipv4_nameservers);
+ } else if (modem->context->ipv6_nameservers) {
+ connman_network_set_nameservers(modem->network,
+ modem->context->ipv6_nameservers);
+ }
+
+ if (setip) {
+ connman_network_set_index(modem->network, index);
+ connman_network_set_connected(modem->network, true);
+ }
+}
+
+static void set_disconnected(struct modem_data *modem)
+{
+ DBG("%s", modem->path);
+
+ if (modem->network)
+ connman_network_set_connected(modem->network, false);
+
+ if (modem->context) {
+ g_free(modem->context->ipv4_nameservers);
+ modem->context->ipv4_nameservers = NULL;
+ if (modem->context->ipv4_method != CONNMAN_IPCONFIG_METHOD_OFF)
+ modem->context->ipv4_method =
+ CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+
+ g_free(modem->context->ipv6_nameservers);
+ modem->context->ipv6_nameservers = NULL;
+ if (modem->context->ipv6_method != CONNMAN_IPCONFIG_METHOD_OFF)
+ modem->context->ipv6_method =
+ CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ }
+}
+
+typedef void (*set_property_cb)(struct modem_data *data,
+ bool success);
+typedef void (*get_properties_cb)(struct modem_data *data,
+ DBusMessageIter *dict);
+
+struct property_info {
+ struct modem_data *modem;
+ const char *path;
+ const char *interface;
+ const char *property;
+ set_property_cb set_property_cb;
+ get_properties_cb get_properties_cb;
+};
+
+static void set_property_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_info *info = user_data;
+ DBusMessage *reply;
+ DBusError error;
+ bool success = true;
+
+ DBG("%s path %s %s.%s", info->modem->path,
+ info->path, info->interface, info->property);
+
+ info->modem->call_set_property = NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("Failed to change property: %s %s.%s: %s %s",
+ info->path, info->interface, info->property,
+ error.name, error.message);
+ dbus_error_free(&error);
+ success = false;
+ }
+
+ if (info->set_property_cb)
+ (*info->set_property_cb)(info->modem, success);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int set_property(struct modem_data *modem,
+ const char *path, const char *interface,
+ const char *property, int type, void *value,
+ set_property_cb notify)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+ struct property_info *info;
+
+ DBG("%s path %s %s.%s", modem->path, path, interface, property);
+
+ if (modem->call_set_property) {
+ DBG("Cancel pending SetProperty");
+ dbus_pending_call_cancel(modem->call_set_property);
+ dbus_pending_call_unref(modem->call_set_property);
+ modem->call_set_property = NULL;
+ }
+
+ message = dbus_message_new_method_call(OFONO_SERVICE, path,
+ interface, SET_PROPERTY);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+ connman_dbus_property_append_basic(&iter, property, type, value);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &modem->call_set_property, TIMEOUT)) {
+ connman_error("Failed to change property: %s %s.%s",
+ path, interface, property);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!modem->call_set_property) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ info = g_try_new0(struct property_info, 1);
+ if (!info) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ info->modem = modem;
+ info->path = path;
+ info->interface = interface;
+ info->property = property;
+ info->set_property_cb = notify;
+
+ dbus_pending_call_set_notify(modem->call_set_property,
+ set_property_reply, info, g_free);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static void get_properties_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_info *info = user_data;
+ DBusMessageIter array, dict;
+ DBusMessage *reply;
+ DBusError error;
+
+ DBG("%s path %s %s", info->modem->path, info->path, info->interface);
+
+ info->modem->call_get_properties = NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("Failed to get properties: %s %s: %s %s",
+ info->path, info->interface,
+ error.name, error.message);
+ dbus_error_free(&error);
+
+ goto done;
+ }
+
+ if (!dbus_message_iter_init(reply, &array))
+ goto done;
+
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
+ goto done;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ if (info->get_properties_cb)
+ (*info->get_properties_cb)(info->modem, &dict);
+
+done:
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int get_properties(const char *path, const char *interface,
+ get_properties_cb notify,
+ struct modem_data *modem)
+{
+ DBusMessage *message;
+ struct property_info *info;
+
+ DBG("%s path %s %s", modem->path, path, interface);
+
+ if (modem->call_get_properties) {
+ connman_error("Pending GetProperties");
+ return -EBUSY;
+ }
+
+ message = dbus_message_new_method_call(OFONO_SERVICE, path,
+ interface, GET_PROPERTIES);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &modem->call_get_properties, TIMEOUT)) {
+ connman_error("Failed to call %s.GetProperties()", interface);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!modem->call_get_properties) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ info = g_try_new0(struct property_info, 1);
+ if (!info) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ info->modem = modem;
+ info->path = path;
+ info->interface = interface;
+ info->get_properties_cb = notify;
+
+ dbus_pending_call_set_notify(modem->call_get_properties,
+ get_properties_reply, info, g_free);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static void context_set_active_reply(struct modem_data *modem,
+ bool success)
+{
+ DBG("%s", modem->path);
+
+ if (success) {
+ /*
+ * Don't handle do anything on success here. oFono will send
+ * the change via PropertyChanged singal.
+ */
+ return;
+ }
+
+ /*
+ * Active = True might fail due a timeout. That means oFono
+ * still tries to go online. If we retry to set Active = True,
+ * we just get a InProgress error message. Should we power
+ * cycle the modem in such cases?
+ */
+
+ if (!modem->network) {
+ /*
+ * In the case where we power down the device
+ * we don't wait for the reply, therefore the network
+ * might already be gone.
+ */
+ return;
+ }
+
+ connman_network_set_error(modem->network,
+ CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
+}
+
+static int context_set_active(struct modem_data *modem,
+ dbus_bool_t active)
+{
+ int err;
+
+ DBG("%s active %d", modem->path, active);
+
+ err = set_property(modem, modem->context->path,
+ OFONO_CONTEXT_INTERFACE,
+ "Active", DBUS_TYPE_BOOLEAN,
+ &active,
+ context_set_active_reply);
+
+ if (!active && err == -EINPROGRESS)
+ return 0;
+
+ return err;
+}
+
+static void cdma_cm_set_powered_reply(struct modem_data *modem,
+ bool success)
+{
+ DBG("%s", modem->path);
+
+ if (success) {
+ /*
+ * Don't handle do anything on success here. oFono will send
+ * the change via PropertyChanged singal.
+ */
+ return;
+ }
+
+ /*
+ * Powered = True might fail due a timeout. That means oFono
+ * still tries to go online. If we retry to set Powered = True,
+ * we just get a InProgress error message. Should we power
+ * cycle the modem in such cases?
+ */
+
+ if (!modem->network) {
+ /*
+ * In the case where we power down the device
+ * we don't wait for the reply, therefore the network
+ * might already be gone.
+ */
+ return;
+ }
+
+ connman_network_set_error(modem->network,
+ CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL);
+}
+
+static int cdma_cm_set_powered(struct modem_data *modem, dbus_bool_t powered)
+{
+ int err;
+
+ DBG("%s powered %d", modem->path, powered);
+
+ err = set_property(modem, modem->path, OFONO_CDMA_CM_INTERFACE,
+ "Powered", DBUS_TYPE_BOOLEAN,
+ &powered,
+ cdma_cm_set_powered_reply);
+
+ if (!powered && err == -EINPROGRESS)
+ return 0;
+
+ return err;
+}
+
+static int modem_set_online(struct modem_data *modem, dbus_bool_t online)
+{
+ DBG("%s online %d", modem->path, online);
+
+ return set_property(modem, modem->path,
+ OFONO_MODEM_INTERFACE,
+ "Online", DBUS_TYPE_BOOLEAN,
+ &online,
+ NULL);
+}
+
+static int cm_set_powered(struct modem_data *modem, dbus_bool_t powered)
+{
+ int err;
+
+ DBG("%s powered %d", modem->path, powered);
+
+ err = set_property(modem, modem->path,
+ OFONO_CM_INTERFACE,
+ "Powered", DBUS_TYPE_BOOLEAN,
+ &powered,
+ NULL);
+
+ if (!powered && err == -EINPROGRESS)
+ return 0;
+
+ return err;
+}
+
+static int modem_set_powered(struct modem_data *modem, dbus_bool_t powered)
+{
+ int err;
+
+ DBG("%s powered %d", modem->path, powered);
+
+ modem->set_powered = powered;
+
+ err = set_property(modem, modem->path,
+ OFONO_MODEM_INTERFACE,
+ "Powered", DBUS_TYPE_BOOLEAN,
+ &powered,
+ NULL);
+
+ if (!powered && err == -EINPROGRESS)
+ return 0;
+
+ return err;
+}
+
+static bool has_interface(uint8_t interfaces,
+ enum ofono_api api)
+{
+ if ((interfaces & api) == api)
+ return true;
+
+ return false;
+}
+
+static uint8_t extract_interfaces(DBusMessageIter *array)
+{
+ DBusMessageIter entry;
+ uint8_t interfaces = 0;
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *name;
+
+ dbus_message_iter_get_basic(&entry, &name);
+
+ if (g_str_equal(name, OFONO_SIM_INTERFACE))
+ interfaces |= OFONO_API_SIM;
+ else if (g_str_equal(name, OFONO_NETREG_INTERFACE))
+ interfaces |= OFONO_API_NETREG;
+ else if (g_str_equal(name, OFONO_CM_INTERFACE))
+ interfaces |= OFONO_API_CM;
+ else if (g_str_equal(name, OFONO_CDMA_CM_INTERFACE))
+ interfaces |= OFONO_API_CDMA_CM;
+ else if (g_str_equal(name, OFONO_CDMA_NETREG_INTERFACE))
+ interfaces |= OFONO_API_CDMA_NETREG;
+
+ dbus_message_iter_next(&entry);
+ }
+
+ return interfaces;
+}
+
+static char *extract_nameservers(DBusMessageIter *array)
+{
+ DBusMessageIter entry;
+ char *nameservers = NULL;
+ char *tmp;
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *nameserver;
+
+ dbus_message_iter_get_basic(&entry, &nameserver);
+
+ if (!nameservers) {
+ nameservers = g_strdup(nameserver);
+ } else {
+ tmp = nameservers;
+ nameservers = g_strdup_printf("%s %s", tmp, nameserver);
+ g_free(tmp);
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ return nameservers;
+}
+
+static void extract_ipv4_settings(DBusMessageIter *array,
+ struct network_context *context)
+{
+ DBusMessageIter dict;
+ char *address = NULL, *netmask = NULL, *gateway = NULL;
+ char *nameservers = NULL;
+ const char *interface = NULL;
+ int index = -1;
+
+ connman_ipaddress_free(context->ipv4_address);
+ context->ipv4_address = NULL;
+ context->index = -1;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key, *val;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Interface")) {
+ dbus_message_iter_get_basic(&value, &interface);
+
+ DBG("Interface %s", interface);
+
+ index = connman_inet_ifindex(interface);
+
+ DBG("index %d", index);
+ } else if (g_str_equal(key, "Method")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ DBG("Method %s", val);
+
+ if (g_strcmp0(val, "static") == 0)
+ context->ipv4_method = CONNMAN_IPCONFIG_METHOD_FIXED;
+ else if (g_strcmp0(val, "dhcp") == 0)
+ context->ipv4_method = CONNMAN_IPCONFIG_METHOD_DHCP;
+
+ } else if (g_str_equal(key, "Address")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ address = g_strdup(val);
+
+ DBG("Address %s", address);
+ } else if (g_str_equal(key, "Netmask")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ netmask = g_strdup(val);
+
+ DBG("Netmask %s", netmask);
+ } else if (g_str_equal(key, "DomainNameServers")) {
+ nameservers = extract_nameservers(&value);
+
+ DBG("Nameservers %s", nameservers);
+ } else if (g_str_equal(key, "Gateway")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ gateway = g_strdup(val);
+
+ DBG("Gateway %s", gateway);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (index < 0)
+ goto out;
+
+ context->index = index;
+
+ if (context->ipv4_method != CONNMAN_IPCONFIG_METHOD_FIXED)
+ goto out;
+
+ context->ipv4_address = connman_ipaddress_alloc(CONNMAN_IPCONFIG_TYPE_IPV4);
+ if (!context->ipv4_address) {
+ context->index = -1;
+ goto out;
+ }
+
+ connman_ipaddress_set_ipv4(context->ipv4_address, address,
+ netmask, gateway);
+
+ g_free(context->ipv4_nameservers);
+ context->ipv4_nameservers = nameservers;
+
+out:
+ if (context->ipv4_nameservers != nameservers)
+ g_free(nameservers);
+
+ g_free(address);
+ g_free(netmask);
+ g_free(gateway);
+}
+
+static void extract_ipv6_settings(DBusMessageIter *array,
+ struct network_context *context)
+{
+ DBusMessageIter dict;
+ char *address = NULL, *gateway = NULL;
+ unsigned char prefix_length = 0;
+ char *nameservers = NULL;
+ const char *interface = NULL;
+ int index = -1;
+
+ connman_ipaddress_free(context->ipv6_address);
+ context->ipv6_address = NULL;
+ context->index = -1;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key, *val;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Interface")) {
+ dbus_message_iter_get_basic(&value, &interface);
+
+ DBG("Interface %s", interface);
+
+ index = connman_inet_ifindex(interface);
+
+ DBG("index %d", index);
+ } else if (g_str_equal(key, "Address")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ address = g_strdup(val);
+
+ DBG("Address %s", address);
+ } else if (g_str_equal(key, "PrefixLength")) {
+ dbus_message_iter_get_basic(&value, &prefix_length);
+
+ DBG("prefix length %d", prefix_length);
+ } else if (g_str_equal(key, "DomainNameServers")) {
+ nameservers = extract_nameservers(&value);
+
+ DBG("Nameservers %s", nameservers);
+ } else if (g_str_equal(key, "Gateway")) {
+ dbus_message_iter_get_basic(&value, &val);
+
+ gateway = g_strdup(val);
+
+ DBG("Gateway %s", gateway);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (index < 0)
+ goto out;
+
+ context->ipv6_method = CONNMAN_IPCONFIG_METHOD_AUTO;
+
+ context->ipv6_address =
+ connman_ipaddress_alloc(CONNMAN_IPCONFIG_TYPE_IPV6);
+ if (!context->ipv6_address)
+ goto out;
+
+ context->index = index;
+ connman_ipaddress_set_ipv6(context->ipv6_address, address,
+ prefix_length, gateway);
+
+ g_free(context->ipv6_nameservers);
+ context->ipv6_nameservers = nameservers;
+
+out:
+ if (context->ipv6_nameservers != nameservers)
+ g_free(nameservers);
+
+ g_free(address);
+ g_free(gateway);
+}
+
+static void update_device_ident(struct connman_device *device, struct modem_data *modem)
+{
+ const char unknown_ident[] = "UNKNOWN";
+ char *ident = NULL;
+
+ if (!device)
+ return;
+
+ if (modem->imsi)
+ ident = modem->imsi;
+ else if (modem->serial)
+ ident = modem->serial;
+ else
+ ident = unknown_ident;
+
+ if (!connman_dbus_validate_ident(ident))
+ ident = connman_dbus_encode_string(ident);
+ else
+ ident = g_strdup(ident);
+
+ connman_device_set_ident(device, ident);
+
+ g_free(ident);
+}
+
+static void create_device(struct modem_data *modem)
+{
+ struct connman_device *device;
+
+ DBG("%s", modem->path);
+
+ device = connman_device_create("ofono", CONNMAN_DEVICE_TYPE_CELLULAR);
+ if (!device)
+ goto out;
+
+ DBG("device %p", device);
+
+ update_device_ident(device, modem);
+
+ connman_device_set_string(device, "Path", modem->path);
+
+ connman_device_set_data(device, modem);
+
+ if (connman_device_register(device) < 0) {
+ connman_error("Failed to register cellular device");
+ connman_device_unref(device);
+ goto out;
+ }
+
+ modem->device = device;
+
+ connman_device_set_powered(modem->device, modem->online);
+
+out:
+ return;
+}
+
+static void destroy_device(struct modem_data *modem)
+{
+ DBG("%s", modem->path);
+
+ connman_device_set_powered(modem->device, false);
+
+ if (modem->network) {
+ connman_device_remove_network(modem->device, modem->network);
+ connman_network_unref(modem->network);
+ modem->network = NULL;
+ }
+
+ connman_device_unregister(modem->device);
+ connman_device_unref(modem->device);
+
+ modem->device = NULL;
+}
+
+static void add_network(struct modem_data *modem)
+{
+ const char *group;
+
+ DBG("%s", modem->path);
+
+ if (modem->network)
+ return;
+
+ modem->network = connman_network_create(modem->context->path,
+ CONNMAN_NETWORK_TYPE_CELLULAR);
+ if (!modem->network)
+ return;
+
+ DBG("network %p", modem->network);
+
+ connman_network_set_data(modem->network, modem);
+
+ connman_network_set_string(modem->network, "Path",
+ modem->context->path);
+
+ if (modem->name)
+ connman_network_set_name(modem->network, modem->name);
+ else
+ connman_network_set_name(modem->network, "");
+
+ connman_network_set_strength(modem->network, modem->strength);
+
+ group = get_ident(modem->context->path);
+ connman_network_set_group(modem->network, group);
+
+ connman_network_set_bool(modem->network, "Roaming",
+ modem->roaming);
+
+ if (connman_device_add_network(modem->device, modem->network) < 0) {
+ connman_network_unref(modem->network);
+ modem->network = NULL;
+ return;
+ }
+}
+
+static void remove_network(struct modem_data *modem)
+{
+ DBG("%s", modem->path);
+
+ if (!modem->network)
+ return;
+
+ DBG("network %p", modem->network);
+
+ connman_device_remove_network(modem->device, modem->network);
+ connman_network_unref(modem->network);
+ modem->network = NULL;
+}
+
+static int set_context_ipconfig(struct network_context *context,
+ const char *protocol)
+{
+ DBG("context %p protocol %s", context, protocol);
+
+ if (!context || !protocol)
+ return -EINVAL;
+
+ if (g_str_equal(protocol, "ip")) {
+ if (context->ipv4_method == CONNMAN_IPCONFIG_METHOD_OFF)
+ context->ipv4_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+
+ context->ipv6_method = CONNMAN_IPCONFIG_METHOD_OFF;
+
+ connman_ipaddress_free(context->ipv6_address);
+ context->ipv6_address = NULL;
+
+ } else if (g_str_equal(protocol, "ipv6")) {
+ if (context->ipv6_method == CONNMAN_IPCONFIG_METHOD_OFF)
+ context->ipv6_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+
+ context->ipv4_method = CONNMAN_IPCONFIG_METHOD_OFF;
+
+ connman_ipaddress_free(context->ipv4_address);
+ context->ipv4_address = NULL;
+
+ } else if (g_str_equal(protocol, "dual")) {
+ if (context->ipv4_method == CONNMAN_IPCONFIG_METHOD_OFF)
+ context->ipv4_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+
+ if (context->ipv6_method == CONNMAN_IPCONFIG_METHOD_OFF)
+ context->ipv6_method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ }
+
+ DBG("ipv4 method %d ipv6 method %d", context->ipv4_method,
+ context->ipv6_method);
+
+ return 0;
+}
+
+static int add_cm_context(struct modem_data *modem, const char *context_path,
+ DBusMessageIter *dict)
+{
+ const char *context_type = NULL;
+ struct network_context *context = NULL;
+ dbus_bool_t active = FALSE;
+ const char *ip_protocol = NULL;
+
+ DBG("%s context path %s", modem->path, context_path);
+
+ if (modem->context) {
+ /*
+ * We have already assigned a context to this modem
+ * and we do only support one Internet context.
+ */
+ return -EALREADY;
+ }
+
+ context = network_context_alloc(context_path);
+ if (!context)
+ return -ENOMEM;
+
+ while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Type")) {
+ dbus_message_iter_get_basic(&value, &context_type);
+
+ DBG("%s context %s type %s", modem->path,
+ context_path, context_type);
+ } else if (g_str_equal(key, "Settings")) {
+ DBG("%s Settings", modem->path);
+
+ extract_ipv4_settings(&value, context);
+ } else if (g_str_equal(key, "IPv6.Settings")) {
+ DBG("%s IPv6.Settings", modem->path);
+
+ extract_ipv6_settings(&value, context);
+ } else if (g_str_equal(key, "Active")) {
+ dbus_message_iter_get_basic(&value, &active);
+
+ DBG("%s Active %d", modem->path, active);
+ } else if (g_str_equal(key, "AccessPointName")) {
+ const char *apn;
+
+ dbus_message_iter_get_basic(&value, &apn);
+ if (apn && strlen(apn) > 0)
+ modem->valid_apn = true;
+ else
+ modem->valid_apn = false;
+
+ DBG("%s AccessPointName '%s'", modem->path, apn);
+ } else if (g_str_equal(key, "Protocol") &&
+ dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING ) {
+
+ dbus_message_iter_get_basic(&value, &ip_protocol);
+
+ DBG("%s Protocol %s", modem->path, ip_protocol);
+ }
+
+ dbus_message_iter_next(dict);
+ }
+
+ if (g_strcmp0(context_type, "internet") != 0) {
+ network_context_free(context);
+ return -EINVAL;
+ }
+
+ if (ip_protocol)
+ set_context_ipconfig(context, ip_protocol);
+
+ modem->context = context;
+ modem->active = active;
+
+ g_hash_table_replace(context_hash, g_strdup(context_path), modem);
+
+ if (modem->valid_apn && modem->attached &&
+ has_interface(modem->interfaces,
+ OFONO_API_NETREG)) {
+ add_network(modem);
+ }
+
+ return 0;
+}
+
+static void remove_cm_context(struct modem_data *modem,
+ const char *context_path)
+{
+ if (!modem->context)
+ return;
+
+ if (modem->network)
+ remove_network(modem);
+
+ g_hash_table_remove(context_hash, context_path);
+
+ network_context_free(modem->context);
+ modem->context = NULL;
+
+ modem->valid_apn = false;
+
+ if (modem->network)
+ remove_network(modem);
+}
+
+static gboolean context_changed(DBusConnection *conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ const char *context_path = dbus_message_get_path(message);
+ struct modem_data *modem = NULL;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ DBG("context_path %s", context_path);
+
+ modem = g_hash_table_lookup(context_hash, context_path);
+ if (!modem)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ /*
+ * oFono guarantees the ordering of Settings and
+ * Active. Settings will always be send before Active = True.
+ * That means we don't have to order here.
+ */
+ if (g_str_equal(key, "Settings")) {
+ DBG("%s Settings", modem->path);
+
+ extract_ipv4_settings(&value, modem->context);
+ } else if (g_str_equal(key, "IPv6.Settings")) {
+ DBG("%s IPv6.Settings", modem->path);
+
+ extract_ipv6_settings(&value, modem->context);
+ } else if (g_str_equal(key, "Active")) {
+ dbus_bool_t active;
+
+ dbus_message_iter_get_basic(&value, &active);
+ modem->active = active;
+
+ DBG("%s Active %d", modem->path, modem->active);
+
+ if (modem->active)
+ set_connected(modem);
+ else
+ set_disconnected(modem);
+ } else if (g_str_equal(key, "AccessPointName")) {
+ const char *apn;
+
+ dbus_message_iter_get_basic(&value, &apn);
+
+ DBG("%s AccessPointName %s", modem->path, apn);
+
+ if (apn && strlen(apn) > 0) {
+ modem->valid_apn = true;
+
+ if (modem->network)
+ return TRUE;
+
+ if (!modem->attached)
+ return TRUE;
+
+ if (!has_interface(modem->interfaces,
+ OFONO_API_NETREG))
+ return TRUE;
+
+ add_network(modem);
+
+ if (modem->active)
+ set_connected(modem);
+ } else {
+ modem->valid_apn = false;
+
+ if (!modem->network)
+ return TRUE;
+
+ remove_network(modem);
+ }
+
+ } else if (g_str_equal(key, "Protocol") &&
+ dbus_message_iter_get_arg_type(&value) == DBUS_TYPE_STRING ) {
+ const char *ip_protocol;
+
+ dbus_message_iter_get_basic(&value, &ip_protocol);
+
+ set_context_ipconfig(modem->context, ip_protocol);
+ }
+
+ return TRUE;
+}
+
+static void cm_get_contexts_reply(DBusPendingCall *call, void *user_data)
+{
+ struct modem_data *modem = user_data;
+ DBusMessageIter array, dict, entry, value;
+ DBusMessage *reply;
+ DBusError error;
+
+ DBG("%s", modem->path);
+
+ modem->call_get_contexts = NULL;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_iter_init(reply, &array))
+ goto done;
+
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
+ goto done;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
+ const char *context_path;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &context_path);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (add_cm_context(modem, context_path, &value) == 0)
+ break;
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int cm_get_contexts(struct modem_data *modem)
+{
+ DBusMessage *message;
+
+ DBG("%s", modem->path);
+
+ if (modem->call_get_contexts)
+ return -EBUSY;
+
+ message = dbus_message_new_method_call(OFONO_SERVICE, modem->path,
+ OFONO_CM_INTERFACE, GET_CONTEXTS);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &modem->call_get_contexts, TIMEOUT)) {
+ connman_error("Failed to call GetContexts()");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!modem->call_get_contexts) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(modem->call_get_contexts,
+ cm_get_contexts_reply,
+ modem, NULL);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static gboolean cm_context_added(DBusConnection *conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ char *context_path;
+ struct modem_data *modem;
+ DBusMessageIter iter, properties;
+
+ DBG("%s", path);
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &context_path);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &properties);
+
+ if (add_cm_context(modem, context_path, &properties) != 0)
+ return TRUE;
+
+ return TRUE;
+}
+
+static gboolean cm_context_removed(DBusConnection *conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ const char *context_path;
+ struct modem_data *modem;
+ DBusMessageIter iter;
+
+ DBG("context path %s", path);
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &context_path);
+
+ modem = g_hash_table_lookup(context_hash, context_path);
+ if (!modem)
+ return TRUE;
+
+ remove_cm_context(modem, context_path);
+
+ return TRUE;
+}
+
+static void netreg_update_name(struct modem_data *modem,
+ DBusMessageIter* value)
+{
+ char *name;
+
+ dbus_message_iter_get_basic(value, &name);
+
+ DBG("%s Name %s", modem->path, name);
+
+ g_free(modem->name);
+ modem->name = g_strdup(name);
+
+ if (!modem->network)
+ return;
+
+ connman_network_set_name(modem->network, modem->name);
+ connman_network_update(modem->network);
+}
+
+static void netreg_update_strength(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ dbus_message_iter_get_basic(value, &modem->strength);
+
+ DBG("%s Strength %d", modem->path, modem->strength);
+
+ if (!modem->network)
+ return;
+
+ /*
+ * GSM:
+ * We don't have 2 signal notifications we always report the strength
+ * signal. data_strength is always equal to 0.
+ *
+ * CDMA:
+ * In the case we have a data_strength signal (from 1xEVDO network)
+ * we don't need to update the value with strength signal (from 1xCDMA)
+ * because the modem is registered to 1xEVDO network for data call.
+ * In case we have no data_strength signal (not registered to 1xEVDO
+ * network), we must report the strength signal (registered to 1xCDMA
+ * network e.g slow mode).
+ */
+ if (modem->data_strength != 0)
+ return;
+
+ connman_network_set_strength(modem->network, modem->strength);
+ connman_network_update(modem->network);
+}
+
+/* Retrieve 1xEVDO Data Strength signal */
+static void netreg_update_datastrength(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ dbus_message_iter_get_basic(value, &modem->data_strength);
+
+ DBG("%s Data Strength %d", modem->path, modem->data_strength);
+
+ if (!modem->network)
+ return;
+
+ /*
+ * CDMA modem is not registered to 1xEVDO network, let
+ * update_signal_strength() reporting the value on the Strength signal
+ * notification.
+ */
+ if (modem->data_strength == 0)
+ return;
+
+ connman_network_set_strength(modem->network, modem->data_strength);
+ connman_network_update(modem->network);
+}
+
+static void netreg_update_status(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ char *status;
+ bool roaming;
+
+ dbus_message_iter_get_basic(value, &status);
+
+ roaming = g_str_equal(status, "roaming");
+ modem->registered = roaming || g_str_equal(status, "registered");
+
+ if (roaming == modem->roaming)
+ return;
+
+ modem->roaming = roaming;
+
+ if (!modem->network)
+ return;
+
+ connman_network_set_bool(modem->network,
+ "Roaming", modem->roaming);
+ connman_network_update(modem->network);
+}
+
+static void netreg_update_regdom(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ char *mobile_country_code;
+ char *alpha2;
+ int mcc;
+
+ dbus_message_iter_get_basic(value, &mobile_country_code);
+
+ DBG("%s MobileContryCode %s", modem->path, mobile_country_code);
+
+
+ mcc = atoi(mobile_country_code);
+ if (mcc > 799 || mcc < 200)
+ return;
+
+ alpha2 = mcc_country_codes[mcc - 200];
+ if (alpha2)
+ connman_technology_set_regdom(alpha2);
+}
+
+static gboolean netreg_changed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct modem_data *modem;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (modem->ignore)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Name"))
+ netreg_update_name(modem, &value);
+ else if (g_str_equal(key, "Strength"))
+ netreg_update_strength(modem, &value);
+ else if (g_str_equal(key, "Status"))
+ netreg_update_status(modem, &value);
+ else if (g_str_equal(key, "MobileCountryCode"))
+ netreg_update_regdom(modem, &value);
+
+ return TRUE;
+}
+
+static void netreg_properties_reply(struct modem_data *modem,
+ DBusMessageIter *dict)
+{
+ DBG("%s", modem->path);
+
+ while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Name"))
+ netreg_update_name(modem, &value);
+ else if (g_str_equal(key, "Strength"))
+ netreg_update_strength(modem, &value);
+ else if (g_str_equal(key, "Status"))
+ netreg_update_status(modem, &value);
+ else if (g_str_equal(key, "MobileCountryCode"))
+ netreg_update_regdom(modem, &value);
+
+ dbus_message_iter_next(dict);
+ }
+
+ if (!modem->context) {
+ /*
+ * netgreg_get_properties() was issued after we got
+ * cm_get_contexts_reply() where we create the
+ * context. Though before we got the
+ * netreg_properties_reply the context was removed
+ * again. Therefore we have to skip the network
+ * creation.
+ */
+ return;
+ }
+
+ if (modem->valid_apn)
+ add_network(modem);
+
+ if (modem->active)
+ set_connected(modem);
+}
+
+static int netreg_get_properties(struct modem_data *modem)
+{
+ return get_properties(modem->path, OFONO_NETREG_INTERFACE,
+ netreg_properties_reply, modem);
+}
+
+static void add_cdma_network(struct modem_data *modem)
+{
+ /* Be sure that device is created before adding CDMA network */
+ if (!modem->device)
+ return;
+
+ /*
+ * CDMA modems don't need contexts for data call, however the current
+ * add_network() logic needs one, so we create one to proceed.
+ */
+ if (!modem->context)
+ modem->context = network_context_alloc(modem->path);
+
+ if (!modem->name)
+ modem->name = g_strdup("CDMA Network");
+
+ add_network(modem);
+
+ if (modem->cdma_cm_powered)
+ set_connected(modem);
+}
+
+static gboolean cdma_netreg_changed(DBusConnection *conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct modem_data *modem;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ DBG("");
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (modem->ignore)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Name"))
+ netreg_update_name(modem, &value);
+ else if (g_str_equal(key, "Strength"))
+ netreg_update_strength(modem, &value);
+ else if (g_str_equal(key, "DataStrength"))
+ netreg_update_datastrength(modem, &value);
+ else if (g_str_equal(key, "Status"))
+ netreg_update_status(modem, &value);
+
+ if (modem->registered)
+ add_cdma_network(modem);
+ else
+ remove_network(modem);
+
+ return TRUE;
+}
+
+static void cdma_netreg_properties_reply(struct modem_data *modem,
+ DBusMessageIter *dict)
+{
+ DBG("%s", modem->path);
+
+ while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Name"))
+ netreg_update_name(modem, &value);
+ else if (g_str_equal(key, "Strength"))
+ netreg_update_strength(modem, &value);
+ else if (g_str_equal(key, "DataStrength"))
+ netreg_update_datastrength(modem, &value);
+ else if (g_str_equal(key, "Status"))
+ netreg_update_status(modem, &value);
+
+ dbus_message_iter_next(dict);
+ }
+
+ if (modem->registered)
+ add_cdma_network(modem);
+ else
+ remove_network(modem);
+}
+
+static int cdma_netreg_get_properties(struct modem_data *modem)
+{
+ return get_properties(modem->path, OFONO_CDMA_NETREG_INTERFACE,
+ cdma_netreg_properties_reply, modem);
+}
+
+static void cm_update_attached(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ dbus_bool_t attached;
+
+ dbus_message_iter_get_basic(value, &attached);
+ modem->attached = attached;
+
+ DBG("%s Attached %d", modem->path, modem->attached);
+
+ if (!modem->attached) {
+ remove_network(modem);
+ return;
+ }
+
+ if (!has_interface(modem->interfaces, OFONO_API_NETREG))
+ return;
+
+ netreg_get_properties(modem);
+}
+
+static void cm_update_powered(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ dbus_bool_t cm_powered;
+
+ dbus_message_iter_get_basic(value, &cm_powered);
+ modem->cm_powered = cm_powered;
+
+ DBG("%s ConnnectionManager Powered %d", modem->path,
+ modem->cm_powered);
+
+ if (modem->cm_powered)
+ return;
+
+ cm_set_powered(modem, TRUE);
+}
+
+static gboolean cm_changed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct modem_data *modem;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (modem->ignore)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Attached"))
+ cm_update_attached(modem, &value);
+ else if (g_str_equal(key, "Powered"))
+ cm_update_powered(modem, &value);
+
+ return TRUE;
+}
+
+static void cdma_cm_update_powered(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ dbus_bool_t cdma_cm_powered;
+
+ dbus_message_iter_get_basic(value, &cdma_cm_powered);
+ modem->cdma_cm_powered = cdma_cm_powered;
+
+ DBG("%s CDMA cm Powered %d", modem->path, modem->cdma_cm_powered);
+
+ if (!modem->network)
+ return;
+
+ if (modem->cdma_cm_powered)
+ set_connected(modem);
+ else
+ set_disconnected(modem);
+}
+
+static void cdma_cm_update_settings(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ DBG("%s Settings", modem->path);
+
+ extract_ipv4_settings(value, modem->context);
+}
+
+static gboolean cdma_cm_changed(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct modem_data *modem;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (modem->online && !modem->network)
+ cdma_netreg_get_properties(modem);
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Powered"))
+ cdma_cm_update_powered(modem, &value);
+ if (g_str_equal(key, "Settings"))
+ cdma_cm_update_settings(modem, &value);
+
+ return TRUE;
+}
+
+static void cm_properties_reply(struct modem_data *modem, DBusMessageIter *dict)
+{
+ DBG("%s", modem->path);
+
+ while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Attached"))
+ cm_update_attached(modem, &value);
+ else if (g_str_equal(key, "Powered"))
+ cm_update_powered(modem, &value);
+
+ dbus_message_iter_next(dict);
+ }
+}
+
+static int cm_get_properties(struct modem_data *modem)
+{
+ return get_properties(modem->path, OFONO_CM_INTERFACE,
+ cm_properties_reply, modem);
+}
+
+static void cdma_cm_properties_reply(struct modem_data *modem,
+ DBusMessageIter *dict)
+{
+ DBG("%s", modem->path);
+
+ if (modem->online)
+ cdma_netreg_get_properties(modem);
+
+ while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Powered"))
+ cdma_cm_update_powered(modem, &value);
+ if (g_str_equal(key, "Settings"))
+ cdma_cm_update_settings(modem, &value);
+
+ dbus_message_iter_next(dict);
+ }
+}
+
+static int cdma_cm_get_properties(struct modem_data *modem)
+{
+ return get_properties(modem->path, OFONO_CDMA_CM_INTERFACE,
+ cdma_cm_properties_reply, modem);
+}
+
+static void sim_update_imsi(struct modem_data *modem,
+ DBusMessageIter *value)
+{
+ char *imsi;
+
+ dbus_message_iter_get_basic(value, &imsi);
+
+ DBG("%s imsi %s", modem->path, imsi);
+
+ g_free(modem->imsi);
+ modem->imsi = g_strdup(imsi);
+}
+
+static gboolean sim_changed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct modem_data *modem;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (modem->ignore)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "SubscriberIdentity")) {
+ sim_update_imsi(modem, &value);
+ /*
+ Device identifier cound be "UNKNOWN" before we have
+ SIM ID or serial num. So here we update modem device's
+ ident sinc we have a new SIM ID.
+ */
+ update_device_ident(modem->device, modem);
+ }
+
+ return TRUE;
+}
+
+static void sim_properties_reply(struct modem_data *modem,
+ DBusMessageIter *dict)
+{
+ DBG("%s", modem->path);
+
+ while (dbus_message_iter_get_arg_type(dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "SubscriberIdentity")) {
+ sim_update_imsi(modem, &value);
+ /*
+ Device identifier cound be "UNKNOWN" before we have
+ SIM ID or serial num. So here we update modem device's
+ ident sinc we have a new SIM ID.
+ */
+ update_device_ident(modem->device, modem);
+
+ if (!modem->online)
+ return;
+
+ /*
+ * The modem is already online and we have the CM interface.
+ * There will be no interface update and therefore our
+ * state machine will not go to next step. We have to
+ * trigger it from here.
+ */
+ if (has_interface(modem->interfaces, OFONO_API_CM)) {
+ cm_get_properties(modem);
+ cm_get_contexts(modem);
+ }
+ return;
+ }
+
+ dbus_message_iter_next(dict);
+ }
+}
+
+static int sim_get_properties(struct modem_data *modem)
+{
+ return get_properties(modem->path, OFONO_SIM_INTERFACE,
+ sim_properties_reply, modem);
+}
+
+static bool api_added(uint8_t old_iface, uint8_t new_iface,
+ enum ofono_api api)
+{
+ if (!has_interface(old_iface, api) &&
+ has_interface(new_iface, api)) {
+ DBG("%s added", api2string(api));
+ return true;
+ }
+
+ return false;
+}
+
+static bool api_removed(uint8_t old_iface, uint8_t new_iface,
+ enum ofono_api api)
+{
+ if (has_interface(old_iface, api) &&
+ !has_interface(new_iface, api)) {
+ DBG("%s removed", api2string(api));
+ return true;
+ }
+
+ return false;
+}
+
+static void modem_update_interfaces(struct modem_data *modem,
+ uint8_t old_ifaces,
+ uint8_t new_ifaces)
+{
+ DBG("%s", modem->path);
+
+ if (api_added(old_ifaces, new_ifaces, OFONO_API_SIM)) {
+ if (!modem->imsi &&
+ !modem->set_powered) {
+ /*
+ * Only use do GetProperties() when
+ * device has not been powered up.
+ */
+ sim_get_properties(modem);
+ }
+ }
+
+ if (api_added(old_ifaces, new_ifaces, OFONO_API_CM)) {
+ if (modem->device) {
+ cm_get_properties(modem);
+ cm_get_contexts(modem);
+ }
+ }
+
+ if (api_added(old_ifaces, new_ifaces, OFONO_API_CDMA_CM)) {
+ /*
+ Device identifier cound be "UNKNOWN" before we have
+ SIM ID or serial num. So here we update modem device's
+ ident sinc we have a new SIM ID.
+ */
+ update_device_ident(modem->device, modem);
+ if (modem->registered)
+ add_cdma_network(modem);
+
+ if (modem->device)
+ cdma_cm_get_properties(modem);
+ }
+
+ if (api_added(old_ifaces, new_ifaces, OFONO_API_NETREG)) {
+ if (modem->attached)
+ netreg_get_properties(modem);
+ }
+
+ if (api_added(old_ifaces, new_ifaces, OFONO_API_CDMA_NETREG))
+ cdma_netreg_get_properties(modem);
+
+ if (api_removed(old_ifaces, new_ifaces, OFONO_API_CM)) {
+ if (modem->call_get_contexts) {
+ DBG("cancelling pending GetContexts call");
+ dbus_pending_call_cancel(modem->call_get_contexts);
+ dbus_pending_call_unref(modem->call_get_contexts);
+ modem->call_get_contexts = NULL;
+ }
+ if (modem->context) {
+ DBG("removing context %s", modem->context->path);
+ remove_cm_context(modem, modem->context->path);
+ }
+ }
+
+ if (api_removed(old_ifaces, new_ifaces, OFONO_API_CDMA_CM))
+ remove_cm_context(modem, modem->context->path);
+
+ if (api_removed(old_ifaces, new_ifaces, OFONO_API_NETREG))
+ remove_network(modem);
+
+ if (api_removed(old_ifaces, new_ifaces, OFONO_API_CDMA_NETREG))
+ remove_network(modem);
+}
+
+static gboolean modem_changed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct modem_data *modem;
+ DBusMessageIter iter, value;
+ const char *key;
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (!modem)
+ return TRUE;
+
+ if (modem->ignore)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (g_str_equal(key, "Powered")) {
+ dbus_bool_t powered;
+
+ dbus_message_iter_get_basic(&value, &powered);
+ modem->powered = powered;
+
+ DBG("%s Powered %d", modem->path, modem->powered);
+
+ connman_device_set_powered(modem->device, modem->powered);
+
+ } else if (g_str_equal(key, "Online")) {
+ dbus_bool_t online;
+
+ dbus_message_iter_get_basic(&value, &online);
+ modem->online = online;
+
+ DBG("%s Online %d", modem->path, modem->online);
+
+ if (!modem->device)
+ return TRUE;
+ } else if (g_str_equal(key, "Interfaces")) {
+ uint8_t interfaces;
+
+ interfaces = extract_interfaces(&value);
+
+ if (interfaces == modem->interfaces)
+ return TRUE;
+
+ DBG("%s Interfaces 0x%02x", modem->path, interfaces);
+
+ modem_update_interfaces(modem, modem->interfaces, interfaces);
+
+ modem->interfaces = interfaces;
+ } else if (g_str_equal(key, "Serial")) {
+ char *serial;
+
+ dbus_message_iter_get_basic(&value, &serial);
+
+ g_free(modem->serial);
+ modem->serial = g_strdup(serial);
+
+ DBG("%s Serial %s", modem->path, modem->serial);
+
+ if (has_interface(modem->interfaces,
+ OFONO_API_CDMA_CM)) {
+ /*
+ Device identifier cound be "UNKNOWN" before we have
+ SIM ID or serial num. So here we try to update modem
+ device's ident.
+ */
+ update_device_ident(modem->device, modem);
+ if (modem->registered)
+ add_cdma_network(modem);
+ }
+ }
+
+ return TRUE;
+}
+
+static void add_modem(const char *path, DBusMessageIter *prop)
+{
+ struct modem_data *modem;
+
+ DBG("%s", path);
+
+ modem = g_hash_table_lookup(modem_hash, path);
+ if (modem) {
+ /*
+ * When oFono powers up we ask for the modems and oFono is
+ * reporting with modem_added signal the modems. Only
+ * handle them once.
+ */
+ return;
+ }
+
+ modem = g_try_new0(struct modem_data, 1);
+ if (!modem)
+ return;
+
+ modem->path = g_strdup(path);
+
+ g_hash_table_insert(modem_hash, g_strdup(path), modem);
+
+ while (dbus_message_iter_get_arg_type(prop) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(prop, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Powered")) {
+ dbus_bool_t powered;
+
+ dbus_message_iter_get_basic(&value, &powered);
+ modem->powered = powered;
+
+ DBG("%s Powered %d", modem->path, modem->powered);
+ } else if (g_str_equal(key, "Online")) {
+ dbus_bool_t online;
+
+ dbus_message_iter_get_basic(&value, &online);
+ modem->online = online;
+
+ DBG("%s Online %d", modem->path, modem->online);
+ } else if (g_str_equal(key, "Interfaces")) {
+ modem->interfaces = extract_interfaces(&value);
+
+ DBG("%s Interfaces 0x%02x", modem->path,
+ modem->interfaces);
+ } else if (g_str_equal(key, "Serial")) {
+ char *serial;
+
+ dbus_message_iter_get_basic(&value, &serial);
+ modem->serial = g_strdup(serial);
+
+ DBG("%s Serial %s", modem->path, modem->serial);
+ } else if (g_str_equal(key, "Type")) {
+ char *type;
+
+ dbus_message_iter_get_basic(&value, &type);
+
+ DBG("%s Type %s", modem->path, type);
+ if (g_strcmp0(type, "hardware") != 0) {
+ DBG("%s Ignore this modem", modem->path);
+ modem->ignore = true;
+ }
+ }
+
+ dbus_message_iter_next(prop);
+ }
+
+ if (!modem->device)
+ create_device(modem);
+
+ if (modem->ignore)
+ return;
+
+ modem_update_interfaces(modem, 0, modem->interfaces);
+}
+
+static void modem_power_down(gpointer key, gpointer value, gpointer user_data)
+{
+ struct modem_data *modem = value;
+
+ DBG("%s", modem->path);
+
+ if (modem->ignore)
+ return;
+
+ modem_set_powered(modem, FALSE);
+}
+
+static void remove_modem(gpointer data)
+{
+ struct modem_data *modem = data;
+
+ DBG("%s", modem->path);
+
+ if (modem->call_set_property) {
+ dbus_pending_call_cancel(modem->call_set_property);
+ dbus_pending_call_unref(modem->call_set_property);
+ modem->call_set_property = NULL;
+ }
+
+ if (modem->call_get_properties) {
+ dbus_pending_call_cancel(modem->call_get_properties);
+ dbus_pending_call_unref(modem->call_get_properties);
+ modem->call_get_properties = NULL;
+ }
+
+ if (modem->call_get_contexts) {
+ dbus_pending_call_cancel(modem->call_get_contexts);
+ dbus_pending_call_unref(modem->call_get_contexts);
+ modem->call_get_contexts = NULL;
+ }
+
+ if (modem->device)
+ destroy_device(modem);
+
+ if (modem->context)
+ remove_cm_context(modem, modem->context->path);
+
+ g_free(modem->serial);
+ g_free(modem->name);
+ g_free(modem->imsi);
+ g_free(modem->path);
+
+ g_free(modem);
+}
+
+static gboolean modem_added(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter, properties;
+ const char *path;
+
+ DBG("");
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &path);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &properties);
+
+ add_modem(path, &properties);
+
+ return TRUE;
+}
+
+static gboolean modem_removed(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ DBusMessageIter iter;
+ const char *path;
+
+ DBG("");
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &path);
+
+ g_hash_table_remove(modem_hash, path);
+
+ return TRUE;
+}
+
+static void manager_get_modems_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+ DBusMessageIter array, dict;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_iter_init(reply, &array))
+ goto done;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter value, properties;
+ const char *path;
+
+ dbus_message_iter_recurse(&dict, &value);
+ dbus_message_iter_get_basic(&value, &path);
+
+ dbus_message_iter_next(&value);
+ dbus_message_iter_recurse(&value, &properties);
+
+ add_modem(path, &properties);
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int manager_get_modems(void)
+{
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ DBG("");
+
+ message = dbus_message_new_method_call(OFONO_SERVICE, "/",
+ OFONO_MANAGER_INTERFACE, GET_MODEMS);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ connman_error("Failed to call GetModems()");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ connman_error("D-Bus connection not available");
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, manager_get_modems_reply,
+ NULL, NULL);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static void ofono_connect(DBusConnection *conn, void *user_data)
+{
+ DBG("");
+
+ modem_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, remove_modem);
+ if (!modem_hash)
+ return;
+
+ context_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, NULL);
+ if (!context_hash) {
+ g_hash_table_destroy(modem_hash);
+ return;
+ }
+
+ manager_get_modems();
+}
+
+static void ofono_disconnect(DBusConnection *conn, void *user_data)
+{
+ DBG("");
+
+ if (!modem_hash || !context_hash)
+ return;
+
+ g_hash_table_destroy(modem_hash);
+ modem_hash = NULL;
+
+ g_hash_table_destroy(context_hash);
+ context_hash = NULL;
+}
+
+static int network_probe(struct connman_network *network)
+{
+ struct modem_data *modem = connman_network_get_data(network);
+
+ DBG("%s network %p", modem->path, network);
+
+ return 0;
+}
+
+static void network_remove(struct connman_network *network)
+{
+ struct modem_data *modem = connman_network_get_data(network);
+
+ DBG("%s network %p", modem->path, network);
+}
+
+static int network_connect(struct connman_network *network)
+{
+ struct modem_data *modem = connman_network_get_data(network);
+
+ DBG("%s network %p", modem->path, network);
+
+ if (has_interface(modem->interfaces, OFONO_API_CM))
+ return context_set_active(modem, TRUE);
+ else if (has_interface(modem->interfaces, OFONO_API_CDMA_CM))
+ return cdma_cm_set_powered(modem, TRUE);
+
+ connman_error("Connection manager interface not available");
+
+ return -ENOSYS;
+}
+
+static int network_disconnect(struct connman_network *network, bool user_initiated)
+{
+ struct modem_data *modem = connman_network_get_data(network);
+
+ DBG("%s network %p", modem->path, network);
+
+ if (has_interface(modem->interfaces, OFONO_API_CM))
+ return context_set_active(modem, FALSE);
+ else if (has_interface(modem->interfaces, OFONO_API_CDMA_CM))
+ return cdma_cm_set_powered(modem, FALSE);
+
+ connman_error("Connection manager interface not available");
+
+ return -ENOSYS;
+}
+
+static struct connman_network_driver network_driver = {
+ .name = "cellular",
+ .type = CONNMAN_NETWORK_TYPE_CELLULAR,
+ .probe = network_probe,
+ .remove = network_remove,
+ .connect = network_connect,
+ .disconnect = network_disconnect,
+};
+
+static int modem_probe(struct connman_device *device)
+{
+ struct modem_data *modem = connman_device_get_data(device);
+
+ DBG("%s device %p", modem->path, device);
+
+ return 0;
+}
+
+static void modem_remove(struct connman_device *device)
+{
+ struct modem_data *modem = connman_device_get_data(device);
+
+ DBG("%s device %p", modem->path, device);
+}
+
+static int modem_enable(struct connman_device *device)
+{
+ struct modem_data *modem = connman_device_get_data(device);
+
+ DBG("%s device %p", modem->path, device);
+
+ if (modem->powered)
+ return 0;
+
+ return modem_set_powered(modem, TRUE);
+}
+
+static int modem_disable(struct connman_device *device)
+{
+ struct modem_data *modem = connman_device_get_data(device);
+
+ DBG("%s device %p", modem->path, device);
+
+ if (!modem->powered)
+ return 0;
+
+ return modem_set_powered(modem, FALSE);
+}
+
+static struct connman_device_driver modem_driver = {
+ .name = "modem",
+ .type = CONNMAN_DEVICE_TYPE_CELLULAR,
+ .probe = modem_probe,
+ .remove = modem_remove,
+ .enable = modem_enable,
+ .disable = modem_disable,
+};
+
+static int tech_probe(struct connman_technology *technology)
+{
+ return 0;
+}
+
+static void tech_remove(struct connman_technology *technology)
+{
+}
+
+static struct connman_technology_driver tech_driver = {
+ .name = "cellular",
+ .type = CONNMAN_SERVICE_TYPE_CELLULAR,
+ .probe = tech_probe,
+ .remove = tech_remove,
+};
+
+static guint watch;
+static guint modem_added_watch;
+static guint modem_removed_watch;
+static guint modem_watch;
+static guint cm_watch;
+static guint sim_watch;
+static guint context_added_watch;
+static guint context_removed_watch;
+static guint netreg_watch;
+static guint context_watch;
+static guint cdma_cm_watch;
+static guint cdma_netreg_watch;
+
+static int ofono_init(void)
+{
+ int err;
+
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ watch = g_dbus_add_service_watch(connection,
+ OFONO_SERVICE, ofono_connect,
+ ofono_disconnect, NULL, NULL);
+
+ modem_added_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE,
+ NULL, OFONO_MANAGER_INTERFACE,
+ MODEM_ADDED,
+ modem_added,
+ NULL, NULL);
+
+ modem_removed_watch = g_dbus_add_signal_watch(connection,
+ OFONO_SERVICE, NULL,
+ OFONO_MANAGER_INTERFACE,
+ MODEM_REMOVED,
+ modem_removed,
+ NULL, NULL);
+
+ modem_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE, NULL,
+ OFONO_MODEM_INTERFACE,
+ PROPERTY_CHANGED,
+ modem_changed,
+ NULL, NULL);
+
+ cm_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE, NULL,
+ OFONO_CM_INTERFACE,
+ PROPERTY_CHANGED,
+ cm_changed,
+ NULL, NULL);
+
+ sim_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE, NULL,
+ OFONO_SIM_INTERFACE,
+ PROPERTY_CHANGED,
+ sim_changed,
+ NULL, NULL);
+
+ context_added_watch = g_dbus_add_signal_watch(connection,
+ OFONO_SERVICE, NULL,
+ OFONO_CM_INTERFACE,
+ CONTEXT_ADDED,
+ cm_context_added,
+ NULL, NULL);
+
+ context_removed_watch = g_dbus_add_signal_watch(connection,
+ OFONO_SERVICE, NULL,
+ OFONO_CM_INTERFACE,
+ CONTEXT_REMOVED,
+ cm_context_removed,
+ NULL, NULL);
+
+ context_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE,
+ NULL, OFONO_CONTEXT_INTERFACE,
+ PROPERTY_CHANGED,
+ context_changed,
+ NULL, NULL);
+
+ netreg_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE, NULL,
+ OFONO_NETREG_INTERFACE,
+ PROPERTY_CHANGED,
+ netreg_changed,
+ NULL, NULL);
+
+ cdma_cm_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE,
+ NULL, OFONO_CDMA_CM_INTERFACE,
+ PROPERTY_CHANGED,
+ cdma_cm_changed,
+ NULL, NULL);
+
+ cdma_netreg_watch = g_dbus_add_signal_watch(connection, OFONO_SERVICE,
+ NULL, OFONO_CDMA_NETREG_INTERFACE,
+ PROPERTY_CHANGED,
+ cdma_netreg_changed,
+ NULL, NULL);
+
+
+ if (watch == 0 || modem_added_watch == 0 || modem_removed_watch == 0 ||
+ modem_watch == 0 || cm_watch == 0 || sim_watch == 0 ||
+ context_added_watch == 0 ||
+ context_removed_watch == 0 ||
+ context_watch == 0 || netreg_watch == 0 ||
+ cdma_cm_watch == 0 || cdma_netreg_watch == 0) {
+ err = -EIO;
+ goto remove;
+ }
+
+ err = connman_network_driver_register(&network_driver);
+ if (err < 0)
+ goto remove;
+
+ err = connman_device_driver_register(&modem_driver);
+ if (err < 0) {
+ connman_network_driver_unregister(&network_driver);
+ goto remove;
+ }
+
+ err = connman_technology_driver_register(&tech_driver);
+ if (err < 0) {
+ connman_device_driver_unregister(&modem_driver);
+ connman_network_driver_unregister(&network_driver);
+ goto remove;
+ }
+
+ return 0;
+
+remove:
+ g_dbus_remove_watch(connection, cdma_netreg_watch);
+ g_dbus_remove_watch(connection, cdma_cm_watch);
+ g_dbus_remove_watch(connection, netreg_watch);
+ g_dbus_remove_watch(connection, context_watch);
+ g_dbus_remove_watch(connection, context_removed_watch);
+ g_dbus_remove_watch(connection, context_added_watch);
+ g_dbus_remove_watch(connection, sim_watch);
+ g_dbus_remove_watch(connection, cm_watch);
+ g_dbus_remove_watch(connection, modem_watch);
+ g_dbus_remove_watch(connection, modem_removed_watch);
+ g_dbus_remove_watch(connection, modem_added_watch);
+ g_dbus_remove_watch(connection, watch);
+ dbus_connection_unref(connection);
+
+ return err;
+}
+
+static void ofono_exit(void)
+{
+ DBG("");
+
+ if (modem_hash) {
+ /*
+ * We should propably wait for the SetProperty() reply
+ * message, because ...
+ */
+ g_hash_table_foreach(modem_hash, modem_power_down, NULL);
+
+ /*
+ * ... here we will cancel the call.
+ */
+ g_hash_table_destroy(modem_hash);
+ modem_hash = NULL;
+ }
+
+ if (context_hash) {
+ g_hash_table_destroy(context_hash);
+ context_hash = NULL;
+ }
+
+ connman_technology_driver_unregister(&tech_driver);
+ connman_device_driver_unregister(&modem_driver);
+ connman_network_driver_unregister(&network_driver);
+
+ g_dbus_remove_watch(connection, cdma_netreg_watch);
+ g_dbus_remove_watch(connection, cdma_cm_watch);
+ g_dbus_remove_watch(connection, netreg_watch);
+ g_dbus_remove_watch(connection, context_watch);
+ g_dbus_remove_watch(connection, context_removed_watch);
+ g_dbus_remove_watch(connection, context_added_watch);
+ g_dbus_remove_watch(connection, sim_watch);
+ g_dbus_remove_watch(connection, cm_watch);
+ g_dbus_remove_watch(connection, modem_watch);
+ g_dbus_remove_watch(connection, modem_added_watch);
+ g_dbus_remove_watch(connection, modem_removed_watch);
+ g_dbus_remove_watch(connection, watch);
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(ofono, "oFono telephony plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, ofono_init, ofono_exit)
diff --git a/plugins/pacrunner.c b/plugins/pacrunner.c
new file mode 100644
index 0000000..850139f
--- /dev/null
+++ b/plugins/pacrunner.c
@@ -0,0 +1,477 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/notifier.h>
+#include <connman/dbus.h>
+#include <connman/log.h>
+#include <connman/proxy.h>
+
+#define PACRUNNER_SERVICE "org.pacrunner"
+#define PACRUNNER_INTERFACE "org.pacrunner.Manager"
+#define PACRUNNER_PATH "/org/pacrunner/manager"
+
+#define PACRUNNER_CLIENT_INTERFACE "org.pacrunner.Client"
+#define PACRUNNER_CLIENT_PATH "/org/pacrunner/client"
+
+#define DBUS_TIMEOUT 5000
+
+struct proxy_data {
+ struct connman_service *service;
+ char *url;
+};
+
+static DBusConnection *connection;
+static dbus_bool_t daemon_running = FALSE;
+
+static struct connman_service *default_service = NULL;
+static char *current_config = NULL;
+
+static void create_config_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ const char *path;
+
+ DBG("");
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ connman_error("Failed to create proxy configuration");
+ goto done;
+ }
+
+ if (!dbus_message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH,
+ &path, DBUS_TYPE_INVALID))
+ goto done;
+
+ g_free(current_config);
+ current_config = g_strdup(path);
+
+done:
+ dbus_message_unref(reply);
+}
+
+static void append_string(DBusMessageIter *iter, void *user_data)
+{
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, user_data);
+}
+
+static void append_string_list(DBusMessageIter *iter, void *user_data)
+{
+ char **list = user_data;
+ int i;
+
+ for (i = 0; list[i]; i++)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &list[i]);
+}
+
+static void create_proxy_configuration(void)
+{
+ DBusMessage *msg;
+ DBusMessageIter iter, dict;
+ DBusPendingCall *call;
+ dbus_bool_t result;
+ char *interface;
+ const char *method;
+ const char *str;
+ char **str_list;
+
+ if (!default_service)
+ return;
+
+ DBG("");
+
+ msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH,
+ PACRUNNER_INTERFACE, "CreateProxyConfiguration");
+ if (!msg)
+ return;
+
+ dbus_message_set_auto_start(msg, FALSE);
+
+ dbus_message_iter_init_append(msg, &iter);
+ connman_dbus_dict_open(&iter, &dict);
+
+ switch(connman_service_get_proxy_method(default_service)) {
+ case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
+ connman_dbus_dict_close(&iter, &dict);
+ goto done;
+ case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
+ method= "direct";
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
+ method = "manual";
+
+ str_list = connman_service_get_proxy_servers(default_service);
+ if (!str_list) {
+ connman_dbus_dict_close(&iter, &dict);
+ goto done;
+ }
+
+ connman_dbus_dict_append_array(&dict, "Servers",
+ DBUS_TYPE_STRING, append_string_list,
+ str_list);
+ g_strfreev(str_list);
+
+ str_list = connman_service_get_proxy_excludes(default_service);
+ if (!str_list)
+ break;
+
+ connman_dbus_dict_append_array(&dict, "Excludes",
+ DBUS_TYPE_STRING, append_string_list,
+ str_list);
+ g_strfreev(str_list);
+
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
+ method = "auto";
+
+ str = connman_service_get_proxy_url(default_service);
+ if (!str) {
+ str = connman_service_get_proxy_autoconfig(
+ default_service);
+ if (!str) {
+ connman_dbus_dict_close(&iter, &dict);
+ goto done;
+ }
+ }
+
+ connman_dbus_dict_append_basic(&dict, "URL",
+ DBUS_TYPE_STRING, &str);
+ break;
+ }
+
+ connman_dbus_dict_append_basic(&dict, "Method",
+ DBUS_TYPE_STRING, &method);
+
+ interface = connman_service_get_interface(default_service);
+ if (interface) {
+ connman_dbus_dict_append_basic(&dict, "Interface",
+ DBUS_TYPE_STRING, &interface);
+ g_free(interface);
+ }
+
+ str = connman_service_get_domainname(default_service);
+ if (str)
+ connman_dbus_dict_append_array(&dict, "Domains",
+ DBUS_TYPE_STRING, append_string, &str);
+
+ str_list = connman_service_get_nameservers(default_service);
+ if (str_list)
+ connman_dbus_dict_append_array(&dict, "Nameservers",
+ DBUS_TYPE_STRING, append_string_list,
+ str_list);
+ g_strfreev(str_list);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ result = dbus_connection_send_with_reply(connection, msg,
+ &call, DBUS_TIMEOUT);
+
+ if (!result || !call)
+ goto done;
+
+ dbus_pending_call_set_notify(call, create_config_reply, NULL, NULL);
+
+ dbus_pending_call_unref(call);
+
+done:
+ dbus_message_unref(msg);
+}
+
+static void destroy_config_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+
+ DBG("");
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ connman_error("Failed to destoy proxy configuration");
+
+ dbus_message_unref(reply);
+}
+
+static void destroy_proxy_configuration(void)
+{
+ DBusMessage *msg;
+ DBusPendingCall *call;
+ dbus_bool_t result;
+
+ if (!current_config)
+ return;
+
+ DBG("");
+
+ msg = dbus_message_new_method_call(PACRUNNER_SERVICE, PACRUNNER_PATH,
+ PACRUNNER_INTERFACE, "DestroyProxyConfiguration");
+ if (!msg)
+ return;
+
+ dbus_message_set_auto_start(msg, FALSE);
+
+ dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH, ¤t_config,
+ DBUS_TYPE_INVALID);
+
+ result = dbus_connection_send_with_reply(connection, msg,
+ &call, DBUS_TIMEOUT);
+
+ dbus_message_unref(msg);
+
+ if (!result || !call)
+ return;
+
+ dbus_pending_call_set_notify(call, destroy_config_reply, NULL, NULL);
+
+ dbus_pending_call_unref(call);
+
+ g_free(current_config);
+ current_config = NULL;
+}
+
+static void default_service_changed(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ if (service == default_service)
+ return;
+
+ default_service = service;
+
+ if (!daemon_running)
+ return;
+
+ destroy_proxy_configuration();
+
+ create_proxy_configuration();
+}
+
+static void proxy_changed(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ if (service != default_service)
+ return;
+
+ if (!daemon_running)
+ return;
+
+ destroy_proxy_configuration();
+
+ create_proxy_configuration();
+}
+
+static struct connman_notifier pacrunner_notifier = {
+ .name = "pacrunner",
+ .default_changed = default_service_changed,
+ .proxy_changed = proxy_changed,
+};
+
+static void pacrunner_connect(DBusConnection *conn, void *user_data)
+{
+ DBG("");
+
+ daemon_running = TRUE;
+
+ create_proxy_configuration();
+}
+
+static void pacrunner_disconnect(DBusConnection *conn, void *user_data)
+{
+ DBG("");
+
+ daemon_running = FALSE;
+
+ g_free(current_config);
+ current_config = NULL;
+}
+
+static char * parse_url(const char *url)
+{
+ char *scheme, *host, *path, *host_ret;
+
+ scheme = g_strdup(url);
+ if (!scheme)
+ return NULL;
+
+ host = strstr(scheme, "://");
+ if (host) {
+ *host = '\0';
+ host += 3;
+ } else
+ host = scheme;
+
+ path = strchr(host, '/');
+ if (path)
+ *(path++) = '\0';
+
+ host_ret = g_strdup(host);
+
+ g_free(scheme);
+
+ return host_ret;
+}
+
+static void request_lookup_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply = dbus_pending_call_steal_reply(call);
+ struct proxy_data *data = user_data;
+ const char *proxy;
+
+ DBG("");
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ connman_error("Failed to find URL:%s", data->url);
+ proxy = NULL;
+ goto done;
+ }
+
+ if (!dbus_message_get_args(reply, NULL, DBUS_TYPE_STRING,
+ &proxy, DBUS_TYPE_INVALID))
+ proxy = NULL;
+
+done:
+ connman_proxy_driver_lookup_notify(data->service, data->url, proxy);
+
+ connman_service_unref(data->service);
+
+ g_free(data->url);
+ g_free(data);
+
+ dbus_message_unref(reply);
+}
+
+static int request_lookup(struct connman_service *service, const char *url)
+{
+ DBusMessage *msg;
+ DBusPendingCall *call;
+ dbus_bool_t result;
+ char *host;
+ struct proxy_data *data;
+
+ DBG("");
+
+ msg = dbus_message_new_method_call(PACRUNNER_SERVICE,
+ PACRUNNER_CLIENT_PATH,
+ PACRUNNER_CLIENT_INTERFACE,
+ "FindProxyForURL");
+ if (!msg)
+ return -1;
+
+ host = parse_url(url);
+ if (!host) {
+ dbus_message_unref(msg);
+ return -EINVAL;
+ }
+
+ data = g_try_new0(struct proxy_data, 1);
+ if (!data) {
+ dbus_message_unref(msg);
+ g_free(host);
+ return -ENOMEM;
+ }
+
+ data->url = g_strdup(url);
+ data->service = connman_service_ref(service);
+
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &url,
+ DBUS_TYPE_STRING, &host,
+ DBUS_TYPE_INVALID);
+
+ result = dbus_connection_send_with_reply(connection, msg,
+ &call, DBUS_TIMEOUT);
+
+ dbus_message_unref(msg);
+
+ if (!result || !call) {
+ g_free(host);
+ g_free(data->url);
+ g_free(data);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, request_lookup_reply,
+ data, NULL);
+
+ dbus_pending_call_unref(call);
+ g_free(host);
+
+ return 0;
+}
+
+static void cancel_lookup(struct connman_service *service, const char *url)
+{
+ DBG("");
+}
+
+static struct connman_proxy_driver pacrunner_proxy = {
+ .name = "pacrunnerproxy",
+ .priority = CONNMAN_PROXY_PRIORITY_HIGH,
+ .request_lookup = request_lookup,
+ .cancel_lookup = cancel_lookup,
+};
+
+static guint pacrunner_watch;
+
+static int pacrunner_init(void)
+{
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ pacrunner_watch = g_dbus_add_service_watch(connection,
+ PACRUNNER_SERVICE, pacrunner_connect,
+ pacrunner_disconnect, NULL, NULL);
+ if (pacrunner_watch == 0) {
+ dbus_connection_unref(connection);
+ return -EIO;
+ }
+
+ connman_notifier_register(&pacrunner_notifier);
+
+ connman_proxy_driver_register(&pacrunner_proxy);
+
+ return 0;
+}
+
+static void pacrunner_exit(void)
+{
+ connman_proxy_driver_unregister(&pacrunner_proxy);
+
+ connman_notifier_unregister(&pacrunner_notifier);
+
+ g_dbus_remove_watch(connection, pacrunner_watch);
+
+ destroy_proxy_configuration();
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(pacrunner, "PAC runner proxy plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, pacrunner_init, pacrunner_exit)
diff --git a/plugins/polkit.c b/plugins/polkit.c
new file mode 100644
index 0000000..ae38364
--- /dev/null
+++ b/plugins/polkit.c
@@ -0,0 +1,55 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/dbus.h>
+
+static const GDBusSecurityTable polkit_security[] = {
+ { CONNMAN_PRIVILEGE_MODIFY, "net.connman.modify",
+ G_DBUS_SECURITY_FLAG_BUILTIN |
+ G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION },
+ { CONNMAN_PRIVILEGE_SECRET, "net.connman.secret",
+ G_DBUS_SECURITY_FLAG_BUILTIN |
+ G_DBUS_SECURITY_FLAG_ALLOW_INTERACTION },
+ { }
+};
+
+static int polkit_init(void)
+{
+ g_dbus_register_security(polkit_security);
+
+ return 0;
+}
+
+static void polkit_exit(void)
+{
+ g_dbus_unregister_security(polkit_security);
+}
+
+CONNMAN_PLUGIN_DEFINE(polkit, "PolicyKit authorization plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, polkit_init, polkit_exit)
diff --git a/plugins/polkit.policy b/plugins/polkit.policy
new file mode 100644
index 0000000..0de152c
--- /dev/null
+++ b/plugins/polkit.policy
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
+
+<policyconfig>
+
+ <vendor>Connection Manager</vendor>
+ <icon_name>network-wireless</icon_name>
+
+ <action id="net.connman.modify">
+ <description>Settings configuration</description>
+ <message>Policy prevents modification of settings</message>
+ <defaults>
+ <allow_inactive>no</allow_inactive>
+ <allow_active>auth_self_keep</allow_active>
+ </defaults>
+ </action>
+
+ <action id="net.connman.secret">
+ <description>Secrets configuration</description>
+ <message>Policy prevents modification of secrets</message>
+ <defaults>
+ <allow_inactive>no</allow_inactive>
+ <allow_active>auth_admin_keep</allow_active>
+ </defaults>
+ </action>
+
+</policyconfig>
diff --git a/plugins/session_policy_local.c b/plugins/session_policy_local.c
new file mode 100644
index 0000000..b2369bd
--- /dev/null
+++ b/plugins/session_policy_local.c
@@ -0,0 +1,823 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <sys/inotify.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <pwd.h>
+#include <grp.h>
+
+#include <glib.h>
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/log.h>
+#include <connman/session.h>
+#include <connman/dbus.h>
+#include <connman/inotify.h>
+
+#include "src/shared/util.h"
+
+#define POLICYDIR STORAGEDIR "/session_policy_local"
+
+#define MODE (S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | \
+ S_IXGRP | S_IROTH | S_IXOTH)
+
+static DBusConnection *connection;
+
+static GHashTable *file_hash; /* (filename, policy_file) */
+static GHashTable *session_hash; /* (connman_session, policy_config) */
+
+/* Global lookup tables for mapping sessions to policies */
+static GHashTable *selinux_hash; /* (lsm context, policy_group) */
+static GHashTable *uid_hash; /* (uid, policy_group) */
+static GHashTable *gid_hash; /* (gid, policy_group) */
+
+/*
+ * A instance of struct policy_file is created per file in
+ * POLICYDIR.
+ */
+struct policy_file {
+ /*
+ * A valid file is a keyfile with one ore more groups. All
+ * groups are keept in this list.
+ */
+ GSList *groups;
+};
+
+struct policy_group {
+ char *selinux;
+ char *uid;
+ char *gid;
+
+ /*
+ * Each policy_group owns a config and is not shared with
+ * sessions. Instead each session copies the valued from this
+ * object.
+ */
+ struct connman_session_config *config;
+
+ /* All 'users' of this policy. */
+ GSList *sessions;
+};
+
+/* A struct policy_config object is created and owned by a session. */
+struct policy_config {
+ char *selinux;
+ char *selinux_context;
+ char *uid;
+ GSList *gids;
+
+ /* The policy config owned by the session */
+ struct connman_session_config *config;
+
+ /* To which policy belongs this policy_config */
+ struct connman_session *session;
+ /*
+ * Points to the policy_group when a config has been applied
+ * from a file.
+ */
+ struct policy_group *group;
+};
+
+static void copy_session_config(struct connman_session_config *dst,
+ struct connman_session_config *src)
+{
+ g_slist_free(dst->allowed_bearers);
+ dst->allowed_bearers = g_slist_copy(src->allowed_bearers);
+ dst->ecall = src->ecall;
+ dst->type = src->type;
+ dst->roaming_policy = src->roaming_policy;
+ dst->priority = src->priority;
+}
+
+static void set_policy(struct policy_config *policy,
+ struct policy_group *group)
+{
+ DBG("policy %p group %p", policy, group);
+
+ group->sessions = g_slist_prepend(group->sessions, policy);
+ policy->group = group;
+
+ copy_session_config(policy->config, group->config);
+}
+
+static char *parse_selinux_type(const char *context)
+{
+ char *ident, **tokens;
+
+ /*
+ * SELinux combines Role-Based Access Control (RBAC), Type
+ * Enforcment (TE) and optionally Multi-Level Security (MLS).
+ *
+ * When SELinux is enabled all processes and files are labeled
+ * with a contex that contains information such as user, role
+ * type (and optionally a level). E.g.
+ *
+ * $ ls -Z
+ * -rwxrwxr-x. wagi wagi unconfined_u:object_r:haifux_exec_t:s0 session_ui.py
+ *
+ * For identifyng application we (ab)using the type
+ * information. In the above example the haifux_exec_t type
+ * will be transfered to haifux_t as defined in the domain
+ * transition and thus we are able to identify the application
+ * as haifux_t.
+ */
+
+ tokens = g_strsplit(context, ":", 0);
+ if (g_strv_length(tokens) < 2) {
+ g_strfreev(tokens);
+ return NULL;
+ }
+
+ /* Use the SELinux type as identification token. */
+ ident = g_strdup(tokens[2]);
+
+ g_strfreev(tokens);
+
+ return ident;
+}
+
+static void cleanup_config(gpointer user_data);
+
+static void finish_create(struct policy_config *policy,
+ connman_session_config_func_t cb,
+ void *user_data)
+{
+ struct policy_group *group = NULL;
+ GSList *list;
+
+ if (policy->selinux)
+ group = g_hash_table_lookup(selinux_hash, policy->selinux);
+
+ if (group) {
+ set_policy(policy, group);
+
+ policy->config->id_type = CONNMAN_SESSION_ID_TYPE_LSM;
+ policy->config->id = g_strdup(policy->selinux_context);
+ goto done;
+ }
+
+ if (policy->uid)
+ group = g_hash_table_lookup(uid_hash, policy->uid);
+
+ if (group) {
+ set_policy(policy, group);
+
+ policy->config->id_type = CONNMAN_SESSION_ID_TYPE_UID;
+ policy->config->id = g_strdup(policy->uid);
+ goto done;
+ }
+
+ for (list = policy->gids; list; list = list->next) {
+ char *gid = list->data;
+
+ group = g_hash_table_lookup(gid_hash, gid);
+ if (!group)
+ continue;
+
+ set_policy(policy, group);
+
+ policy->config->id_type = CONNMAN_SESSION_ID_TYPE_GID;
+ policy->config->id = g_strdup(gid);
+ break;
+ }
+done:
+ g_hash_table_replace(session_hash, policy->session, policy);
+
+ (*cb)(policy->session, policy->config, user_data, 0);
+}
+
+static void failed_create(struct policy_config *policy,
+ connman_session_config_func_t cb,
+ void *user_data, int err)
+{
+ (*cb)(policy->session, NULL, user_data, err);
+
+ cleanup_config(policy);
+}
+
+static void selinux_context_reply(const unsigned char *context, void *user_data,
+ int err)
+{
+ struct cb_data *cbd = user_data;
+ connman_session_config_func_t cb = cbd->cb;
+ struct policy_config *policy = cbd->data;
+ char *ident = NULL;
+
+ DBG("session %p", policy->session);
+
+ if (err == -EIO) {
+ /* No SELinux support, drop back to UID/GID only mode */
+ finish_create(policy, cb, cbd->user_data);
+ goto done;
+ }
+
+ if (err < 0) {
+ failed_create(policy, cb, cbd->user_data, err);
+ goto done;
+ }
+
+ DBG("SELinux context %s", context);
+
+ policy->selinux_context = g_strdup((const char *)context);
+ ident = parse_selinux_type(policy->selinux_context);
+ if (ident)
+ policy->selinux = g_strdup(ident);
+
+ finish_create(policy, cb, cbd->user_data);
+
+done:
+ g_free(cbd);
+ g_free(ident);
+}
+
+static void get_uid_reply(unsigned int uid, void *user_data, int err)
+{
+ struct cb_data *cbd = user_data;
+ connman_session_config_func_t cb = cbd->cb;
+ struct policy_config *policy = cbd->data;
+ const char *owner;
+ struct passwd *pwd;
+ struct group *grp;
+ gid_t *groups = NULL;
+ int nrgroups, i;
+
+ DBG("session %p uid %d", policy->session, uid);
+
+ if (err < 0) {
+ cleanup_config(policy);
+ goto err;
+ }
+
+ pwd = getpwuid((uid_t)uid);
+ if (!pwd) {
+ if (errno != 0)
+ err = -errno;
+ else
+ err = -EINVAL;
+ goto err;
+ }
+
+ policy->uid = g_strdup(pwd->pw_name);
+
+ nrgroups = 0;
+ getgrouplist(pwd->pw_name, pwd->pw_gid, NULL, &nrgroups);
+ groups = g_try_new0(gid_t, nrgroups);
+ if (!groups) {
+ err = -ENOMEM;
+ goto err;
+ }
+
+ err = getgrouplist(pwd->pw_name, pwd->pw_gid, groups, &nrgroups);
+ if (err < 0)
+ goto err;
+
+ for (i = 0; i < nrgroups; i++) {
+ grp = getgrgid(groups[i]);
+ if (!grp) {
+ if (errno != 0)
+ err = -errno;
+ else
+ err = -EINVAL;
+ goto err;
+ }
+
+ policy->gids = g_slist_prepend(policy->gids,
+ g_strdup(grp->gr_name));
+ }
+ g_free(groups);
+
+ owner = connman_session_get_owner(policy->session);
+
+ err = connman_dbus_get_selinux_context(connection, owner,
+ selinux_context_reply, cbd);
+ if (err == 0) {
+ /*
+ * We are able to ask for a SELinux context. Let's defer the
+ * creation of the session config until we get the answer
+ * from D-Bus.
+ */
+ return;
+ }
+
+ finish_create(policy, cb, cbd->user_data);
+ g_free(cbd);
+
+ return;
+
+err:
+ failed_create(NULL, cb, cbd->user_data, err);
+ g_free(cbd);
+ g_free(groups);
+}
+
+static int policy_local_create(struct connman_session *session,
+ connman_session_config_func_t cb,
+ void *user_data)
+{
+ struct cb_data *cbd = cb_data_new(cb, user_data);
+ struct policy_config *policy;
+ const char *owner;
+ int err;
+
+ DBG("session %p", session);
+
+ policy = g_new0(struct policy_config, 1);
+ policy->config = connman_session_create_default_config();
+ policy->session = session;
+
+ cbd->data = policy;
+
+ owner = connman_session_get_owner(session);
+
+ err = connman_dbus_get_connection_unix_user(connection, owner,
+ get_uid_reply, cbd);
+ if (err < 0) {
+ connman_error("Could not get UID");
+ cleanup_config(policy);
+ g_free(cbd);
+ return err;
+ }
+
+ return 0;
+}
+
+static void policy_local_destroy(struct connman_session *session)
+{
+ struct policy_data *policy;
+
+ DBG("session %p", session);
+
+ policy = g_hash_table_lookup(session_hash, session);
+ if (!policy)
+ return;
+
+ g_hash_table_remove(session_hash, session);
+}
+
+static struct connman_session_policy session_policy_local = {
+ .name = "session local policy configuration",
+ .priority = CONNMAN_SESSION_POLICY_PRIORITY_DEFAULT,
+ .create = policy_local_create,
+ .destroy = policy_local_destroy,
+};
+
+static int load_keyfile(const char *pathname, GKeyFile **keyfile)
+{
+ GError *error = NULL;
+ int err;
+
+ *keyfile = g_key_file_new();
+
+ if (!g_key_file_load_from_file(*keyfile, pathname, 0, &error))
+ goto err;
+
+ return 0;
+
+err:
+ /*
+ * The fancy G_FILE_ERROR_* codes are identical to the native
+ * error codes.
+ */
+ err = -error->code;
+
+ DBG("Unable to load %s: %s", pathname, error->message);
+ g_clear_error(&error);
+
+ g_key_file_free(*keyfile);
+ *keyfile = NULL;
+
+ return err;
+}
+
+static int load_policy(GKeyFile *keyfile, const char *groupname,
+ struct policy_group *group)
+{
+ struct connman_session_config *config = group->config;
+ char *str, **tokens;
+ int i, err = 0;
+
+ group->selinux = g_key_file_get_string(keyfile, groupname,
+ "selinux", NULL);
+
+ group->gid = g_key_file_get_string(keyfile, groupname,
+ "gid", NULL);
+
+ group->uid = g_key_file_get_string(keyfile, groupname,
+ "uid", NULL);
+
+ if (!group->selinux && !group->gid && !group->uid)
+ return -EINVAL;
+
+ config->priority = g_key_file_get_boolean(keyfile, groupname,
+ "Priority", NULL);
+
+ str = g_key_file_get_string(keyfile, groupname, "RoamingPolicy",
+ NULL);
+ if (str) {
+ config->roaming_policy = connman_session_parse_roaming_policy(str);
+ g_free(str);
+ }
+
+ str = g_key_file_get_string(keyfile, groupname, "ConnectionType",
+ NULL);
+ if (str) {
+ config->type = connman_session_parse_connection_type(str);
+ g_free(str);
+ }
+
+ config->ecall = g_key_file_get_boolean(keyfile, groupname,
+ "EmergencyCall", NULL);
+
+ str = g_key_file_get_string(keyfile, groupname, "AllowedBearers",
+ NULL);
+ if (str) {
+ tokens = g_strsplit(str, " ", 0);
+
+ for (i = 0; tokens[i]; i++) {
+ err = connman_session_parse_bearers(tokens[i],
+ &config->allowed_bearers);
+ if (err < 0)
+ break;
+ }
+
+ g_free(str);
+ g_strfreev(tokens);
+ }
+
+ DBG("group %p selinux %s uid %s gid %s", group, group->selinux,
+ group->uid, group->gid);
+
+ return err;
+}
+
+static void update_session(struct policy_config *policy)
+{
+ DBG("policy %p session %p", policy, policy->session);
+
+ if (!policy->session)
+ return;
+
+ if (connman_session_config_update(policy->session) < 0)
+ connman_session_destroy(policy->session);
+}
+
+static void set_default_config(gpointer user_data)
+{
+ struct policy_config *policy = user_data;
+
+ connman_session_set_default_config(policy->config);
+ policy->group = NULL;
+ update_session(policy);
+}
+
+static void cleanup_config(gpointer user_data)
+{
+ struct policy_config *policy = user_data;
+
+ DBG("policy %p group %p", policy, policy->group);
+
+ if (policy->group)
+ policy->group->sessions =
+ g_slist_remove(policy->group->sessions, policy);
+
+ g_slist_free(policy->config->allowed_bearers);
+ g_free(policy->config->id);
+ g_free(policy->config);
+ g_free(policy->selinux_context);
+ g_free(policy->selinux);
+ g_free(policy->uid);
+ g_slist_free_full(policy->gids, g_free);
+ g_free(policy);
+}
+
+static void cleanup_group(gpointer user_data)
+{
+ struct policy_group *group = user_data;
+
+ DBG("group %p", group);
+
+ g_slist_free_full(group->sessions, set_default_config);
+
+ g_slist_free(group->config->allowed_bearers);
+ g_free(group->config->id);
+ g_free(group->config);
+ if (group->selinux)
+ g_hash_table_remove(selinux_hash, group->selinux);
+ if (group->uid)
+ g_hash_table_remove(uid_hash, group->uid);
+ if (group->gid)
+ g_hash_table_remove(gid_hash, group->gid);
+ g_free(group->selinux);
+ g_free(group->uid);
+ g_free(group->gid);
+ g_free(group);
+}
+
+static void cleanup_file(gpointer user_data)
+{
+ struct policy_file *file = user_data;
+
+ DBG("file %p", file);
+
+ g_slist_free_full(file->groups, cleanup_group);
+ g_free(file);
+}
+
+static void recheck_sessions(void)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+ struct policy_group *group = NULL;
+ GSList *list;
+
+ g_hash_table_iter_init(&iter, session_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct policy_config *policy = value;
+
+ if (policy->group)
+ continue;
+
+ if (policy->selinux)
+ group = g_hash_table_lookup(selinux_hash,
+ policy->selinux);
+ if (group) {
+ policy->config->id_type = CONNMAN_SESSION_ID_TYPE_LSM;
+ g_free(policy->config->id);
+ policy->config->id = g_strdup(policy->selinux_context);
+ update_session(policy);
+ continue;
+ }
+
+ group = g_hash_table_lookup(uid_hash, policy->uid);
+ if (group) {
+ set_policy(policy, group);
+
+ policy->config->id_type = CONNMAN_SESSION_ID_TYPE_UID;
+ g_free(policy->config->id);
+ policy->config->id = g_strdup(policy->uid);
+ update_session(policy);
+ continue;
+ }
+
+ for (list = policy->gids; list; list = list->next) {
+ char *gid = list->data;
+ group = g_hash_table_lookup(gid_hash, gid);
+ if (group) {
+ set_policy(policy, group);
+
+ policy->config->id_type = CONNMAN_SESSION_ID_TYPE_GID;
+ g_free(policy->config->id);
+ policy->config->id = g_strdup(gid);
+ update_session(policy);
+ }
+ }
+ }
+}
+
+static int load_file(const char *filename, struct policy_file *file)
+{
+ GKeyFile *keyfile;
+ struct policy_group *group;
+ char **groupnames;
+ char *pathname;
+ int err = 0, i;
+
+ DBG("%s", filename);
+
+ pathname = g_strdup_printf("%s/%s", POLICYDIR, filename);
+ err = load_keyfile(pathname, &keyfile);
+ g_free(pathname);
+
+ if (err < 0)
+ return err;
+
+ groupnames = g_key_file_get_groups(keyfile, NULL);
+
+ for (i = 0; groupnames[i]; i++) {
+ group = g_new0(struct policy_group, 1);
+ group->config = g_new0(struct connman_session_config, 1);
+
+ err = load_policy(keyfile, groupnames[i], group);
+ if (err < 0) {
+ g_free(group->config);
+ g_free(group);
+ break;
+ }
+ if (group->selinux)
+ g_hash_table_replace(selinux_hash, group->selinux, group);
+
+ if (group->uid)
+ g_hash_table_replace(uid_hash, group->uid, group);
+
+ if (group->gid)
+ g_hash_table_replace(gid_hash, group->gid, group);
+
+ file->groups = g_slist_prepend(file->groups, group);
+ }
+
+ g_strfreev(groupnames);
+
+ if (err < 0)
+ g_slist_free_full(file->groups, cleanup_group);
+
+ g_key_file_free(keyfile);
+
+ return err;
+}
+
+static bool is_filename_valid(const char *filename)
+{
+ if (!filename)
+ return false;
+
+ if (filename[0] == '.')
+ return false;
+
+ return g_str_has_suffix(filename, ".policy");
+}
+
+static int read_policies(void)
+{
+ GDir *dir;
+ const gchar *filename;
+ struct policy_file *file;
+
+ DBG("");
+
+ dir = g_dir_open(POLICYDIR, 0, NULL);
+ if (!dir)
+ return -EINVAL;
+
+ while ((filename = g_dir_read_name(dir))) {
+ if (!is_filename_valid(filename))
+ continue;
+
+ file = g_new0(struct policy_file, 1);
+ if (load_file(filename, file) < 0) {
+ g_free(file);
+ continue;
+ }
+
+ g_hash_table_replace(file_hash, g_strdup(filename), file);
+ }
+
+ g_dir_close(dir);
+
+ return 0;
+}
+
+
+static void notify_handler(struct inotify_event *event,
+ const char *filename)
+{
+ struct policy_file *file;
+
+ DBG("event %x file %s", event->mask, filename);
+
+ if (event->mask & IN_CREATE)
+ return;
+
+ if (!is_filename_valid(filename))
+ return;
+
+ /*
+ * load_file() will modify the global selinux/uid/gid hash
+ * tables. We need to remove the old entries first before
+ * else the table points to the wrong entries.
+ */
+ g_hash_table_remove(file_hash, filename);
+
+ if (event->mask & (IN_DELETE | IN_MOVED_FROM))
+ return;
+
+ if (event->mask & (IN_MOVED_TO | IN_MODIFY)) {
+ connman_info("Policy update for '%s'", filename);
+
+ file = g_new0(struct policy_file, 1);
+ if (load_file(filename, file) < 0) {
+ g_free(file);
+ return;
+ }
+
+ g_hash_table_replace(file_hash, g_strdup(filename), file);
+ recheck_sessions();
+ }
+}
+
+static int session_policy_local_init(void)
+{
+ int err;
+
+ DBG("");
+
+ /* If the dir doesn't exist, create it */
+ if (!g_file_test(POLICYDIR, G_FILE_TEST_IS_DIR)) {
+ if (mkdir(POLICYDIR, MODE) < 0) {
+ if (errno != EEXIST)
+ return -errno;
+ }
+ }
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ file_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, cleanup_file);
+ session_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, cleanup_config);
+ selinux_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ uid_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ gid_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ err = connman_inotify_register(POLICYDIR, notify_handler);
+ if (err < 0)
+ goto err;
+
+ err = connman_session_policy_register(&session_policy_local);
+ if (err < 0)
+ goto err_notify;
+
+ read_policies();
+
+ return 0;
+
+err_notify:
+
+ connman_inotify_unregister(POLICYDIR, notify_handler);
+
+err:
+ if (file_hash)
+ g_hash_table_destroy(file_hash);
+
+ if (session_hash)
+ g_hash_table_destroy(session_hash);
+
+ if (selinux_hash)
+ g_hash_table_destroy(selinux_hash);
+
+ if (uid_hash)
+ g_hash_table_destroy(uid_hash);
+
+ if (gid_hash)
+ g_hash_table_destroy(gid_hash);
+
+ connman_session_policy_unregister(&session_policy_local);
+
+ dbus_connection_unref(connection);
+
+ return err;
+}
+
+static void session_policy_local_exit(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(file_hash);
+ g_hash_table_destroy(session_hash);
+ g_hash_table_destroy(selinux_hash);
+ g_hash_table_destroy(uid_hash);
+ g_hash_table_destroy(gid_hash);
+
+ connman_session_policy_unregister(&session_policy_local);
+
+ dbus_connection_unref(connection);
+
+ connman_inotify_unregister(POLICYDIR, notify_handler);
+}
+
+CONNMAN_PLUGIN_DEFINE(session_policy_local,
+ "Session local file policy configuration plugin",
+ VERSION, CONNMAN_PLUGIN_PRIORITY_DEFAULT,
+ session_policy_local_init, session_policy_local_exit)
diff --git a/plugins/sleepplugin.c b/plugins/sleepplugin.c
new file mode 100644
index 0000000..301f025
--- /dev/null
+++ b/plugins/sleepplugin.c
@@ -0,0 +1,241 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2015 Nest Labs, Inc. All rights reserved.
+ *
+ * Author: Andrew LeCain <alecain@nestlabs.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <poll.h>
+
+#include <unistd.h>
+#include <pthread.h>
+#include <glib.h>
+
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/device.h>
+#include <connman/network.h>
+#include <connman/inet.h>
+#include <connman/dbus.h>
+#include <connman/notifier.h>
+#include <connman/log.h>
+#include <connman/technology.h>
+#include <connman/service.h>
+#include <connman/ipconfig.h>
+
+
+#undef DBG
+#define DBG(fmt, arg...) \
+ connman_debug("%s:%s() " fmt, \
+ __FILE__, __FUNCTION__ , ## arg);
+
+
+static GList *sleep_queue;
+static GList *wake_queue;
+
+typedef struct event_s{
+ void *owner;
+ GList *q;
+ time_t valid_until;
+}event_t;
+
+gboolean process_queues(gpointer user_data);
+
+gint owner_equals(gconstpointer a, gconstpointer b)
+{
+ event_t *e = (event_t*) a;
+ if (e->owner == b){
+ return 0;
+ }
+ return -1;
+}
+
+gint event_compare(gconstpointer aEvent, gconstpointer bEvent)
+{
+ event_t* a = (event_t*) aEvent;
+ event_t* b = (event_t*) bEvent;
+ return a->valid_until < b->valid_until;
+}
+
+void sleep_event(void *identifier, int cansleep, time_t valid_until)
+{
+
+ DBG("Sleep event: can%s sleep until %d\n",cansleep ? "" : "'t" , valid_until);
+ //remove any previous entries owned by current identifier
+ GList* entry = g_list_find_custom(wake_queue, identifier, &owner_equals);
+
+ if (entry)
+ {
+ DBG("Found entry in wake queue");
+ free(entry->data);
+ wake_queue = g_list_delete_link(wake_queue, entry);
+ }
+ else
+ {
+ entry = g_list_find_custom(sleep_queue, identifier, &owner_equals);
+ if (entry){
+ DBG("Found entry in sleep queue");
+ free(entry->data);
+ sleep_queue = g_list_delete_link(sleep_queue, entry);
+ }
+ }
+
+ DBG("pruned previous requests\n");
+
+ //make a new event
+ event_t *new_event = (event_t *)malloc(sizeof (event_t));
+ if (new_event == NULL){
+ return;
+ }
+
+ new_event->owner = identifier;
+ new_event->valid_until = valid_until;
+
+ DBG("inserting new request\n");
+ if(cansleep)
+ {
+ //insert entry into sleep queue
+ new_event->q = sleep_queue;
+ sleep_queue = g_list_insert(sleep_queue, new_event, -1);
+
+ }
+ else
+ {
+ //insert entry into wake queue
+ new_event->q = wake_queue;
+ wake_queue = g_list_insert(wake_queue, new_event, -1);
+ }
+ DBG("added new request\n");
+
+ process_queues(NULL);
+}
+
+
+
+gint is_expired(gconstpointer data, gconstpointer user_data)
+{
+
+
+ event_t *e = (event_t*) data;
+ if ( e && ( e->valid_until <= time(NULL))){
+ return 0;
+ }
+ return -1;
+}
+
+
+gboolean process_queues(gpointer user_data)
+{
+
+ //sort queues
+ DBG("sorting queues\n");
+ sleep_queue = g_list_sort(sleep_queue, &event_compare);
+ wake_queue = g_list_sort(wake_queue, &event_compare);
+ //go through each queue and dump anything that has expired.
+
+ DBG("sleep q len: %d, wake q len: %d\n", g_list_length(sleep_queue), g_list_length(wake_queue));
+
+ DBG("cleaning out queues");
+ GList* entry;
+ while (NULL != (entry = g_list_find_custom(sleep_queue, NULL , &is_expired)))
+ {
+ DBG("Passed sleep point%d", ((event_t*) (entry->data))->valid_until);
+ free(entry->data);
+ sleep_queue = g_list_delete_link(sleep_queue, entry);
+ }
+ while (NULL != (entry = g_list_find_custom(wake_queue, NULL, &is_expired)))
+ {
+ DBG("Passed wake point %d", ((event_t *) (entry->data))->valid_until);
+ free(entry->data);
+ wake_queue = g_list_delete_link(wake_queue, entry);
+ }
+
+ DBG("sleep q len: %d, wake q len: %d\n", g_list_length(sleep_queue), g_list_length(wake_queue));
+
+ DBG("checking wake queue\n");
+ //check wake queue for ANYTHING.
+ if (wake_queue)
+ {
+ event_t *e = wake_queue->data;
+ //we can't sleep until at least e->valid_until
+ //Stay awake and reschedule for then.
+ DBG("staying awake for %d seconds", e->valid_until-time(NULL));
+ g_timeout_add_seconds(e->valid_until, process_queues, NULL);
+ }
+ else
+ {
+ //nothing is holding us awake-- maybe we can sleep
+ DBG("checking sleep queue\n");
+ if (sleep_queue)
+ {
+ event_t *e = sleep_queue->data;
+ //There is a valid wake time! We can sleep til then
+ DBG("Sleeping for %d seconds", e->valid_until-time(NULL));
+ //system_sleep_until(e->valid_until);
+ }
+ //else: indeterminiate. Probably shouldn't sleep.
+ }
+
+ return FALSE;
+}
+
+static struct connman_notifier notifier = {
+ .name = "sleepplugin",
+ .priority = CONNMAN_NOTIFIER_PRIORITY_DEFAULT,
+ .default_changed = NULL,
+ .service_add = NULL,
+ .service_remove = NULL,
+ .service_enabled = NULL,
+ .offline_mode = NULL,
+ .proxy_changed = NULL,
+ .service_state_changed = NULL,
+ .ipconfig_changed = NULL,
+ .sleep_event = &sleep_event,
+ .idle_state = NULL,
+};
+
+static int sleepplugin_init(void)
+{
+
+ DBG("");
+
+ sleep_queue = NULL;
+ wake_queue = NULL;
+
+ connman_notifier_register(¬ifier);
+
+ return 0;
+}
+
+static void sleepplugin_exit(void)
+{
+ g_list_free_full(sleep_queue, free);
+ g_list_free_full(wake_queue, free);
+ DBG("");
+
+}
+
+CONNMAN_PLUGIN_DEFINE(sleepplugin, "connman sleep plugin", CONNMAN_VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, sleepplugin_init, sleepplugin_exit)
diff --git a/plugins/tist.c b/plugins/tist.c
new file mode 100644
index 0000000..ad5ef79
--- /dev/null
+++ b/plugins/tist.c
@@ -0,0 +1,611 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+#include <sys/ioctl.h>
+#include <termios.h>
+#include <unistd.h>
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/log.h>
+
+#define TIST_SYSFS_INSTALL "/sys/devices/platform/kim/install"
+#define TIST_SYSFS_UART "/sys/devices/platform/kim/dev_name"
+#define TIST_SYSFS_BAUD "/sys/devices/platform/kim/baud_rate"
+
+/* Shared transport line discipline */
+#define N_TI_WL 22
+
+static GIOChannel *install_channel = NULL;
+static GIOChannel *uart_channel = NULL;
+static char uart_dev_name[32];
+static unsigned long baud_rate = 0;
+
+static guint install_watch = 0;
+static guint uart_watch = 0;
+
+static int install_count = 0;
+
+#define NCCS2 19
+struct termios2 {
+ tcflag_t c_iflag; /* input mode flags */
+ tcflag_t c_oflag; /* output mode flags */
+ tcflag_t c_cflag; /* control mode flags */
+ tcflag_t c_lflag; /* local mode flags */
+ cc_t c_line; /* line discipline */
+ cc_t c_cc[NCCS2]; /* control characters */
+ speed_t c_ispeed; /* input speed */
+ speed_t c_ospeed; /* output speed */
+};
+
+#define BOTHER 0x00001000
+
+/* HCI definitions */
+#define HCI_HDR_OPCODE 0xff36
+#define HCI_COMMAND_PKT 0x01
+#define HCI_EVENT_PKT 0x04
+#define EVT_CMD_COMPLETE 0x0E
+
+/* HCI Command structure to set the target baud rate */
+struct speed_change_cmd {
+ uint8_t uart_prefix;
+ uint16_t opcode;
+ uint8_t plen;
+ uint32_t speed;
+} __attribute__ ((packed));
+
+/* HCI Event structure to set the cusrom baud rate*/
+struct cmd_complete {
+ uint8_t uart_prefix;
+ uint8_t evt;
+ uint8_t plen;
+ uint8_t ncmd;
+ uint16_t opcode;
+ uint8_t status;
+ uint8_t data[16];
+} __attribute__ ((packed));
+
+static int read_baud_rate(unsigned long *baud)
+{
+ int err;
+ FILE *f;
+
+ DBG("");
+
+ f = fopen(TIST_SYSFS_BAUD, "r");
+ if (!f)
+ return -EIO;
+
+ err = fscanf(f, "%lu", baud);
+ fclose(f);
+
+ DBG("baud rate %lu", *baud);
+
+ return err;
+}
+
+static int read_uart_name(char uart_name[], size_t uart_name_len)
+{
+ int err;
+ FILE *f;
+
+ DBG("");
+
+ memset(uart_name, 0, uart_name_len);
+
+ f = fopen(TIST_SYSFS_UART, "r");
+ if (!f)
+ return -EIO;
+
+ err = fscanf(f, "%s", uart_name);
+ fclose(f);
+
+ DBG("UART name %s", uart_name);
+
+ return err;
+}
+
+static int read_hci_event(int fd, unsigned char *buf, int size)
+{
+ int prefix_len, param_len;
+
+ if (size <= 0)
+ return -EINVAL;
+
+ /* First 3 bytes are prefix, event and param length */
+ prefix_len = read(fd, buf, 3);
+ if (prefix_len < 0)
+ return prefix_len;
+
+ if (prefix_len < 3) {
+ connman_error("Truncated HCI prefix %d bytes 0x%x",
+ prefix_len, buf[0]);
+ return -EIO;
+ }
+
+ DBG("type 0x%x event 0x%x param len %d", buf[0], buf[1], buf[2]);
+
+ param_len = buf[2];
+ if (param_len > size - 3) {
+ connman_error("Buffer is too small %d", size);
+ return -EINVAL;
+ }
+
+ return read(fd, buf + 3, param_len);
+}
+
+static int read_command_complete(int fd, unsigned short opcode)
+{
+ struct cmd_complete resp;
+ int err;
+
+ DBG("");
+
+ err = read_hci_event(fd, (unsigned char *)&resp, sizeof(resp));
+ if (err < 0)
+ return err;
+
+ DBG("HCI event %d bytes", err);
+
+ if (resp.uart_prefix != HCI_EVENT_PKT) {
+ connman_error("Not an event packet");
+ return -EIO;
+ }
+
+ if (resp.evt != EVT_CMD_COMPLETE) {
+ connman_error("Not a cmd complete event");
+ return -EIO;
+ }
+
+ if (resp.plen < 4) {
+ connman_error("HCI header length %d", resp.plen);
+ return -EIO;
+ }
+
+ if (resp.opcode != (unsigned short) opcode) {
+ connman_error("opcode 0x%04x 0x%04x", resp.opcode, opcode);
+ return -EIO;
+ }
+
+ return 0;
+}
+
+/* The default baud rate is 115200 */
+static int set_default_baud_rate(int fd)
+{
+ struct termios ti;
+ int err;
+
+ DBG("");
+
+ err = tcflush(fd, TCIOFLUSH);
+ if (err < 0)
+ goto err;
+
+ err = tcgetattr(fd, &ti);
+ if (err < 0)
+ goto err;
+
+ cfmakeraw(&ti);
+
+ ti.c_cflag |= 1;
+ ti.c_cflag |= CRTSCTS;
+
+ err = tcsetattr(fd, TCSANOW, &ti);
+ if (err < 0)
+ goto err;
+
+ cfsetospeed(&ti, B115200);
+ cfsetispeed(&ti, B115200);
+
+ err = tcsetattr(fd, TCSANOW, &ti);
+ if (err < 0)
+ goto err;
+
+ err = tcflush(fd, TCIOFLUSH);
+ if (err < 0)
+ goto err;
+
+ return 0;
+
+err:
+ connman_error("%s", strerror(errno));
+
+ return err;
+}
+
+static int set_custom_baud_rate(int fd, unsigned long cus_baud_rate, int flow_ctrl)
+{
+ struct termios ti;
+ struct termios2 ti2;
+ int err;
+
+ DBG("baud rate %lu flow_ctrl %d", cus_baud_rate, flow_ctrl);
+
+ err = tcflush(fd, TCIOFLUSH);
+ if (err < 0)
+ goto err;
+
+ err = tcgetattr(fd, &ti);
+ if (err < 0)
+ goto err;
+
+ if (flow_ctrl)
+ ti.c_cflag |= CRTSCTS;
+ else
+ ti.c_cflag &= ~CRTSCTS;
+
+ /*
+ * Set the parameters associated with the UART
+ * The change will occur immediately by using TCSANOW.
+ */
+ err = tcsetattr(fd, TCSANOW, &ti);
+ if (err < 0)
+ goto err;
+
+ err = tcflush(fd, TCIOFLUSH);
+ if (err < 0)
+ goto err;
+
+ /* Set the actual baud rate */
+ err = ioctl(fd, TCGETS2, &ti2);
+ if (err < 0)
+ goto err;
+
+ ti2.c_cflag &= ~CBAUD;
+ ti2.c_cflag |= BOTHER;
+ ti2.c_ospeed = cus_baud_rate;
+
+ err = ioctl(fd, TCSETS2, &ti2);
+ if (err < 0)
+ goto err;
+
+ return 0;
+
+err:
+ DBG("%s", strerror(errno));
+
+ return err;
+}
+
+static gboolean uart_event(GIOChannel *channel,
+ GIOCondition cond, gpointer data)
+{
+ int uart_fd, ldisc;
+
+ DBG("");
+
+ uart_fd = g_io_channel_unix_get_fd(channel);
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR)) {
+ connman_error("UART event 0x%x", cond);
+ if (uart_watch > 0)
+ g_source_remove(uart_watch);
+
+ goto err;
+ }
+
+ if (read_command_complete(uart_fd, HCI_HDR_OPCODE) < 0)
+ goto err;
+
+ if (set_custom_baud_rate(uart_fd, baud_rate, 1) < 0)
+ goto err;
+
+ ldisc = N_TI_WL;
+ if (ioctl(uart_fd, TIOCSETD, &ldisc) < 0)
+ goto err;
+
+ install_count = 1;
+ __sync_synchronize();
+
+ return FALSE;
+
+err:
+ install_count = 0;
+ __sync_synchronize();
+
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+
+ return FALSE;
+}
+
+static int install_ldisc(GIOChannel *channel, bool install)
+{
+ int uart_fd, err;
+ struct speed_change_cmd cmd;
+ GIOFlags flags;
+
+ DBG("%d %p", install, uart_channel);
+
+ if (!install) {
+ install_count = 0;
+ __sync_synchronize();
+
+ if (!uart_channel) {
+ DBG("UART channel is NULL");
+ return 0;
+ }
+
+ g_io_channel_shutdown(uart_channel, TRUE, NULL);
+ g_io_channel_unref(uart_channel);
+
+ uart_channel = NULL;
+
+ return 0;
+ }
+
+ if (uart_channel) {
+ g_io_channel_shutdown(uart_channel, TRUE, NULL);
+ g_io_channel_unref(uart_channel);
+ uart_channel = NULL;
+ }
+
+ DBG("opening %s custom baud %lu", uart_dev_name, baud_rate);
+
+ uart_fd = open(uart_dev_name, O_RDWR | O_CLOEXEC);
+ if (uart_fd < 0)
+ return -EIO;
+
+ uart_channel = g_io_channel_unix_new(uart_fd);
+ g_io_channel_set_close_on_unref(uart_channel, TRUE);
+
+ g_io_channel_set_encoding(uart_channel, NULL, NULL);
+ g_io_channel_set_buffered(uart_channel, FALSE);
+
+ flags = g_io_channel_get_flags(uart_channel);
+ flags |= G_IO_FLAG_NONBLOCK;
+ g_io_channel_set_flags(uart_channel, flags, NULL);
+
+ err = set_default_baud_rate(uart_fd);
+ if (err < 0) {
+ g_io_channel_shutdown(uart_channel, TRUE, NULL);
+ g_io_channel_unref(uart_channel);
+ uart_channel = NULL;
+
+ return err;
+ }
+
+ if (baud_rate == 115200) {
+ int ldisc;
+
+ ldisc = N_TI_WL;
+ if (ioctl(uart_fd, TIOCSETD, &ldisc) < 0) {
+ g_io_channel_shutdown(uart_channel, TRUE, NULL);
+ g_io_channel_unref(uart_channel);
+ uart_channel = NULL;
+ }
+
+ install_count = 0;
+ __sync_synchronize();
+
+ return 0;
+ }
+
+ cmd.uart_prefix = HCI_COMMAND_PKT;
+ cmd.opcode = HCI_HDR_OPCODE;
+ cmd.plen = sizeof(unsigned long);
+ cmd.speed = baud_rate;
+
+ uart_watch = g_io_add_watch(uart_channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ uart_event, NULL);
+
+ err = write(uart_fd, &cmd, sizeof(cmd));
+ if (err < 0) {
+ connman_error("Write failed %d", err);
+
+ g_io_channel_shutdown(uart_channel, TRUE, NULL);
+ g_io_channel_unref(uart_channel);
+ uart_channel = NULL;
+ }
+
+ return err;
+}
+
+
+static gboolean install_event(GIOChannel *channel,
+ GIOCondition cond, gpointer data)
+{
+ GIOStatus status = G_IO_STATUS_NORMAL;
+ unsigned int install_state;
+ bool install;
+ char buf[8];
+ gsize len;
+
+ DBG("");
+
+ if (cond & (G_IO_HUP | G_IO_NVAL)) {
+ connman_error("install event 0x%x", cond);
+ return FALSE;
+ }
+
+ __sync_synchronize();
+ if (install_count != 0) {
+ status = g_io_channel_seek_position(channel, 0, G_SEEK_SET, NULL);
+ if (status != G_IO_STATUS_NORMAL) {
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+ return FALSE;
+ }
+
+ /* Read the install value */
+ status = g_io_channel_read_chars(channel, (gchar *) buf,
+ 8, &len, NULL);
+ if (status != G_IO_STATUS_NORMAL) {
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+ return FALSE;
+ }
+
+ install_state = atoi(buf);
+ DBG("install event while installing %d %c", install_state, buf[0]);
+
+ return TRUE;
+ } else {
+ install_count = 1;
+ __sync_synchronize();
+ }
+
+ status = g_io_channel_seek_position(channel, 0, G_SEEK_SET, NULL);
+ if (status != G_IO_STATUS_NORMAL) {
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+ return FALSE;
+ }
+
+ /* Read the install value */
+ status = g_io_channel_read_chars(channel, (gchar *) buf, 8, &len, NULL);
+ if (status != G_IO_STATUS_NORMAL) {
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+ return FALSE;
+ }
+
+ install_state = atoi(buf);
+
+ DBG("install state %d", install_state);
+
+ install = !!install_state;
+
+ if (install_ldisc(channel, install) < 0) {
+ connman_error("ldisc installation failed");
+ install_count = 0;
+ __sync_synchronize();
+ return TRUE;
+ }
+
+ return TRUE;
+}
+
+
+static int tist_init(void)
+{
+ GIOStatus status = G_IO_STATUS_NORMAL;
+ GIOFlags flags;
+ unsigned int install_state;
+ char buf[8];
+ int fd, err;
+ gsize len;
+
+ err = read_uart_name(uart_dev_name, sizeof(uart_dev_name));
+ if (err < 0) {
+ connman_error("Could not read the UART name");
+ return err;
+ }
+
+ err = read_baud_rate(&baud_rate);
+ if (err < 0) {
+ connman_error("Could not read the baud rate");
+ return err;
+ }
+
+ fd = open(TIST_SYSFS_INSTALL, O_RDONLY | O_CLOEXEC);
+ if (fd < 0) {
+ connman_error("Failed to open TI ST sysfs install file");
+ return -EIO;
+ }
+
+ install_channel = g_io_channel_unix_new(fd);
+ g_io_channel_set_close_on_unref(install_channel, TRUE);
+
+ g_io_channel_set_encoding(install_channel, NULL, NULL);
+ g_io_channel_set_buffered(install_channel, FALSE);
+
+ flags = g_io_channel_get_flags(install_channel);
+ flags |= G_IO_FLAG_NONBLOCK;
+ g_io_channel_set_flags(install_channel, flags, NULL);
+
+ status = g_io_channel_read_chars(install_channel, (gchar *) buf, 8,
+ &len, NULL);
+ if (status != G_IO_STATUS_NORMAL) {
+ g_io_channel_shutdown(install_channel, TRUE, NULL);
+ g_io_channel_unref(install_channel);
+ return status;
+ }
+
+ status = g_io_channel_seek_position(install_channel, 0, G_SEEK_SET, NULL);
+ if (status != G_IO_STATUS_NORMAL) {
+ connman_error("Initial seek failed");
+ g_io_channel_shutdown(install_channel, TRUE, NULL);
+ g_io_channel_unref(install_channel);
+ return -EIO;
+ }
+
+ install_state = atoi(buf);
+
+ DBG("Initial state %d", install_state);
+
+ install_watch = g_io_add_watch_full(install_channel, G_PRIORITY_HIGH,
+ G_IO_PRI | G_IO_ERR,
+ install_event, NULL, NULL);
+
+ if (install_state) {
+ install_count = 1;
+ __sync_synchronize();
+
+ err = install_ldisc(install_channel, true);
+ if (err < 0) {
+ connman_error("ldisc installtion failed");
+ return err;
+ }
+ }
+
+ return 0;
+}
+
+
+static void tist_exit(void)
+{
+
+ if (install_watch > 0)
+ g_source_remove(install_watch);
+
+ DBG("uart_channel %p", uart_channel);
+
+ g_io_channel_shutdown(install_channel, TRUE, NULL);
+ g_io_channel_unref(install_channel);
+
+ if (uart_channel) {
+ g_io_channel_shutdown(uart_channel, TRUE, NULL);
+ g_io_channel_unref(uart_channel);
+ uart_channel = NULL;
+ }
+
+}
+
+CONNMAN_PLUGIN_DEFINE(tist, "TI shared transport support", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, tist_init, tist_exit)
diff --git a/plugins/vpn.c b/plugins/vpn.c
new file mode 100644
index 0000000..e6e4c8e
--- /dev/null
+++ b/plugins/vpn.c
@@ -0,0 +1,1864 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <stdlib.h>
+#include <glib.h>
+
+#include <gdbus.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/technology.h>
+#include <connman/plugin.h>
+#include <connman/log.h>
+#include <connman/dbus.h>
+#include <connman/provider.h>
+#include <connman/ipaddress.h>
+#include <connman/vpn-dbus.h>
+#include <connman/inet.h>
+#include <gweb/gresolv.h>
+
+#define DBUS_TIMEOUT 10000
+
+static DBusConnection *connection;
+
+static GHashTable *vpn_connections = NULL;
+static guint watch;
+static guint added_watch;
+static guint removed_watch;
+static guint property_watch;
+
+struct vpn_route {
+ int family;
+ char *network;
+ char *netmask;
+ char *gateway;
+};
+
+struct config_create_data {
+ connection_ready_cb callback;
+ DBusMessage *message;
+ char *path;
+};
+
+struct connection_data {
+ char *path;
+ char *ident;
+ struct connman_provider *provider;
+ int index;
+ DBusPendingCall *call;
+ bool connect_pending;
+ struct config_create_data *cb_data;
+
+ char *state;
+ char *type;
+ char *name;
+ char *host;
+ char **host_ip;
+ char *domain;
+ char **nameservers;
+ bool immutable;
+
+ GHashTable *server_routes;
+ GHashTable *user_routes;
+ GHashTable *setting_strings;
+
+ struct connman_ipaddress *ip;
+
+ GResolv *resolv;
+ guint resolv_id;
+};
+
+static int set_string(struct connman_provider *provider,
+ const char *key, const char *value)
+{
+ struct connection_data *data;
+
+ data = connman_provider_get_data(provider);
+ if (!data)
+ return -EINVAL;
+
+ DBG("data %p provider %p key %s value %s", data, provider, key, value);
+
+ if (g_str_equal(key, "Type")) {
+ g_free(data->type);
+ data->type = g_strdup(value);
+ } else if (g_str_equal(key, "Name")) {
+ g_free(data->name);
+ data->name = g_strdup(value);
+ } else if (g_str_equal(key, "Host")) {
+ g_free(data->host);
+ data->host = g_strdup(value);
+ } else if (g_str_equal(key, "VPN.Domain") ||
+ g_str_equal(key, "Domain")) {
+ g_free(data->domain);
+ data->domain = g_strdup(value);
+ } else
+ g_hash_table_replace(data->setting_strings,
+ g_strdup(key), g_strdup(value));
+ return 0;
+}
+
+static const char *get_string(struct connman_provider *provider,
+ const char *key)
+{
+ struct connection_data *data;
+
+ data = connman_provider_get_data(provider);
+ if (!data)
+ return NULL;
+
+ DBG("data %p provider %p key %s", data, provider, key);
+
+ if (g_str_equal(key, "Type"))
+ return data->type;
+ else if (g_str_equal(key, "Name"))
+ return data->name;
+ else if (g_str_equal(key, "Host"))
+ return data->host;
+ else if (g_str_equal(key, "HostIP")) {
+ if (!data->host_ip ||
+ !data->host_ip[0])
+ return data->host;
+ else
+ return data->host_ip[0];
+ } else if (g_str_equal(key, "VPN.Domain"))
+ return data->domain;
+
+ return g_hash_table_lookup(data->setting_strings, key);
+}
+
+static char *get_ident(const char *path)
+{
+ char *pos;
+
+ if (*path != '/')
+ return NULL;
+
+ pos = strrchr(path, '/');
+ if (!pos)
+ return NULL;
+
+ return pos + 1;
+}
+
+static void cancel_host_resolv(struct connection_data *data)
+{
+ if (data->resolv_id != 0)
+ g_resolv_cancel_lookup(data->resolv, data->resolv_id);
+
+ data->resolv_id = 0;
+
+ g_resolv_unref(data->resolv);
+ data->resolv = NULL;
+}
+
+static gboolean remove_resolv(gpointer user_data)
+{
+ struct connection_data *data = user_data;
+
+ cancel_host_resolv(data);
+
+ return FALSE;
+}
+
+static void resolv_result(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+ struct connection_data *data = user_data;
+
+ DBG("status %d", status);
+
+ if (status == G_RESOLV_RESULT_STATUS_SUCCESS && results &&
+ g_strv_length(results) > 0) {
+ g_strfreev(data->host_ip);
+ data->host_ip = g_strdupv(results);
+ }
+
+ /*
+ * We cannot unref the resolver here as resolv struct is manipulated
+ * by gresolv.c after we return from this callback.
+ */
+ g_timeout_add_seconds(0, remove_resolv, data);
+
+ data->resolv_id = 0;
+}
+
+static void resolv_host_addr(struct connection_data *data)
+{
+ if (!data->host)
+ return;
+
+ if (connman_inet_check_ipaddress(data->host) > 0)
+ return;
+
+ if (data->host_ip)
+ return;
+
+ data->resolv = g_resolv_new(0);
+ if (!data->resolv) {
+ DBG("Cannot resolv %s", data->host);
+ return;
+ }
+
+ DBG("Trying to resolv %s", data->host);
+
+ data->resolv_id = g_resolv_lookup_hostname(data->resolv, data->host,
+ resolv_result, data);
+}
+
+static void free_config_cb_data(struct config_create_data *cb_data)
+{
+ if (!cb_data)
+ return;
+
+ g_free(cb_data->path);
+ cb_data->path = NULL;
+
+ if (cb_data->message) {
+ dbus_message_unref(cb_data->message);
+ cb_data->message = NULL;
+ }
+
+ cb_data->callback = NULL;
+
+ g_free(cb_data);
+}
+
+static void set_provider_state(struct connection_data *data)
+{
+ enum connman_provider_state state = CONNMAN_PROVIDER_STATE_UNKNOWN;
+ int err = 0;
+
+ DBG("provider %p new state %s", data->provider, data->state);
+
+ if (g_str_equal(data->state, "ready")) {
+ state = CONNMAN_PROVIDER_STATE_READY;
+ goto set;
+ } else if (g_str_equal(data->state, "configuration")) {
+ state = CONNMAN_PROVIDER_STATE_CONNECT;
+ } else if (g_str_equal(data->state, "idle")) {
+ state = CONNMAN_PROVIDER_STATE_IDLE;
+ } else if (g_str_equal(data->state, "disconnect")) {
+ err = ECONNREFUSED;
+ state = CONNMAN_PROVIDER_STATE_DISCONNECT;
+ goto set;
+ } else if (g_str_equal(data->state, "failure")) {
+ err = ECONNREFUSED;
+ state = CONNMAN_PROVIDER_STATE_FAILURE;
+ goto set;
+ }
+
+ connman_provider_set_state(data->provider, state);
+ return;
+
+set:
+ if (data->cb_data)
+ data->cb_data->callback(data->cb_data->message,
+ err, data->ident);
+
+ connman_provider_set_state(data->provider, state);
+
+ free_config_cb_data(data->cb_data);
+ data->cb_data = NULL;
+}
+
+static int create_provider(struct connection_data *data, void *user_data)
+{
+ struct connman_provider_driver *driver = user_data;
+ int err;
+
+ DBG("%s", data->path);
+
+ data->provider = connman_provider_get(data->ident);
+ if (!data->provider)
+ return -ENOMEM;
+
+ DBG("provider %p name %s", data->provider, data->name);
+
+ connman_provider_set_data(data->provider, data);
+ connman_provider_set_driver(data->provider, driver);
+
+ err = connman_provider_create_service(data->provider);
+ if (err == 0) {
+ connman_provider_set_immutable(data->provider, data->immutable);
+ if (g_str_equal(data->state, "ready")) {
+ connman_provider_set_index(data->provider,
+ data->index);
+ if (data->ip)
+ connman_provider_set_ipaddress(data->provider,
+ data->ip);
+ }
+
+ set_provider_state(data);
+ }
+
+ return 0;
+}
+
+static void destroy_route(gpointer user_data)
+{
+ struct vpn_route *route = user_data;
+
+ g_free(route->network);
+ g_free(route->netmask);
+ g_free(route->gateway);
+ g_free(route);
+}
+
+static struct connection_data *create_connection_data(const char *path)
+{
+ struct connection_data *data;
+
+ data = g_try_new0(struct connection_data, 1);
+ if (!data)
+ return NULL;
+
+ DBG("path %s", path);
+
+ data->path = g_strdup(path);
+ data->ident = g_strdup(get_ident(path));
+ data->index = -1;
+
+ data->setting_strings = g_hash_table_new_full(g_str_hash,
+ g_str_equal, g_free, g_free);
+
+ data->server_routes = g_hash_table_new_full(g_direct_hash,
+ g_str_equal, g_free, destroy_route);
+ data->user_routes = g_hash_table_new_full(g_str_hash,
+ g_str_equal, g_free, destroy_route);
+
+ return data;
+}
+
+static int extract_ip(DBusMessageIter *array, int family,
+ struct connection_data *data)
+{
+ DBusMessageIter dict;
+ char *address = NULL, *gateway = NULL, *netmask = NULL, *peer = NULL;
+ unsigned char prefix_len;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "Address")) {
+ dbus_message_iter_get_basic(&value, &address);
+ DBG("address %s", address);
+ } else if (g_str_equal(key, "Netmask")) {
+ dbus_message_iter_get_basic(&value, &netmask);
+ DBG("netmask %s", netmask);
+ } else if (g_str_equal(key, "PrefixLength")) {
+ dbus_message_iter_get_basic(&value, &netmask);
+ DBG("prefix length %s", netmask);
+ } else if (g_str_equal(key, "Peer")) {
+ dbus_message_iter_get_basic(&value, &peer);
+ DBG("peer %s", peer);
+ } else if (g_str_equal(key, "Gateway")) {
+ dbus_message_iter_get_basic(&value, &gateway);
+ DBG("gateway %s", gateway);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ connman_ipaddress_free(data->ip);
+ data->ip = connman_ipaddress_alloc(family);
+ if (!data->ip)
+ return -ENOMEM;
+
+ switch (family) {
+ case AF_INET:
+ connman_ipaddress_set_ipv4(data->ip, address, netmask,
+ gateway);
+ break;
+ case AF_INET6:
+ prefix_len = atoi(netmask);
+ connman_ipaddress_set_ipv6(data->ip, address, prefix_len,
+ gateway);
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ connman_ipaddress_set_peer(data->ip, peer);
+
+ return 0;
+}
+
+static int extract_nameservers(DBusMessageIter *array,
+ struct connection_data *data)
+{
+ DBusMessageIter entry;
+ char **nameservers = NULL;
+ int i = 0;
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *nameserver;
+
+ dbus_message_iter_get_basic(&entry, &nameserver);
+
+ nameservers = g_try_renew(char *, nameservers, i + 2);
+ if (!nameservers)
+ return -ENOMEM;
+
+ DBG("[%d] %s", i, nameserver);
+
+ nameservers[i] = g_strdup(nameserver);
+ if (!nameservers[i])
+ return -ENOMEM;
+
+ nameservers[++i] = NULL;
+
+ dbus_message_iter_next(&entry);
+ }
+
+ g_strfreev(data->nameservers);
+ data->nameservers = nameservers;
+
+ return 0;
+}
+
+static int errorstr2val(const char *error) {
+ if (g_strcmp0(error, CONNMAN_ERROR_INTERFACE ".InProgress") == 0)
+ return -EINPROGRESS;
+
+ if (g_strcmp0(error, CONNMAN_ERROR_INTERFACE ".AlreadyConnected") == 0)
+ return -EISCONN;
+
+ return -ECONNREFUSED;
+}
+
+static void connect_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+ struct connection_data *data = user_data;
+ struct config_create_data *cb_data = data->cb_data;
+
+ if (!dbus_pending_call_get_completed(call))
+ return;
+
+ DBG("user_data %p path %s", user_data, cb_data ? cb_data->path : NULL);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ int err = errorstr2val(error.name);
+ if (err != -EINPROGRESS) {
+ connman_error("Connect reply: %s (%s)", error.message,
+ error.name);
+ dbus_error_free(&error);
+
+ DBG("data %p cb_data %p", data, cb_data);
+ if (cb_data) {
+ cb_data->callback(cb_data->message, err, NULL);
+ free_config_cb_data(cb_data);
+ data->cb_data = NULL;
+ }
+ goto done;
+ }
+ dbus_error_free(&error);
+ }
+
+ /*
+ * The vpn connection is up when we get a "ready" state
+ * property so at this point we do nothing for the provider
+ * state.
+ */
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int connect_provider(struct connection_data *data, void *user_data)
+{
+ DBusPendingCall *call;
+ DBusMessage *message;
+ struct config_create_data *cb_data = user_data;
+
+ DBG("data %p user %p path %s", data, cb_data, data->path);
+
+ data->connect_pending = false;
+
+ message = dbus_message_new_method_call(VPN_SERVICE, data->path,
+ VPN_CONNECTION_INTERFACE,
+ VPN_CONNECT);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, DBUS_TIMEOUT)) {
+ connman_error("Unable to call %s.%s()",
+ VPN_CONNECTION_INTERFACE, VPN_CONNECT);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (cb_data) {
+ g_free(cb_data->path);
+ cb_data->path = g_strdup(data->path);
+ }
+
+ dbus_pending_call_set_notify(call, connect_reply, data, NULL);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static void add_connection(const char *path, DBusMessageIter *properties,
+ void *user_data)
+{
+ struct connection_data *data;
+ int err;
+ char *ident = get_ident(path);
+ bool found = false;
+
+ data = g_hash_table_lookup(vpn_connections, ident);
+ if (data) {
+ /*
+ * We might have a dummy connection struct here that
+ * was created by configuration_create_reply() so in
+ * that case just continue.
+ */
+ if (!data->connect_pending)
+ return;
+
+ found = true;
+ } else {
+ data = create_connection_data(path);
+ if (!data)
+ return;
+ }
+
+ DBG("data %p path %s", data, path);
+
+ while (dbus_message_iter_get_arg_type(properties) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+ char *str;
+
+ dbus_message_iter_recurse(properties, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "State")) {
+ dbus_message_iter_get_basic(&value, &str);
+ DBG("state %s -> %s", data->state, str);
+ data->state = g_strdup(str);
+ } else if (g_str_equal(key, "IPv4")) {
+ extract_ip(&value, AF_INET, data);
+ } else if (g_str_equal(key, "IPv6")) {
+ extract_ip(&value, AF_INET6, data);
+ } else if (g_str_equal(key, "Name")) {
+ dbus_message_iter_get_basic(&value, &str);
+ data->name = g_strdup(str);
+ } else if (g_str_equal(key, "Type")) {
+ dbus_message_iter_get_basic(&value, &str);
+ data->type = g_strdup(str);
+ } else if (g_str_equal(key, "Immutable")) {
+ dbus_bool_t immutable;
+
+ dbus_message_iter_get_basic(&value, &immutable);
+ data->immutable = immutable;
+ } else if (g_str_equal(key, "Host")) {
+ dbus_message_iter_get_basic(&value, &str);
+ data->host = g_strdup(str);
+ } else if (g_str_equal(key, "Domain")) {
+ dbus_message_iter_get_basic(&value, &str);
+ g_free(data->domain);
+ data->domain = g_strdup(str);
+ } else if (g_str_equal(key, "Nameservers")) {
+ extract_nameservers(&value, data);
+ } else if (g_str_equal(key, "Index")) {
+ dbus_message_iter_get_basic(&value, &data->index);
+ } else if (g_str_equal(key, "ServerRoutes")) {
+ /* Ignored */
+ } else if (g_str_equal(key, "UserRoutes")) {
+ /* Ignored */
+ } else {
+ if (dbus_message_iter_get_arg_type(&value) ==
+ DBUS_TYPE_STRING) {
+ dbus_message_iter_get_basic(&value, &str);
+ g_hash_table_replace(data->setting_strings,
+ g_strdup(key), g_strdup(str));
+ } else {
+ DBG("unknown key %s", key);
+ }
+ }
+
+ dbus_message_iter_next(properties);
+ }
+
+ if (!found)
+ g_hash_table_insert(vpn_connections, g_strdup(data->ident),
+ data);
+
+ err = create_provider(data, user_data);
+ if (err < 0)
+ goto out;
+
+ resolv_host_addr(data);
+
+ if (data->nameservers)
+ connman_provider_set_nameservers(data->provider,
+ data->nameservers);
+
+ if (data->domain)
+ connman_provider_set_domain(data->provider,
+ data->domain);
+
+ if (data->connect_pending)
+ connect_provider(data, data->cb_data);
+
+ return;
+
+out:
+ DBG("removing %s", data->ident);
+ g_hash_table_remove(vpn_connections, data->ident);
+}
+
+static void get_connections_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+ DBusMessageIter array, dict;
+ const char *signature = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_OBJECT_PATH_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING;
+
+ if (!dbus_pending_call_get_completed(call))
+ return;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_has_signature(reply, signature)) {
+ connman_error("vpnd signature \"%s\" does not match "
+ "expected \"%s\"",
+ dbus_message_get_signature(reply), signature);
+ goto done;
+ }
+
+ if (!dbus_message_iter_init(reply, &array))
+ goto done;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_STRUCT) {
+ DBusMessageIter value, properties;
+ const char *path;
+
+ dbus_message_iter_recurse(&dict, &value);
+ dbus_message_iter_get_basic(&value, &path);
+
+ dbus_message_iter_next(&value);
+ dbus_message_iter_recurse(&value, &properties);
+
+ add_connection(path, &properties, user_data);
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int get_connections(void *user_data)
+{
+ DBusPendingCall *call;
+ DBusMessage *message;
+
+ DBG("");
+
+ message = dbus_message_new_method_call(VPN_SERVICE, "/",
+ VPN_MANAGER_INTERFACE,
+ GET_CONNECTIONS);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, DBUS_TIMEOUT)) {
+ connman_error("Unable to call %s.%s()", VPN_MANAGER_INTERFACE,
+ GET_CONNECTIONS);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, get_connections_reply,
+ user_data, NULL);
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static int provider_probe(struct connman_provider *provider)
+{
+ return 0;
+}
+
+static void remove_connection_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+
+ if (!dbus_pending_call_get_completed(call))
+ return;
+
+ DBG("");
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ /*
+ * If the returned error is NotFound, it means that we
+ * have actually removed the provider in vpnd already.
+ */
+ if (!dbus_error_has_name(&error,
+ CONNMAN_ERROR_INTERFACE".NotFound"))
+ connman_error("%s", error.message);
+
+ dbus_error_free(&error);
+ }
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int provider_remove(struct connman_provider *provider)
+{
+ DBusPendingCall *call;
+ DBusMessage *message;
+ struct connection_data *data;
+
+ data = connman_provider_get_data(provider);
+
+ DBG("provider %p data %p", provider, data);
+
+ if (!data) {
+ /*
+ * This means the provider is already removed,
+ * just ignore the dbus in this case.
+ */
+ return -EALREADY;
+ }
+
+ /*
+ * When provider.c:provider_remove() calls this function,
+ * it will remove the provider itself after the call.
+ * This means that we cannot use the provider pointer later
+ * as it is no longer valid.
+ */
+ data->provider = NULL;
+
+ message = dbus_message_new_method_call(VPN_SERVICE, "/",
+ VPN_MANAGER_INTERFACE,
+ VPN_REMOVE);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_append_args(message, DBUS_TYPE_OBJECT_PATH, &data->path,
+ NULL);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, DBUS_TIMEOUT)) {
+ connman_error("Unable to call %s.%s()", VPN_MANAGER_INTERFACE,
+ VPN_REMOVE);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, remove_connection_reply,
+ NULL, NULL);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+static int provider_connect(struct connman_provider *provider)
+{
+ struct connection_data *data;
+
+ data = connman_provider_get_data(provider);
+ if (!data)
+ return -EINVAL;
+
+ return connect_provider(data, NULL);
+}
+
+static void disconnect_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+
+ if (!dbus_pending_call_get_completed(call))
+ return;
+
+ DBG("user %p", user_data);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("%s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static int disconnect_provider(struct connection_data *data)
+{
+ DBusPendingCall *call;
+ DBusMessage *message;
+
+ DBG("data %p path %s", data, data->path);
+
+ message = dbus_message_new_method_call(VPN_SERVICE, data->path,
+ VPN_CONNECTION_INTERFACE,
+ VPN_DISCONNECT);
+ if (!message)
+ return -ENOMEM;
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, DBUS_TIMEOUT)) {
+ connman_error("Unable to call %s.%s()",
+ VPN_CONNECTION_INTERFACE, VPN_DISCONNECT);
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ return -EINVAL;
+ }
+
+ dbus_pending_call_set_notify(call, disconnect_reply, NULL, NULL);
+
+ dbus_message_unref(message);
+
+ connman_provider_set_state(data->provider,
+ CONNMAN_PROVIDER_STATE_DISCONNECT);
+ /*
+ * We return 0 here instead of -EINPROGRESS because
+ * __connman_service_disconnect() needs to return something
+ * to gdbus so that gdbus will not call Disconnect() more
+ * than once. This way we do not need to pass the dbus reply
+ * message around the code.
+ */
+ return 0;
+}
+
+static int provider_disconnect(struct connman_provider *provider)
+{
+ struct connection_data *data;
+
+ DBG("provider %p", provider);
+
+ data = connman_provider_get_data(provider);
+ if (!data)
+ return -EINVAL;
+
+ if (g_str_equal(data->state, "ready") ||
+ g_str_equal(data->state, "configuration"))
+ return disconnect_provider(data);
+
+ return 0;
+}
+
+static void configuration_create_reply(DBusPendingCall *call, void *user_data)
+{
+ DBusMessage *reply;
+ DBusError error;
+ DBusMessageIter iter;
+ const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ const char *path;
+ char *ident;
+ struct connection_data *data;
+ struct config_create_data *cb_data = user_data;
+
+ if (!dbus_pending_call_get_completed(call))
+ return;
+
+ DBG("user %p", cb_data);
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ dbus_error_init(&error);
+
+ if (dbus_set_error_from_message(&error, reply)) {
+ connman_error("dbus error: %s", error.message);
+ dbus_error_free(&error);
+ goto done;
+ }
+
+ if (!dbus_message_has_signature(reply, signature)) {
+ connman_error("vpn configuration signature \"%s\" does not "
+ "match expected \"%s\"",
+ dbus_message_get_signature(reply), signature);
+ goto done;
+ }
+
+ if (!dbus_message_iter_init(reply, &iter))
+ goto done;
+
+ dbus_message_iter_get_basic(&iter, &path);
+
+ /*
+ * Then try to connect the VPN as expected by ConnectProvider API
+ */
+ ident = get_ident(path);
+
+ data = g_hash_table_lookup(vpn_connections, ident);
+ if (!data) {
+ /*
+ * Someone removed the data. We cannot really continue.
+ */
+ DBG("Pending data not found for %s, cannot continue!", ident);
+ } else {
+ data->call = NULL;
+ data->connect_pending = true;
+
+ if (!data->cb_data)
+ data->cb_data = cb_data;
+ else
+ DBG("Connection callback data already in use!");
+
+ /*
+ * Connection is created in add_connections() after
+ * we have received the ConnectionAdded signal.
+ */
+
+ DBG("cb %p msg %p", data->cb_data,
+ data->cb_data ? data->cb_data->message : NULL);
+ }
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+static void set_dbus_ident(char *ident)
+{
+ int i, len = strlen(ident);
+
+ for (i = 0; i < len; i++) {
+ if (ident[i] >= '0' && ident[i] <= '9')
+ continue;
+ if (ident[i] >= 'a' && ident[i] <= 'z')
+ continue;
+ if (ident[i] >= 'A' && ident[i] <= 'Z')
+ continue;
+ ident[i] = '_';
+ }
+}
+
+static struct vpn_route *parse_user_route(const char *user_route)
+{
+ char *network, *netmask;
+ struct vpn_route *route = NULL;
+ int family = PF_UNSPEC;
+ char **elems = g_strsplit(user_route, "/", 0);
+
+ if (!elems)
+ return NULL;
+
+ network = elems[0];
+ if (!network || *network == '\0') {
+ DBG("no network/netmask set");
+ goto out;
+ }
+
+ netmask = elems[1];
+ if (netmask && *netmask == '\0') {
+ DBG("no netmask set");
+ goto out;
+ }
+
+ if (g_strrstr(network, ":"))
+ family = AF_INET6;
+ else if (g_strrstr(network, ".")) {
+ family = AF_INET;
+
+ if (!g_strrstr(netmask, ".")) {
+ /* We have netmask length */
+ in_addr_t addr;
+ struct in_addr netmask_in;
+ unsigned char prefix_len = 32;
+
+ if (netmask) {
+ char *ptr;
+ long int value = strtol(netmask, &ptr, 10);
+ if (ptr != netmask && *ptr == '\0' &&
+ value && value <= 32)
+ prefix_len = value;
+ }
+
+ addr = 0xffffffff << (32 - prefix_len);
+ netmask_in.s_addr = htonl(addr);
+ netmask = inet_ntoa(netmask_in);
+
+ DBG("network %s netmask %s", network, netmask);
+ }
+ }
+
+ route = g_try_new(struct vpn_route, 1);
+ if (!route)
+ goto out;
+
+ route->network = g_strdup(network);
+ route->netmask = g_strdup(netmask);
+ route->gateway = NULL;
+ route->family = family;
+
+out:
+ g_strfreev(elems);
+ return route;
+}
+
+static GSList *get_user_networks(DBusMessageIter *array)
+{
+ DBusMessageIter entry;
+ GSList *list = NULL;
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *val;
+ struct vpn_route *route;
+
+ dbus_message_iter_get_basic(&entry, &val);
+
+ route = parse_user_route(val);
+ if (route)
+ list = g_slist_prepend(list, route);
+
+ dbus_message_iter_next(&entry);
+ }
+
+ return list;
+}
+
+static void append_route(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_route *route = user_data;
+ DBusMessageIter item;
+ int family = 0;
+
+ connman_dbus_dict_open(iter, &item);
+
+ if (!route)
+ goto empty_dict;
+
+ if (route->family == AF_INET)
+ family = 4;
+ else if (route->family == AF_INET6)
+ family = 6;
+
+ if (family != 0)
+ connman_dbus_dict_append_basic(&item, "ProtocolFamily",
+ DBUS_TYPE_INT32, &family);
+
+ if (route->network)
+ connman_dbus_dict_append_basic(&item, "Network",
+ DBUS_TYPE_STRING, &route->network);
+
+ if (route->netmask)
+ connman_dbus_dict_append_basic(&item, "Netmask",
+ DBUS_TYPE_STRING, &route->netmask);
+
+ if (route->gateway)
+ connman_dbus_dict_append_basic(&item, "Gateway",
+ DBUS_TYPE_STRING, &route->gateway);
+
+empty_dict:
+ connman_dbus_dict_close(iter, &item);
+}
+
+static void append_routes(DBusMessageIter *iter, void *user_data)
+{
+ GSList *list, *routes = user_data;
+
+ DBG("routes %p", routes);
+
+ for (list = routes; list; list = g_slist_next(list)) {
+ DBusMessageIter dict;
+ struct vpn_route *route = list->data;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
+ &dict);
+ append_route(&dict, route);
+ dbus_message_iter_close_container(iter, &dict);
+ }
+}
+
+static int create_configuration(DBusMessage *msg, connection_ready_cb callback)
+{
+ DBusMessage *new_msg = NULL;
+ DBusPendingCall *call;
+ DBusMessageIter iter, array, new_iter, new_dict;
+ const char *type = NULL, *name = NULL;
+ const char *host = NULL, *domain = NULL;
+ char *ident, *me = NULL;
+ int err = 0;
+ dbus_bool_t result;
+ struct connection_data *data;
+ struct config_create_data *user_data = NULL;
+ GSList *networks = NULL;
+
+ /*
+ * We copy the old message data into new message. We cannot
+ * just use the old message as is because the user route
+ * information is not in the same format in vpnd.
+ */
+ new_msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
+ dbus_message_iter_init_append(new_msg, &new_iter);
+ connman_dbus_dict_open(&new_iter, &new_dict);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ void *item_value;
+ const char *key;
+ int value_type;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ value_type = dbus_message_iter_get_arg_type(&value);
+ item_value = NULL;
+
+ switch (value_type) {
+ case DBUS_TYPE_STRING:
+ dbus_message_iter_get_basic(&value, &item_value);
+
+ if (g_str_equal(key, "Type"))
+ type = (const char *)item_value;
+ else if (g_str_equal(key, "Name"))
+ name = (const char *)item_value;
+ else if (g_str_equal(key, "Host"))
+ host = (const char *)item_value;
+ else if (g_str_equal(key, "VPN.Domain"))
+ domain = (const char *)item_value;
+
+ DBG("%s %s", key, (char *)item_value);
+
+ if (item_value)
+ connman_dbus_dict_append_basic(&new_dict, key,
+ value_type, &item_value);
+ break;
+ case DBUS_TYPE_ARRAY:
+ if (g_str_equal(key, "Networks")) {
+ networks = get_user_networks(&value);
+ connman_dbus_dict_append_array(&new_dict,
+ "UserRoutes",
+ DBUS_TYPE_DICT_ENTRY,
+ append_routes,
+ networks);
+ }
+ break;
+ }
+
+ dbus_message_iter_next(&array);
+ }
+
+ connman_dbus_dict_close(&new_iter, &new_dict);
+
+ DBG("VPN type %s name %s host %s domain %s networks %p",
+ type, name, host, domain, networks);
+
+ if (!host || !domain) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ if (!type || !name) {
+ err = -EOPNOTSUPP;
+ goto done;
+ }
+
+ ident = g_strdup_printf("%s_%s", host, domain);
+ set_dbus_ident(ident);
+
+ DBG("ident %s", ident);
+
+ data = g_hash_table_lookup(vpn_connections, ident);
+ if (data) {
+ if (data->call || data->cb_data) {
+ DBG("create configuration call already pending");
+ err = -EINPROGRESS;
+ goto done;
+ }
+ } else {
+ char *path = g_strdup_printf("%s/connection/%s", VPN_PATH,
+ ident);
+ data = create_connection_data(path);
+ g_free(path);
+
+ if (!data) {
+ err = -ENOMEM;
+ goto done;
+ }
+
+ g_hash_table_insert(vpn_connections, g_strdup(ident), data);
+ }
+
+ /*
+ * User called net.connman.Manager.ConnectProvider if we are here.
+ * So use the data from original message in the new msg.
+ */
+ me = g_strdup(dbus_message_get_destination(msg));
+
+ dbus_message_set_interface(new_msg, VPN_MANAGER_INTERFACE);
+ dbus_message_set_path(new_msg, "/");
+ dbus_message_set_destination(new_msg, VPN_SERVICE);
+ dbus_message_set_sender(new_msg, me);
+ dbus_message_set_member(new_msg, "Create");
+
+ user_data = g_try_new0(struct config_create_data, 1);
+ if (!user_data) {
+ err = -ENOMEM;
+ goto done;
+ }
+
+ user_data->callback = callback;
+ user_data->message = dbus_message_ref(msg);
+ user_data->path = NULL;
+
+ DBG("cb %p msg %p", user_data, msg);
+
+ result = dbus_connection_send_with_reply(connection, new_msg,
+ &call, DBUS_TIMEOUT);
+ if (!result || !call) {
+ err = -EIO;
+ goto done;
+ }
+
+ dbus_pending_call_set_notify(call, configuration_create_reply,
+ user_data, NULL);
+ data->call = call;
+
+done:
+ if (new_msg)
+ dbus_message_unref(new_msg);
+
+ if (networks)
+ g_slist_free_full(networks, destroy_route);
+
+ g_free(me);
+ return err;
+}
+
+static bool check_host(char **hosts, char *host)
+{
+ int i;
+
+ if (!hosts)
+ return false;
+
+ for (i = 0; hosts[i]; i++) {
+ if (g_strcmp0(hosts[i], host) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+static void set_route(struct connection_data *data, struct vpn_route *route)
+{
+ /*
+ * If the VPN administrator/user has given a route to
+ * VPN server, then we must discard that because the
+ * server cannot be contacted via VPN tunnel.
+ */
+ if (check_host(data->host_ip, route->network)) {
+ DBG("Discarding VPN route to %s via %s at index %d",
+ route->network, route->gateway, data->index);
+ return;
+ }
+
+ if (route->family == AF_INET6) {
+ unsigned char prefix_len = atoi(route->netmask);
+
+ connman_inet_add_ipv6_network_route(data->index,
+ route->network,
+ route->gateway,
+ prefix_len);
+ } else {
+ connman_inet_add_network_route(data->index, route->network,
+ route->gateway,
+ route->netmask);
+ }
+}
+
+static int set_routes(struct connman_provider *provider,
+ enum connman_provider_route_type type)
+{
+ struct connection_data *data;
+ GHashTableIter iter;
+ gpointer value, key;
+
+ DBG("provider %p", provider);
+
+ data = connman_provider_get_data(provider);
+ if (!data)
+ return -EINVAL;
+
+ if (type == CONNMAN_PROVIDER_ROUTE_ALL ||
+ type == CONNMAN_PROVIDER_ROUTE_USER) {
+ g_hash_table_iter_init(&iter, data->user_routes);
+
+ while (g_hash_table_iter_next(&iter, &key, &value))
+ set_route(data, value);
+ }
+
+ if (type == CONNMAN_PROVIDER_ROUTE_ALL ||
+ type == CONNMAN_PROVIDER_ROUTE_SERVER) {
+ g_hash_table_iter_init(&iter, data->server_routes);
+
+ while (g_hash_table_iter_next(&iter, &key, &value))
+ set_route(data, value);
+ }
+
+ return 0;
+}
+
+static bool check_routes(struct connman_provider *provider)
+{
+ struct connection_data *data;
+
+ DBG("provider %p", provider);
+
+ data = connman_provider_get_data(provider);
+ if (!data)
+ return false;
+
+ if (data->user_routes &&
+ g_hash_table_size(data->user_routes) > 0)
+ return true;
+
+ if (data->server_routes &&
+ g_hash_table_size(data->server_routes) > 0)
+ return true;
+
+ return false;
+}
+
+static struct connman_provider_driver provider_driver = {
+ .name = "VPN",
+ .type = CONNMAN_PROVIDER_TYPE_VPN,
+ .probe = provider_probe,
+ .remove = provider_remove,
+ .connect = provider_connect,
+ .disconnect = provider_disconnect,
+ .set_property = set_string,
+ .get_property = get_string,
+ .create = create_configuration,
+ .set_routes = set_routes,
+ .check_routes = check_routes,
+};
+
+static void destroy_provider(struct connection_data *data)
+{
+ DBG("data %p", data);
+
+ if (g_str_equal(data->state, "ready") ||
+ g_str_equal(data->state, "configuration"))
+ connman_provider_disconnect(data->provider);
+
+ if (data->call)
+ dbus_pending_call_cancel(data->call);
+
+ connman_provider_set_data(data->provider, NULL);
+
+ connman_provider_remove(data->provider);
+
+ data->provider = NULL;
+}
+
+static void connection_destroy(gpointer hash_data)
+{
+ struct connection_data *data = hash_data;
+
+ DBG("data %p", data);
+
+ if (data->provider)
+ destroy_provider(data);
+
+ g_free(data->path);
+ g_free(data->ident);
+ g_free(data->state);
+ g_free(data->type);
+ g_free(data->name);
+ g_free(data->host);
+ g_free(data->host_ip);
+ g_free(data->domain);
+ g_hash_table_destroy(data->server_routes);
+ g_hash_table_destroy(data->user_routes);
+ g_strfreev(data->nameservers);
+ g_hash_table_destroy(data->setting_strings);
+ connman_ipaddress_free(data->ip);
+
+ cancel_host_resolv(data);
+
+ g_free(data);
+}
+
+static void vpnd_created(DBusConnection *conn, void *user_data)
+{
+ DBG("connection %p", conn);
+
+ get_connections(user_data);
+}
+
+static void vpnd_removed(DBusConnection *conn, void *user_data)
+{
+ DBG("connection %p", conn);
+
+ g_hash_table_remove_all(vpn_connections);
+}
+
+static void remove_connection(DBusConnection *conn, const char *path)
+{
+ DBG("path %s", path);
+
+ g_hash_table_remove(vpn_connections, get_ident(path));
+}
+
+static gboolean connection_removed(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ const char *path;
+ const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ struct connection_data *data;
+
+ if (!dbus_message_has_signature(message, signature)) {
+ connman_error("vpn removed signature \"%s\" does not match "
+ "expected \"%s\"",
+ dbus_message_get_signature(message), signature);
+ return TRUE;
+ }
+
+ dbus_message_get_args(message, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ data = g_hash_table_lookup(vpn_connections, get_ident(path));
+ if (data)
+ remove_connection(conn, path);
+
+ return TRUE;
+}
+
+static gboolean connection_added(DBusConnection *conn, DBusMessage *message,
+ void *user_data)
+{
+ DBusMessageIter iter, properties;
+ const char *path;
+ const char *signature = DBUS_TYPE_OBJECT_PATH_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
+
+ if (!dbus_message_has_signature(message, signature)) {
+ connman_error("vpn ConnectionAdded signature \"%s\" does not "
+ "match expected \"%s\"",
+ dbus_message_get_signature(message), signature);
+ return TRUE;
+ }
+
+ DBG("");
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &path);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &properties);
+
+ add_connection(path, &properties, user_data);
+
+ return TRUE;
+}
+
+static int save_route(GHashTable *routes, int family, const char *network,
+ const char *netmask, const char *gateway)
+{
+ struct vpn_route *route;
+ char *key = g_strdup_printf("%d/%s/%s", family, network, netmask);
+
+ DBG("family %d network %s netmask %s", family, network, netmask);
+
+ route = g_hash_table_lookup(routes, key);
+ if (!route) {
+ route = g_try_new0(struct vpn_route, 1);
+ if (!route) {
+ connman_error("out of memory");
+ return -ENOMEM;
+ }
+
+ route->family = family;
+ route->network = g_strdup(network);
+ route->netmask = g_strdup(netmask);
+ route->gateway = g_strdup(gateway);
+
+ g_hash_table_replace(routes, key, route);
+ } else
+ g_free(key);
+
+ return 0;
+}
+
+static int read_route_dict(GHashTable *routes, DBusMessageIter *dicts)
+{
+ DBusMessageIter dict;
+ const char *network, *netmask, *gateway;
+ int family;
+
+ dbus_message_iter_recurse(dicts, &dict);
+
+ network = netmask = gateway = NULL;
+ family = PF_UNSPEC;
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (g_str_equal(key, "ProtocolFamily")) {
+ int pf;
+ dbus_message_iter_get_basic(&value, &pf);
+ switch (pf) {
+ case 4:
+ family = AF_INET;
+ break;
+ case 6:
+ family = AF_INET6;
+ break;
+ }
+ DBG("family %d", family);
+ } else if (g_str_equal(key, "Netmask")) {
+ dbus_message_iter_get_basic(&value, &netmask);
+ DBG("netmask %s", netmask);
+ } else if (g_str_equal(key, "Network")) {
+ dbus_message_iter_get_basic(&value, &network);
+ DBG("host %s", network);
+ } else if (g_str_equal(key, "Gateway")) {
+ dbus_message_iter_get_basic(&value, &gateway);
+ DBG("gateway %s", gateway);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (!netmask || !network || !gateway) {
+ DBG("Value missing.");
+ return -EINVAL;
+ }
+
+ return save_route(routes, family, network, netmask, gateway);
+}
+
+static int routes_changed(DBusMessageIter *array, GHashTable *routes)
+{
+ DBusMessageIter entry;
+ int ret = -EINVAL;
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY) {
+ DBG("Expecting array, ignoring routes.");
+ return -EINVAL;
+ }
+
+ while (dbus_message_iter_get_arg_type(array) == DBUS_TYPE_ARRAY) {
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) ==
+ DBUS_TYPE_STRUCT) {
+ DBusMessageIter dicts;
+
+ dbus_message_iter_recurse(&entry, &dicts);
+
+ while (dbus_message_iter_get_arg_type(&dicts) ==
+ DBUS_TYPE_ARRAY) {
+ int err = read_route_dict(routes, &dicts);
+ if (ret != 0)
+ ret = err;
+ dbus_message_iter_next(&dicts);
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ dbus_message_iter_next(array);
+ }
+
+ return ret;
+}
+
+static gboolean property_changed(DBusConnection *conn,
+ DBusMessage *message,
+ void *user_data)
+{
+ const char *path = dbus_message_get_path(message);
+ struct connection_data *data = NULL;
+ DBusMessageIter iter, value;
+ bool ip_set = false;
+ int err;
+ char *str;
+ const char *key;
+ const char *signature = DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING;
+
+ if (!dbus_message_has_signature(message, signature)) {
+ connman_error("vpn property signature \"%s\" does not match "
+ "expected \"%s\"",
+ dbus_message_get_signature(message), signature);
+ return TRUE;
+ }
+
+ data = g_hash_table_lookup(vpn_connections, get_ident(path));
+ if (!data)
+ return TRUE;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return TRUE;
+
+ dbus_message_iter_get_basic(&iter, &key);
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_recurse(&iter, &value);
+
+ DBG("key %s", key);
+
+ if (g_str_equal(key, "State")) {
+ dbus_message_iter_get_basic(&value, &str);
+
+ DBG("%s %s -> %s", data->path, data->state, str);
+
+ if (g_str_equal(data->state, str))
+ return TRUE;
+
+ g_free(data->state);
+ data->state = g_strdup(str);
+
+ set_provider_state(data);
+ } else if (g_str_equal(key, "Index")) {
+ dbus_message_iter_get_basic(&value, &data->index);
+ connman_provider_set_index(data->provider, data->index);
+ } else if (g_str_equal(key, "IPv4")) {
+ err = extract_ip(&value, AF_INET, data);
+ ip_set = true;
+ } else if (g_str_equal(key, "IPv6")) {
+ err = extract_ip(&value, AF_INET6, data);
+ ip_set = true;
+ } else if (g_str_equal(key, "ServerRoutes")) {
+ err = routes_changed(&value, data->server_routes);
+ /*
+ * Note that the vpnd will delay the route sending a bit
+ * (in order to collect the routes from VPN client),
+ * so we might have got the State changed property before
+ * we got ServerRoutes. This means that we must try to set
+ * the routes here because they would be left unset otherwise.
+ */
+ if (err == 0)
+ set_routes(data->provider,
+ CONNMAN_PROVIDER_ROUTE_SERVER);
+ } else if (g_str_equal(key, "UserRoutes")) {
+ err = routes_changed(&value, data->user_routes);
+ if (err == 0)
+ set_routes(data->provider,
+ CONNMAN_PROVIDER_ROUTE_USER);
+ } else if (g_str_equal(key, "Nameservers")) {
+ if (extract_nameservers(&value, data) == 0 &&
+ data->nameservers)
+ connman_provider_set_nameservers(data->provider,
+ data->nameservers);
+ } else if (g_str_equal(key, "Domain")) {
+ dbus_message_iter_get_basic(&value, &str);
+ g_free(data->domain);
+ data->domain = g_strdup(str);
+ connman_provider_set_domain(data->provider, data->domain);
+ }
+
+ if (ip_set && err == 0) {
+ err = connman_provider_set_ipaddress(data->provider, data->ip);
+ if (err < 0)
+ DBG("setting provider IP address failed (%s/%d)",
+ strerror(-err), -err);
+ }
+
+ return TRUE;
+}
+
+static int vpn_init(void)
+{
+ int err;
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EIO;
+
+ watch = g_dbus_add_service_watch(connection, VPN_SERVICE,
+ vpnd_created, vpnd_removed, &provider_driver, NULL);
+
+ added_watch = g_dbus_add_signal_watch(connection, VPN_SERVICE, NULL,
+ VPN_MANAGER_INTERFACE,
+ CONNECTION_ADDED, connection_added,
+ &provider_driver, NULL);
+
+ removed_watch = g_dbus_add_signal_watch(connection, VPN_SERVICE, NULL,
+ VPN_MANAGER_INTERFACE,
+ CONNECTION_REMOVED, connection_removed,
+ NULL, NULL);
+
+ property_watch = g_dbus_add_signal_watch(connection, VPN_SERVICE, NULL,
+ VPN_CONNECTION_INTERFACE,
+ PROPERTY_CHANGED, property_changed,
+ NULL, NULL);
+
+ if (added_watch == 0 || removed_watch == 0 || property_watch == 0) {
+ err = -EIO;
+ goto remove;
+ }
+
+ err = connman_provider_driver_register(&provider_driver);
+ if (err == 0) {
+ vpn_connections = g_hash_table_new_full(g_str_hash,
+ g_str_equal,
+ g_free, connection_destroy);
+
+ vpnd_created(connection, &provider_driver);
+ }
+
+ return err;
+
+remove:
+ g_dbus_remove_watch(connection, watch);
+ g_dbus_remove_watch(connection, added_watch);
+ g_dbus_remove_watch(connection, removed_watch);
+ g_dbus_remove_watch(connection, property_watch);
+
+ dbus_connection_unref(connection);
+
+ return err;
+}
+
+static void vpn_exit(void)
+{
+ g_dbus_remove_watch(connection, watch);
+ g_dbus_remove_watch(connection, added_watch);
+ g_dbus_remove_watch(connection, removed_watch);
+ g_dbus_remove_watch(connection, property_watch);
+
+ connman_provider_driver_unregister(&provider_driver);
+
+ if (vpn_connections)
+ g_hash_table_destroy(vpn_connections);
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(vpn, "VPN plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, vpn_init, vpn_exit)
diff --git a/plugins/wifi.c b/plugins/wifi.c
new file mode 100644
index 0000000..c823128
--- /dev/null
+++ b/plugins/wifi.c
@@ -0,0 +1,3469 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <linux/if_arp.h>
+#include <linux/wireless.h>
+#include <net/ethernet.h>
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+#include <dbus/dbus.h>
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/inet.h>
+#include <connman/device.h>
+#include <connman/rtnl.h>
+#include <connman/technology.h>
+#include <connman/service.h>
+#include <connman/peer.h>
+#include <connman/log.h>
+#include <connman/option.h>
+#include <connman/storage.h>
+#include <include/setting.h>
+#include <connman/provision.h>
+#include <connman/utsname.h>
+#include <connman/machine.h>
+
+#include <gsupplicant/gsupplicant.h>
+
+#define wifi_data_ref(wifi) \
+ wifi_data_ref_debug(wifi, __FILE__, __LINE__, __func__)
+
+#define wifi_data_unref(wifi) \
+ wifi_data_unref_debug(wifi, __FILE__, __LINE__, __func__)
+
+#define CLEANUP_TIMEOUT 8 /* in seconds */
+#define INACTIVE_TIMEOUT 12 /* in seconds */
+#define FAVORITE_MAXIMUM_RETRIES 2
+
+#define BGSCAN_DEFAULT "simple:30:-45:300"
+#define AUTOSCAN_DEFAULT "exponential:3:300"
+
+#define P2P_FIND_TIMEOUT 30
+#define P2P_CONNECTION_TIMEOUT 100
+#define P2P_LISTEN_PERIOD 500
+#define P2P_LISTEN_INTERVAL 2000
+
+#define GSUP_80211_ASSOC_STATUS_NO_ADDITIONAL_CLIENT 17
+#define GSUP_80211_ASSOC_STATUS_UNSPECIFIED_FAILURE 1
+#define GSUP_80211_ASSOC_STATUS_REJECTED_TEMPORARILY 30
+#define WPA_SUP_LOAD_SHAPING_MAX_RETRIES 3
+static struct connman_technology *wifi_technology = NULL;
+static struct connman_technology *p2p_technology = NULL;
+
+enum wifi_ap_capability{
+ WIFI_AP_UNKNOWN = 0,
+ WIFI_AP_SUPPORTED = 1,
+ WIFI_AP_NOT_SUPPORTED = 2,
+};
+
+struct hidden_params {
+ char ssid[32];
+ unsigned int ssid_len;
+ char *identity;
+ char *passphrase;
+ char *security;
+ GSupplicantScanParams *scan_params;
+ gpointer user_data;
+};
+
+/**
+ * Used for autoscan "emulation".
+ * Should be removed when wpa_s autoscan support will be by default.
+ */
+struct autoscan_params {
+ int base;
+ int limit;
+ int interval;
+ unsigned int timeout;
+};
+
+struct wifi_tethering_info {
+ struct wifi_data *wifi;
+ struct connman_technology *technology;
+ char *ifname;
+ GSupplicantSSID *ssid;
+};
+
+struct wifi_data {
+ int refcount;
+ char *identifier;
+ struct connman_device *device;
+ struct connman_network *network;
+ struct connman_network *pending_network;
+ GSList *networks;
+ GSupplicantInterface *interface;
+ GSupplicantState state;
+ bool connected;
+ bool disconnecting;
+ bool tethering;
+ enum wifi_ap_capability ap_supported;
+ bool bridged;
+ bool interface_ready;
+ bool shutting_down;
+ const char *bridge;
+ int index;
+ unsigned flags;
+ unsigned int watch;
+ int retries;
+ int wpa_sup_load_shaping_retries;
+ struct hidden_params *hidden;
+ bool postpone_hidden;
+ struct wifi_tethering_info *tethering_param;
+ /**
+ * autoscan "emulation".
+ */
+ struct autoscan_params *autoscan;
+
+ GSupplicantScanParams *scan_params;
+ unsigned int p2p_find_timeout;
+ unsigned int p2p_connection_timeout;
+ struct connman_peer *pending_peer;
+ GSupplicantPeer *peer;
+ bool p2p_connecting;
+ bool p2p_device;
+ int servicing;
+ bool scanning;
+ int disconnect_reasoncode;
+ int assoc_statuscode;
+};
+
+static GList *iface_list = NULL;
+
+static GList *pending_wifi_device = NULL;
+static GList *p2p_iface_list = NULL;
+bool wfd_service_registered = false;
+
+static void start_autoscan(struct connman_device *device);
+static int tech_set_tethering(struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled);
+
+static void wifi_data_ref_debug(struct wifi_data *wifi,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", wifi, wifi->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&wifi->refcount, 1);
+}
+
+static void wifi_data_unref_debug(struct wifi_data *wifi,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p unref %d by %s:%d:%s()", wifi, wifi->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&wifi->refcount, 1) != 1)
+ return;
+
+ g_free(wifi);
+}
+
+static inline bool wifi_link_removed(struct wifi_data *wifi)
+{
+ return (!wifi || wifi->shutting_down);
+}
+
+static int p2p_tech_probe(struct connman_technology *technology)
+{
+ p2p_technology = technology;
+
+ return 0;
+}
+
+static void p2p_tech_remove(struct connman_technology *technology)
+{
+ p2p_technology = NULL;
+}
+
+static struct connman_technology_driver p2p_tech_driver = {
+ .name = "p2p",
+ .type = CONNMAN_SERVICE_TYPE_P2P,
+ .probe = p2p_tech_probe,
+ .remove = p2p_tech_remove,
+};
+
+static bool is_p2p_connecting(void)
+{
+ GList *list;
+
+ for (list = iface_list; list; list = list->next) {
+ struct wifi_data *wifi = list->data;
+
+ if (wifi->p2p_connecting)
+ return true;
+ }
+
+ return false;
+}
+
+static void add_pending_wifi_device(struct wifi_data *wifi)
+{
+ if (g_list_find(pending_wifi_device, wifi))
+ return;
+
+ pending_wifi_device = g_list_append(pending_wifi_device, wifi);
+}
+
+static struct wifi_data *get_pending_wifi_data(const char *ifname)
+{
+ GList *list;
+
+ for (list = pending_wifi_device; list; list = list->next) {
+ struct wifi_data *wifi;
+ const char *dev_name;
+
+ wifi = list->data;
+ if (!wifi || !wifi->device)
+ continue;
+
+ dev_name = connman_device_get_string(wifi->device, "Interface");
+ if (!g_strcmp0(ifname, dev_name)) {
+ pending_wifi_device = g_list_delete_link(
+ pending_wifi_device, list);
+ return wifi;
+ }
+ }
+
+ return NULL;
+}
+
+static void remove_pending_wifi_device(struct wifi_data *wifi)
+{
+ GList *link;
+
+ link = g_list_find(pending_wifi_device, wifi);
+
+ if (!link)
+ return;
+
+ pending_wifi_device = g_list_delete_link(pending_wifi_device, link);
+}
+
+static void peer_cancel_timeout(struct wifi_data *wifi)
+{
+ if (wifi->p2p_connection_timeout > 0)
+ g_source_remove(wifi->p2p_connection_timeout);
+
+ wifi->p2p_connection_timeout = 0;
+ wifi->p2p_connecting = false;
+
+ if (wifi->pending_peer) {
+ connman_peer_unref(wifi->pending_peer);
+ wifi->pending_peer = NULL;
+ }
+
+ wifi->peer = NULL;
+}
+
+static gboolean peer_connect_timeout(gpointer data)
+{
+ struct wifi_data *wifi = data;
+
+ DBG("");
+
+ if (wifi->p2p_connecting) {
+ enum connman_peer_state state = CONNMAN_PEER_STATE_FAILURE;
+
+ if (g_supplicant_peer_has_requested_connection(wifi->peer))
+ state = CONNMAN_PEER_STATE_IDLE;
+
+ connman_peer_set_state(wifi->pending_peer, state);
+ }
+
+ peer_cancel_timeout(wifi);
+
+ return FALSE;
+}
+
+static void peer_connect_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct wifi_data *wifi = user_data;
+ struct connman_peer *peer = wifi->pending_peer;
+
+ DBG("peer %p - %d", peer, result);
+
+ if (!peer)
+ return;
+
+ if (result < 0) {
+ peer_connect_timeout(wifi);
+ return;
+ }
+
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_ASSOCIATION);
+
+ wifi->p2p_connection_timeout = g_timeout_add_seconds(
+ P2P_CONNECTION_TIMEOUT,
+ peer_connect_timeout, wifi);
+}
+
+static int peer_connect(struct connman_peer *peer,
+ enum connman_peer_wps_method wps_method,
+ const char *wps_pin)
+{
+ struct connman_device *device = connman_peer_get_device(peer);
+ GSupplicantPeerParams *peer_params;
+ GSupplicantPeer *gs_peer;
+ struct wifi_data *wifi;
+ bool pbc, pin;
+ int ret;
+
+ DBG("peer %p", peer);
+
+ if (!device)
+ return -ENODEV;
+
+ wifi = connman_device_get_data(device);
+ if (!wifi)
+ return -ENODEV;
+
+ if (wifi->p2p_connecting)
+ return -EBUSY;
+
+ wifi->peer = NULL;
+
+ gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
+ connman_peer_get_identifier(peer));
+ if (!gs_peer)
+ return -EINVAL;
+
+ pbc = g_supplicant_peer_is_wps_pbc(gs_peer);
+ pin = g_supplicant_peer_is_wps_pin(gs_peer);
+
+ switch (wps_method) {
+ case CONNMAN_PEER_WPS_UNKNOWN:
+ if ((pbc && pin) || pin)
+ return -ENOKEY;
+ break;
+ case CONNMAN_PEER_WPS_PBC:
+ if (!pbc)
+ return -EINVAL;
+ wps_pin = NULL;
+ break;
+ case CONNMAN_PEER_WPS_PIN:
+ if (!pin || !wps_pin)
+ return -EINVAL;
+ break;
+ }
+
+ peer_params = g_try_malloc0(sizeof(GSupplicantPeerParams));
+ if (!peer_params)
+ return -ENOMEM;
+
+ peer_params->path = g_strdup(g_supplicant_peer_get_path(gs_peer));
+ if (wps_pin)
+ peer_params->wps_pin = g_strdup(wps_pin);
+
+ peer_params->master = connman_peer_service_is_master();
+
+ ret = g_supplicant_interface_p2p_connect(wifi->interface, peer_params,
+ peer_connect_callback, wifi);
+ if (ret == -EINPROGRESS) {
+ wifi->pending_peer = connman_peer_ref(peer);
+ wifi->peer = gs_peer;
+ wifi->p2p_connecting = true;
+ } else if (ret < 0)
+ g_free(peer_params);
+
+ return ret;
+}
+
+static int peer_disconnect(struct connman_peer *peer)
+{
+ struct connman_device *device = connman_peer_get_device(peer);
+ GSupplicantPeerParams peer_params = {};
+ GSupplicantPeer *gs_peer;
+ struct wifi_data *wifi;
+ int ret;
+
+ DBG("peer %p", peer);
+
+ if (!device)
+ return -ENODEV;
+
+ wifi = connman_device_get_data(device);
+ if (!wifi)
+ return -ENODEV;
+
+ gs_peer = g_supplicant_interface_peer_lookup(wifi->interface,
+ connman_peer_get_identifier(peer));
+ if (!gs_peer)
+ return -EINVAL;
+
+ peer_params.path = g_strdup(g_supplicant_peer_get_path(gs_peer));
+
+ ret = g_supplicant_interface_p2p_disconnect(wifi->interface,
+ &peer_params);
+ g_free(peer_params.path);
+
+ if (ret == -EINPROGRESS)
+ peer_cancel_timeout(wifi);
+
+ return ret;
+}
+
+struct peer_service_registration {
+ peer_service_registration_cb_t callback;
+ void *user_data;
+};
+
+static bool is_service_wfd(const unsigned char *specs, int length)
+{
+ if (length < 9 || specs[0] != 0 || specs[1] != 0 || specs[2] != 6)
+ return false;
+
+ return true;
+}
+
+static void apply_p2p_listen_on_iface(gpointer data, gpointer user_data)
+{
+ struct wifi_data *wifi = data;
+
+ if (!wifi->interface ||
+ !g_supplicant_interface_has_p2p(wifi->interface))
+ return;
+
+ if (!wifi->servicing) {
+ g_supplicant_interface_p2p_listen(wifi->interface,
+ P2P_LISTEN_PERIOD, P2P_LISTEN_INTERVAL);
+ }
+
+ wifi->servicing++;
+}
+
+static void register_wfd_service_cb(int result,
+ GSupplicantInterface *iface, void *user_data)
+{
+ struct peer_service_registration *reg_data = user_data;
+
+ DBG("");
+
+ if (result == 0)
+ g_list_foreach(iface_list, apply_p2p_listen_on_iface, NULL);
+
+ if (reg_data && reg_data->callback) {
+ reg_data->callback(result, reg_data->user_data);
+ g_free(reg_data);
+ }
+}
+
+static GSupplicantP2PServiceParams *fill_in_peer_service_params(
+ const unsigned char *spec,
+ int spec_length, const unsigned char *query,
+ int query_length, int version)
+{
+ GSupplicantP2PServiceParams *params;
+
+ params = g_try_malloc0(sizeof(GSupplicantP2PServiceParams));
+ if (!params)
+ return NULL;
+
+ if (version > 0) {
+ params->version = version;
+ params->service = g_memdup(spec, spec_length);
+ } else if (query_length > 0 && spec_length > 0) {
+ params->query = g_memdup(query, query_length);
+ params->query_length = query_length;
+
+ params->response = g_memdup(spec, spec_length);
+ params->response_length = spec_length;
+ } else {
+ params->wfd_ies = g_memdup(spec, spec_length);
+ params->wfd_ies_length = spec_length;
+ }
+
+ return params;
+}
+
+static void free_peer_service_params(GSupplicantP2PServiceParams *params)
+{
+ if (!params)
+ return;
+
+ g_free(params->service);
+ g_free(params->query);
+ g_free(params->response);
+ g_free(params->wfd_ies);
+
+ g_free(params);
+}
+
+static int peer_register_wfd_service(const unsigned char *specification,
+ int specification_length,
+ peer_service_registration_cb_t callback,
+ void *user_data)
+{
+ struct peer_service_registration *reg_data = NULL;
+ static GSupplicantP2PServiceParams *params;
+ int ret;
+
+ DBG("");
+
+ if (wfd_service_registered)
+ return -EBUSY;
+
+ params = fill_in_peer_service_params(specification,
+ specification_length, NULL, 0, 0);
+ if (!params)
+ return -ENOMEM;
+
+ reg_data = g_try_malloc0(sizeof(*reg_data));
+ if (!reg_data) {
+ ret = -ENOMEM;
+ goto error;
+ }
+
+ reg_data->callback = callback;
+ reg_data->user_data = user_data;
+
+ ret = g_supplicant_set_widi_ies(params,
+ register_wfd_service_cb, reg_data);
+ if (ret < 0 && ret != -EINPROGRESS)
+ goto error;
+
+ wfd_service_registered = true;
+
+ return ret;
+error:
+ free_peer_service_params(params);
+ g_free(reg_data);
+
+ return ret;
+}
+
+static void register_peer_service_cb(int result,
+ GSupplicantInterface *iface, void *user_data)
+{
+ struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
+ struct peer_service_registration *reg_data = user_data;
+
+ DBG("");
+
+ if (result == 0)
+ apply_p2p_listen_on_iface(wifi, NULL);
+
+ if (reg_data->callback)
+ reg_data->callback(result, reg_data->user_data);
+
+ g_free(reg_data);
+}
+
+static int peer_register_service(const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version,
+ peer_service_registration_cb_t callback,
+ void *user_data)
+{
+ struct peer_service_registration *reg_data;
+ GSupplicantP2PServiceParams *params;
+ bool found = false;
+ int ret, ret_f;
+ GList *list;
+
+ DBG("");
+
+ if (specification && !version && !query &&
+ is_service_wfd(specification, specification_length)) {
+ return peer_register_wfd_service(specification,
+ specification_length, callback, user_data);
+ }
+
+ reg_data = g_try_malloc0(sizeof(*reg_data));
+ if (!reg_data)
+ return -ENOMEM;
+
+ reg_data->callback = callback;
+ reg_data->user_data = user_data;
+
+ ret_f = -EOPNOTSUPP;
+
+ for (list = iface_list; list; list = list->next) {
+ struct wifi_data *wifi = list->data;
+ GSupplicantInterface *iface = wifi->interface;
+
+ if (!g_supplicant_interface_has_p2p(iface))
+ continue;
+
+ params = fill_in_peer_service_params(specification,
+ specification_length, query,
+ query_length, version);
+ if (!params) {
+ ret = -ENOMEM;
+ continue;
+ }
+
+ if (!found) {
+ ret_f = g_supplicant_interface_p2p_add_service(iface,
+ register_peer_service_cb, params, reg_data);
+ if (ret_f == 0 || ret_f == -EINPROGRESS)
+ found = true;
+ ret = ret_f;
+ } else
+ ret = g_supplicant_interface_p2p_add_service(iface,
+ register_peer_service_cb, params, NULL);
+ if (ret != 0 && ret != -EINPROGRESS)
+ free_peer_service_params(params);
+ }
+
+ if (ret_f != 0 && ret_f != -EINPROGRESS)
+ g_free(reg_data);
+
+ return ret_f;
+}
+
+static int peer_unregister_wfd_service(void)
+{
+ GSupplicantP2PServiceParams *params;
+ GList *list;
+
+ if (!wfd_service_registered)
+ return -EALREADY;
+
+ params = fill_in_peer_service_params(NULL, 0, NULL, 0, 0);
+ if (!params)
+ return -ENOMEM;
+
+ wfd_service_registered = false;
+
+ g_supplicant_set_widi_ies(params, NULL, NULL);
+
+ for (list = iface_list; list; list = list->next) {
+ struct wifi_data *wifi = list->data;
+
+ if (!g_supplicant_interface_has_p2p(wifi->interface))
+ continue;
+
+ wifi->servicing--;
+ if (!wifi->servicing || wifi->servicing < 0) {
+ g_supplicant_interface_p2p_listen(wifi->interface,
+ 0, 0);
+ wifi->servicing = 0;
+ }
+ }
+
+ return 0;
+}
+
+static int peer_unregister_service(const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version)
+{
+ GSupplicantP2PServiceParams *params;
+ bool wfd = false;
+ GList *list;
+ int ret;
+
+ if (specification && !version && !query &&
+ is_service_wfd(specification, specification_length)) {
+ ret = peer_unregister_wfd_service();
+ if (ret != 0 && ret != -EINPROGRESS)
+ return ret;
+ wfd = true;
+ }
+
+ for (list = iface_list; list; list = list->next) {
+ struct wifi_data *wifi = list->data;
+ GSupplicantInterface *iface = wifi->interface;
+
+ if (wfd)
+ goto stop_listening;
+
+ if (!g_supplicant_interface_has_p2p(iface))
+ continue;
+
+ params = fill_in_peer_service_params(specification,
+ specification_length, query,
+ query_length, version);
+ if (!params) {
+ ret = -ENOMEM;
+ continue;
+ }
+
+ ret = g_supplicant_interface_p2p_del_service(iface, params);
+ if (ret != 0 && ret != -EINPROGRESS)
+ free_peer_service_params(params);
+stop_listening:
+ wifi->servicing--;
+ if (!wifi->servicing || wifi->servicing < 0) {
+ g_supplicant_interface_p2p_listen(iface, 0, 0);
+ wifi->servicing = 0;
+ }
+ }
+
+ return 0;
+}
+
+static struct connman_peer_driver peer_driver = {
+ .connect = peer_connect,
+ .disconnect = peer_disconnect,
+ .register_service = peer_register_service,
+ .unregister_service = peer_unregister_service,
+};
+
+static void handle_tethering(struct wifi_data *wifi)
+{
+ if (!wifi->tethering)
+ return;
+
+ if (!wifi->bridge)
+ return;
+
+ if (wifi->bridged)
+ return;
+
+ DBG("index %d bridge %s", wifi->index, wifi->bridge);
+
+ if (connman_inet_add_to_bridge(wifi->index, wifi->bridge) < 0)
+ return;
+
+ wifi->bridged = true;
+}
+
+static void wifi_newlink(unsigned flags, unsigned change, void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ DBG("index %d flags %d change %d", wifi->index, flags, change);
+
+ if ((wifi->flags & IFF_UP) != (flags & IFF_UP)) {
+ if (flags & IFF_UP)
+ DBG("interface up");
+ else
+ DBG("interface down");
+ }
+
+ if ((wifi->flags & IFF_LOWER_UP) != (flags & IFF_LOWER_UP)) {
+ if (flags & IFF_LOWER_UP) {
+ DBG("carrier on");
+
+ handle_tethering(wifi);
+ } else
+ DBG("carrier off");
+ }
+
+ wifi->flags = flags;
+}
+
+static int wifi_probe(struct connman_device *device)
+{
+ struct wifi_data *wifi;
+
+ DBG("device %p", device);
+
+ wifi = g_try_new0(struct wifi_data, 1);
+ if (!wifi)
+ return -ENOMEM;
+
+ wifi->refcount = 1;
+ wifi->shutting_down = false;
+ wifi->scanning = false;
+
+ DBG("wifi allocated %p ref count %d", wifi, wifi->refcount);
+ wifi->state = G_SUPPLICANT_STATE_INACTIVE;
+ wifi->ap_supported = WIFI_AP_UNKNOWN;
+ wifi->tethering_param = NULL;
+
+ connman_device_set_data(device, wifi);
+ wifi->device = connman_device_ref(device);
+
+ wifi->index = connman_device_get_index(device);
+ wifi->flags = 0;
+
+ wifi->watch = connman_rtnl_add_newlink_watch(wifi->index,
+ wifi_newlink, device);
+ if (is_p2p_connecting())
+ add_pending_wifi_device(wifi);
+ else
+ iface_list = g_list_append(iface_list, wifi);
+
+ return 0;
+}
+
+static void remove_networks(struct connman_device *device,
+ struct wifi_data *wifi)
+{
+ GSList *list;
+
+ for (list = wifi->networks; list; list = list->next) {
+ struct connman_network *network = list->data;
+
+ connman_device_remove_network(device, network);
+ connman_network_unref(network);
+ }
+
+ g_slist_free(wifi->networks);
+ wifi->networks = NULL;
+}
+
+static void reset_autoscan(struct connman_device *device)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ struct autoscan_params *autoscan;
+
+ DBG("");
+
+ if (!wifi || !wifi->autoscan)
+ return;
+
+ autoscan = wifi->autoscan;
+
+ if (autoscan->timeout == 0 && autoscan->interval == 0)
+ return;
+
+ g_source_remove(autoscan->timeout);
+
+ autoscan->timeout = 0;
+ autoscan->interval = 0;
+
+ connman_device_unref(device);
+}
+
+static void stop_autoscan(struct connman_device *device)
+{
+ const struct wifi_data *wifi = connman_device_get_data(device);
+
+ if (!wifi || !wifi->autoscan)
+ return;
+
+ reset_autoscan(device);
+
+ connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_WIFI, false);
+}
+
+static void check_p2p_technology(void)
+{
+ bool p2p_exists = false;
+ GList *list;
+
+ for (list = iface_list; list; list = list->next) {
+ struct wifi_data *w = list->data;
+
+ if (w->interface &&
+ g_supplicant_interface_has_p2p(w->interface))
+ p2p_exists = true;
+ }
+
+ if (!p2p_exists) {
+ connman_technology_driver_unregister(&p2p_tech_driver);
+ connman_peer_driver_unregister(&peer_driver);
+ }
+}
+
+static void wifi_remove(struct connman_device *device)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+
+ DBG("device %p wifi %p", device, wifi);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ g_supplicant_interface_remove(wifi->interface, NULL, NULL);
+ stop_autoscan(device);
+
+ if (wifi->p2p_device)
+ p2p_iface_list = g_list_remove(p2p_iface_list, wifi);
+ else
+ iface_list = g_list_remove(iface_list, wifi);
+
+ check_p2p_technology();
+
+ remove_pending_wifi_device(wifi);
+
+ if (wifi->p2p_find_timeout) {
+ g_source_remove(wifi->p2p_find_timeout);
+ connman_device_unref(wifi->device);
+ }
+
+ if (wifi->p2p_connection_timeout)
+ g_source_remove(wifi->p2p_connection_timeout);
+
+ remove_networks(device, wifi);
+
+ connman_device_set_powered(device, false);
+ connman_device_set_data(device, NULL);
+ connman_device_unref(wifi->device);
+ wifi->device = NULL;
+
+ connman_rtnl_remove_watch(wifi->watch);
+ wifi->watch = 0;
+
+ g_supplicant_interface_set_data(wifi->interface, NULL);
+ wifi->interface = NULL;
+
+ g_supplicant_interface_cancel(wifi->interface);
+
+ if (wifi->scan_params) {
+ g_supplicant_free_scan_params(wifi->scan_params);
+ wifi->scan_params = NULL;
+ }
+
+ g_free(wifi->autoscan);
+ wifi->autoscan = NULL;
+
+ g_free(wifi->identifier);
+ wifi->identifier = NULL;
+
+ wifi->shutting_down = true;
+
+ /* Remove ref added in wifi_scan() if scan is ongoing */
+ if (wifi->scanning)
+ wifi_data_unref(wifi);
+
+ /* Remove ref added in wifi_probe */
+ wifi_data_unref(wifi);
+}
+
+static bool is_duplicate(GSList *list, gchar *ssid, int ssid_len)
+{
+ GSList *iter;
+
+ for (iter = list; iter; iter = g_slist_next(iter)) {
+ struct scan_ssid *scan_ssid = iter->data;
+
+ if (ssid_len == scan_ssid->ssid_len &&
+ memcmp(ssid, scan_ssid->ssid, ssid_len) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+static int add_scan_param(gchar *hex_ssid, char *raw_ssid, int raw_ssid_len,
+ int freq, GSupplicantScanParams *scan_data,
+ int driver_max_scan_ssids, char *ssid_name)
+{
+ unsigned int i;
+ struct scan_ssid *scan_ssid;
+
+ if ((driver_max_scan_ssids == 0 ||
+ driver_max_scan_ssids > scan_data->num_ssids) &&
+ (hex_ssid || raw_ssid)) {
+ gchar *ssid;
+ unsigned int ssid_len = 0, hex;
+
+ if (hex_ssid) {
+ size_t hex_ssid_len = strlen(hex_ssid);
+
+ ssid = g_try_malloc0(hex_ssid_len / 2);
+ if (!ssid)
+ return -ENOMEM;
+
+ for (i = 0; i < hex_ssid_len; i += 2) {
+ sscanf(hex_ssid + i, "%02x", &hex);
+ ssid[ssid_len++] = hex;
+ }
+ } else {
+ ssid = raw_ssid;
+ ssid_len = raw_ssid_len;
+ }
+
+ /*
+ * If we have already added hidden AP to the list,
+ * then do not do it again. This might happen if you have
+ * used or are using multiple wifi cards, so in that case
+ * you might have multiple service files for same AP.
+ */
+ if (is_duplicate(scan_data->ssids, ssid, ssid_len)) {
+ if (hex_ssid)
+ g_free(ssid);
+ return 0;
+ }
+
+ scan_ssid = g_try_new(struct scan_ssid, 1);
+ if (!scan_ssid) {
+ if (hex_ssid)
+ g_free(ssid);
+ return -ENOMEM;
+ }
+
+ memcpy(scan_ssid->ssid, ssid, ssid_len);
+ scan_ssid->ssid_len = ssid_len;
+ scan_data->ssids = g_slist_prepend(scan_data->ssids,
+ scan_ssid);
+
+ scan_data->num_ssids++;
+
+ DBG("SSID %s added to scanned list of %d entries", ssid_name,
+ scan_data->num_ssids);
+
+ if (hex_ssid)
+ g_free(ssid);
+ } else
+ return -EINVAL;
+
+ scan_data->ssids = g_slist_reverse(scan_data->ssids);
+
+ if (!scan_data->freqs) {
+ scan_data->freqs = g_try_malloc0(sizeof(uint16_t));
+ if (!scan_data->freqs) {
+ g_slist_free_full(scan_data->ssids, g_free);
+ return -ENOMEM;
+ }
+
+ scan_data->num_freqs = 1;
+ scan_data->freqs[0] = freq;
+ } else {
+ bool duplicate = false;
+
+ /* Don't add duplicate entries */
+ for (i = 0; i < scan_data->num_freqs; i++) {
+ if (scan_data->freqs[i] == freq) {
+ duplicate = true;
+ break;
+ }
+ }
+
+ if (!duplicate) {
+ scan_data->num_freqs++;
+ scan_data->freqs = g_try_realloc(scan_data->freqs,
+ sizeof(uint16_t) * scan_data->num_freqs);
+ if (!scan_data->freqs) {
+ g_slist_free_full(scan_data->ssids, g_free);
+ return -ENOMEM;
+ }
+ scan_data->freqs[scan_data->num_freqs - 1] = freq;
+ }
+ }
+
+ return 1;
+}
+
+static int get_hidden_connections(GSupplicantScanParams *scan_data)
+{
+ struct connman_config_entry **entries;
+ GKeyFile *keyfile;
+ gchar **services;
+ char *ssid, *name;
+ int i, ret;
+ bool value;
+ int num_ssids = 0, add_param_failed = 0;
+
+ services = connman_storage_get_services();
+ for (i = 0; services && services[i]; i++) {
+ if (strncmp(services[i], "wifi_", 5) != 0)
+ continue;
+
+ keyfile = connman_storage_load_service(services[i]);
+ if (!keyfile)
+ continue;
+
+ value = g_key_file_get_boolean(keyfile,
+ services[i], "Hidden", NULL);
+ if (!value) {
+ g_key_file_free(keyfile);
+ continue;
+ }
+
+ value = g_key_file_get_boolean(keyfile,
+ services[i], "Favorite", NULL);
+ if (!value) {
+ g_key_file_free(keyfile);
+ continue;
+ }
+
+ ssid = g_key_file_get_string(keyfile,
+ services[i], "SSID", NULL);
+
+ name = g_key_file_get_string(keyfile, services[i], "Name",
+ NULL);
+
+ ret = add_scan_param(ssid, NULL, 0, 0, scan_data, 0, name);
+ if (ret < 0)
+ add_param_failed++;
+ else if (ret > 0)
+ num_ssids++;
+
+ g_free(ssid);
+ g_free(name);
+ g_key_file_free(keyfile);
+ }
+
+ /*
+ * Check if there are any hidden AP that needs to be provisioned.
+ */
+ entries = connman_config_get_entries("wifi");
+ for (i = 0; entries && entries[i]; i++) {
+ int len;
+
+ if (!entries[i]->hidden)
+ continue;
+
+ if (!entries[i]->ssid) {
+ ssid = entries[i]->name;
+ len = strlen(ssid);
+ } else {
+ ssid = entries[i]->ssid;
+ len = entries[i]->ssid_len;
+ }
+
+ if (!ssid)
+ continue;
+
+ ret = add_scan_param(NULL, ssid, len, 0, scan_data, 0, ssid);
+ if (ret < 0)
+ add_param_failed++;
+ else if (ret > 0)
+ num_ssids++;
+ }
+
+ connman_config_free_entries(entries);
+
+ if (add_param_failed > 0)
+ DBG("Unable to scan %d out of %d SSIDs",
+ add_param_failed, num_ssids);
+
+ g_strfreev(services);
+
+ return num_ssids;
+}
+
+static int get_hidden_connections_params(struct wifi_data *wifi,
+ GSupplicantScanParams *scan_params)
+{
+ int driver_max_ssids, i;
+ GSupplicantScanParams *orig_params;
+
+ /*
+ * Scan hidden networks so that we can autoconnect to them.
+ * We will assume 1 as a default number of ssid to scan.
+ */
+ driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
+ wifi->interface);
+ if (driver_max_ssids == 0)
+ driver_max_ssids = 1;
+
+ DBG("max ssids %d", driver_max_ssids);
+
+ if (!wifi->scan_params) {
+ wifi->scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
+ if (!wifi->scan_params)
+ return 0;
+
+ if (get_hidden_connections(wifi->scan_params) == 0) {
+ g_supplicant_free_scan_params(wifi->scan_params);
+ wifi->scan_params = NULL;
+
+ return 0;
+ }
+ }
+
+ orig_params = wifi->scan_params;
+
+ /* Let's transfer driver_max_ssids params */
+ for (i = 0; i < driver_max_ssids; i++) {
+ struct scan_ssid *ssid;
+
+ if (!wifi->scan_params->ssids)
+ break;
+
+ ssid = orig_params->ssids->data;
+ orig_params->ssids = g_slist_remove(orig_params->ssids, ssid);
+ scan_params->ssids = g_slist_prepend(scan_params->ssids, ssid);
+ }
+
+ if (i > 0) {
+ scan_params->num_ssids = i;
+ scan_params->ssids = g_slist_reverse(scan_params->ssids);
+
+ scan_params->freqs = g_memdup(orig_params->freqs,
+ sizeof(uint16_t) * orig_params->num_freqs);
+ if (!scan_params->freqs)
+ goto err;
+
+ scan_params->num_freqs = orig_params->num_freqs;
+
+ } else
+ goto err;
+
+ orig_params->num_ssids -= scan_params->num_ssids;
+
+ return scan_params->num_ssids;
+
+err:
+ g_slist_free_full(scan_params->ssids, g_free);
+ g_supplicant_free_scan_params(wifi->scan_params);
+ wifi->scan_params = NULL;
+
+ return 0;
+}
+
+static int throw_wifi_scan(struct connman_device *device,
+ GSupplicantInterfaceCallback callback)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ int ret;
+
+ if (wifi_link_removed(wifi))
+ return -ENODEV;
+
+ DBG("device %p %p %p", device, wifi->interface, wifi);
+
+ if (wifi->tethering)
+ return -EBUSY;
+
+ if (connman_device_get_scanning(device))
+ return -EALREADY;
+
+ connman_device_ref(device);
+ wifi_data_ref(wifi);
+
+ ret = g_supplicant_interface_scan(wifi->interface, NULL,
+ callback, device);
+ if (ret == 0) {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, true);
+ } else {
+ wifi_data_unref(wifi);
+ connman_device_unref(device);
+ }
+
+ return ret;
+}
+
+static void hidden_free(struct hidden_params *hidden)
+{
+ if (!hidden)
+ return;
+
+ if (hidden->scan_params)
+ g_supplicant_free_scan_params(hidden->scan_params);
+ g_free(hidden->identity);
+ g_free(hidden->passphrase);
+ g_free(hidden->security);
+ g_free(hidden);
+}
+
+static void scan_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+ bool scanning;
+
+ DBG("result %d wifi %p", result, wifi);
+
+ if (wifi_link_removed(wifi))
+ goto done;
+
+ if (wifi->hidden && !wifi->postpone_hidden) {
+ connman_network_clear_hidden(wifi->hidden->user_data);
+ hidden_free(wifi->hidden);
+ wifi->hidden = NULL;
+ }
+
+ if (wifi->scan_params) {
+ g_supplicant_free_scan_params(wifi->scan_params);
+ wifi->scan_params = NULL;
+ }
+
+ if (result < 0)
+ connman_device_reset_scanning(device);
+
+ /* User is connecting to a hidden AP, let's wait for finished event */
+ if (wifi->hidden && wifi->postpone_hidden) {
+ GSupplicantScanParams *scan_params;
+ int ret;
+
+ wifi->postpone_hidden = false;
+ scan_params = wifi->hidden->scan_params;
+ wifi->hidden->scan_params = NULL;
+
+ reset_autoscan(device);
+
+ /* No addref on wifi_data, scan_callback already has one */
+ ret = g_supplicant_interface_scan(wifi->interface, scan_params,
+ scan_callback, device);
+ if (ret == 0)
+ return;
+
+ /* On error, let's recall scan_callback, which will cleanup */
+ return scan_callback(ret, interface, user_data);
+ }
+
+ /* Remove ref added in wifi_scan() */
+ if (wifi->scanning) {
+ wifi->scanning = false;
+ wifi_data_unref(wifi);
+ }
+
+done:
+ connman_service_force_notify();
+
+ scanning = connman_device_get_scanning(device);
+
+ if (scanning) {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, false);
+ }
+
+ if (result != -ENOLINK)
+ start_autoscan(device);
+
+ /*
+ * If we are here then we were scanning; however, if we are
+ * also mid-flight disabling the interface, then wifi_disable
+ * has already cleared the device scanning state and
+ * unreferenced the device, obviating the need to do it here.
+ */
+
+ if (scanning)
+ connman_device_unref(device);
+}
+
+static void scan_callback_hidden(int result,
+ GSupplicantInterface *interface, void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+ GSupplicantScanParams *scan_params;
+ int ret;
+
+ DBG("result %d wifi %p", result, wifi);
+
+ if (wifi_link_removed(wifi))
+ goto out;
+
+ /* User is trying to connect to a hidden AP */
+ if (wifi->hidden && wifi->postpone_hidden)
+ goto out;
+
+ scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
+ if (!scan_params)
+ goto out;
+
+ if (get_hidden_connections_params(wifi, scan_params) > 0) {
+ /* No addref on wifi_data, scan_callback_hidden already has one */
+ ret = g_supplicant_interface_scan(wifi->interface,
+ scan_params,
+ scan_callback_hidden,
+ device);
+ if (ret == 0)
+ return;
+ }
+
+ g_supplicant_free_scan_params(scan_params);
+
+out:
+ /* wifi_data struct unref'd in scan_callback */
+ scan_callback(result, interface, user_data);
+}
+
+static gboolean autoscan_timeout(gpointer data)
+{
+ struct connman_device *device = data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+ struct autoscan_params *autoscan;
+ int interval;
+
+ if (wifi_link_removed(wifi))
+ return FALSE;
+
+ autoscan = wifi->autoscan;
+
+ if (autoscan->interval <= 0) {
+ interval = autoscan->base;
+ goto set_interval;
+ } else
+ interval = autoscan->interval * autoscan->base;
+
+ if (interval > autoscan->limit)
+ interval = autoscan->limit;
+
+ throw_wifi_scan(wifi->device, scan_callback_hidden);
+
+set_interval:
+ DBG("interval %d", interval);
+
+ autoscan->interval = interval;
+
+ autoscan->timeout = g_timeout_add_seconds(interval,
+ autoscan_timeout, device);
+
+ return FALSE;
+}
+
+static void start_autoscan(struct connman_device *device)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ struct autoscan_params *autoscan;
+
+ DBG("");
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ if (wifi->p2p_device)
+ return;
+
+ if (wifi->connected)
+ return;
+
+ autoscan = wifi->autoscan;
+ if (!autoscan)
+ return;
+
+ if (autoscan->timeout > 0 || autoscan->interval > 0)
+ return;
+
+ connman_device_ref(device);
+
+ autoscan_timeout(device);
+}
+
+static struct autoscan_params *parse_autoscan_params(const char *params)
+{
+ struct autoscan_params *autoscan;
+ char **list_params;
+ int limit;
+ int base;
+
+ DBG("Emulating autoscan");
+
+ list_params = g_strsplit(params, ":", 0);
+ if (list_params == 0)
+ return NULL;
+
+ if (g_strv_length(list_params) < 3) {
+ g_strfreev(list_params);
+ return NULL;
+ }
+
+ base = atoi(list_params[1]);
+ limit = atoi(list_params[2]);
+
+ g_strfreev(list_params);
+
+ autoscan = g_try_malloc0(sizeof(struct autoscan_params));
+ if (!autoscan) {
+ DBG("Could not allocate memory for autoscan");
+ return NULL;
+ }
+
+ DBG("base %d - limit %d", base, limit);
+ autoscan->base = base;
+ autoscan->limit = limit;
+
+ return autoscan;
+}
+
+static void setup_autoscan(struct wifi_data *wifi)
+{
+ if (!wifi->autoscan)
+ wifi->autoscan = parse_autoscan_params(AUTOSCAN_DEFAULT);
+
+ start_autoscan(wifi->device);
+}
+
+static void finalize_interface_creation(struct wifi_data *wifi)
+{
+ DBG("interface is ready wifi %p tethering %d", wifi, wifi->tethering);
+
+ if (!wifi->device) {
+ connman_error("WiFi device not set");
+ return;
+ }
+
+ connman_device_set_powered(wifi->device, true);
+
+ if (!connman_setting_get_bool("BackgroundScanning"))
+ return;
+
+ if (wifi->p2p_device)
+ return;
+
+ setup_autoscan(wifi);
+}
+
+static void interface_create_callback(int result,
+ GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct wifi_data *wifi = user_data;
+
+ DBG("result %d ifname %s, wifi %p", result,
+ g_supplicant_interface_get_ifname(interface),
+ wifi);
+
+ if (result < 0 || wifi_link_removed(wifi))
+ goto done;
+
+ wifi->interface = interface;
+ g_supplicant_interface_set_data(interface, wifi);
+
+ if (g_supplicant_interface_get_ready(interface)) {
+ wifi->interface_ready = true;
+ finalize_interface_creation(wifi);
+ wifi = NULL;
+ }
+
+done:
+ if (wifi != NULL) {
+ /* Remove ref added in wifi_enable */
+ wifi_data_unref(wifi);
+ }
+}
+
+static int wifi_enable(struct connman_device *device)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ int index;
+ char *interface;
+ const char *driver = connman_option_get_string("wifi");
+ int ret;
+
+ DBG("device %p %p", device, wifi);
+
+ index = connman_device_get_index(device);
+ DBG("index %d p2p %d", index, is_p2p_connecting());
+ if (!wifi || index < 0)
+ return -ENODEV;
+
+ if (is_p2p_connecting())
+ return -EINPROGRESS;
+ interface = connman_inet_ifname(index);
+
+ ret = g_supplicant_interface_create(interface, driver, NULL,
+ interface_create_callback,
+ wifi);
+ g_free(interface);
+ if (ret < 0)
+ return ret;
+
+ return -EINPROGRESS;
+}
+
+static int wifi_disable(struct connman_device *device)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ int ret;
+
+ DBG("device %p wifi %p", device, wifi);
+
+ if (wifi_link_removed(wifi))
+ return -ENODEV;
+
+ wifi->connected = false;
+ wifi->disconnecting = false;
+
+ if (wifi->pending_network)
+ wifi->pending_network = NULL;
+
+ stop_autoscan(device);
+
+ if (wifi->p2p_find_timeout) {
+ g_source_remove(wifi->p2p_find_timeout);
+ wifi->p2p_find_timeout = 0;
+ connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
+ connman_device_unref(wifi->device);
+ }
+
+ /* In case of a user scan, device is still referenced */
+ if (connman_device_get_scanning(device)) {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, false);
+ connman_device_unref(wifi->device);
+ }
+
+ remove_networks(device, wifi);
+
+ ret = g_supplicant_interface_remove(wifi->interface, NULL, NULL);
+ if (ret < 0)
+ return ret;
+
+ return -EINPROGRESS;
+}
+
+struct last_connected {
+ GTimeVal modified;
+ gchar *ssid;
+ int freq;
+};
+
+static gint sort_entry(gconstpointer a, gconstpointer b, gpointer user_data)
+{
+ GTimeVal *aval = (GTimeVal *)a;
+ GTimeVal *bval = (GTimeVal *)b;
+
+ /* Note that the sort order is descending */
+ if (aval->tv_sec < bval->tv_sec)
+ return 1;
+
+ if (aval->tv_sec > bval->tv_sec)
+ return -1;
+
+ return 0;
+}
+
+static void free_entry(gpointer data)
+{
+ struct last_connected *entry = data;
+
+ g_free(entry->ssid);
+ g_free(entry);
+}
+
+static int get_latest_connections(int max_ssids,
+ GSupplicantScanParams *scan_data)
+{
+ GSequenceIter *iter;
+ GSequence *latest_list;
+ struct last_connected *entry;
+ GKeyFile *keyfile;
+ GTimeVal modified;
+ gchar **services;
+ gchar *str;
+ char *ssid;
+ int i, freq;
+ int num_ssids = 0;
+
+ latest_list = g_sequence_new(free_entry);
+ if (!latest_list)
+ return -ENOMEM;
+
+ services = connman_storage_get_services();
+ for (i = 0; services && services[i]; i++) {
+ if (strncmp(services[i], "wifi_", 5) != 0)
+ continue;
+
+ keyfile = connman_storage_load_service(services[i]);
+ if (!keyfile)
+ continue;
+
+ str = g_key_file_get_string(keyfile,
+ services[i], "Favorite", NULL);
+ if (!str || g_strcmp0(str, "true")) {
+ g_free(str);
+ g_key_file_free(keyfile);
+ continue;
+ }
+ g_free(str);
+
+ str = g_key_file_get_string(keyfile,
+ services[i], "AutoConnect", NULL);
+ if (!str || g_strcmp0(str, "true")) {
+ g_free(str);
+ g_key_file_free(keyfile);
+ continue;
+ }
+ g_free(str);
+
+ str = g_key_file_get_string(keyfile,
+ services[i], "Modified", NULL);
+ if (!str) {
+ g_key_file_free(keyfile);
+ continue;
+ }
+ g_time_val_from_iso8601(str, &modified);
+ g_free(str);
+
+ ssid = g_key_file_get_string(keyfile,
+ services[i], "SSID", NULL);
+
+ freq = g_key_file_get_integer(keyfile, services[i],
+ "Frequency", NULL);
+ if (freq) {
+ entry = g_try_new(struct last_connected, 1);
+ if (!entry) {
+ g_sequence_free(latest_list);
+ g_key_file_free(keyfile);
+ g_free(ssid);
+ return -ENOMEM;
+ }
+
+ entry->ssid = ssid;
+ entry->modified = modified;
+ entry->freq = freq;
+
+ g_sequence_insert_sorted(latest_list, entry,
+ sort_entry, NULL);
+ num_ssids++;
+ } else
+ g_free(ssid);
+
+ g_key_file_free(keyfile);
+ }
+
+ g_strfreev(services);
+
+ num_ssids = num_ssids > max_ssids ? max_ssids : num_ssids;
+
+ iter = g_sequence_get_begin_iter(latest_list);
+
+ for (i = 0; i < num_ssids; i++) {
+ entry = g_sequence_get(iter);
+
+ DBG("ssid %s freq %d modified %lu", entry->ssid, entry->freq,
+ entry->modified.tv_sec);
+
+ add_scan_param(entry->ssid, NULL, 0, entry->freq, scan_data,
+ max_ssids, entry->ssid);
+
+ iter = g_sequence_iter_next(iter);
+ }
+
+ g_sequence_free(latest_list);
+ return num_ssids;
+}
+
+static int wifi_scan_simple(struct connman_device *device)
+{
+ reset_autoscan(device);
+
+ return throw_wifi_scan(device, scan_callback_hidden);
+}
+
+static gboolean p2p_find_stop(gpointer data)
+{
+ struct connman_device *device = data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+
+ DBG("");
+
+ wifi->p2p_find_timeout = 0;
+
+ connman_device_set_scanning(device, CONNMAN_SERVICE_TYPE_P2P, false);
+
+ g_supplicant_interface_p2p_stop_find(wifi->interface);
+
+ connman_device_unref(device);
+ reset_autoscan(device);
+
+ return FALSE;
+}
+
+static void p2p_find_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+
+ if (wifi_link_removed(wifi))
+ goto done;
+
+ DBG("result %d wifi %p", result, wifi);
+
+ if (wifi->p2p_find_timeout) {
+ g_source_remove(wifi->p2p_find_timeout);
+ wifi->p2p_find_timeout = 0;
+ }
+
+ if (result)
+ goto error;
+
+ wifi->p2p_find_timeout = g_timeout_add_seconds(P2P_FIND_TIMEOUT,
+ p2p_find_stop, device);
+ if (!wifi->p2p_find_timeout)
+ goto error;
+done:
+ /* Remove ref added before call to g_supplicant_interface_p2p_find */
+ wifi_data_unref(wifi);
+
+ return;
+
+error:
+ /* Remove ref added before call to g_supplicant_interface_p2p_find */
+ wifi_data_unref(wifi);
+
+ p2p_find_stop(device);
+}
+
+static int p2p_find(struct connman_device *device)
+{
+ struct wifi_data *wifi;
+ int ret;
+
+ DBG("");
+
+ if (!p2p_technology)
+ return -ENOTSUP;
+
+ wifi = connman_device_get_data(device);
+
+ if (g_supplicant_interface_is_p2p_finding(wifi->interface))
+ return -EALREADY;
+
+ reset_autoscan(device);
+ connman_device_ref(device);
+
+ /* Add ref for duration of GSupplicant DBus call(s) */
+ wifi_data_ref(wifi);
+
+ ret = g_supplicant_interface_p2p_find(wifi->interface,
+ p2p_find_callback, device);
+ if (ret) {
+ /* Remove ref if GSupplicant call fails */
+ wifi_data_unref(wifi);
+
+ connman_device_unref(device);
+ start_autoscan(device);
+ } else {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_P2P, true);
+ }
+
+ return ret;
+}
+
+/*
+ * Note that the hidden scan is only used when connecting to this specific
+ * hidden AP first time. It is not used when system autoconnects to hidden AP.
+ */
+static int wifi_scan(enum connman_service_type type,
+ struct connman_device *device,
+ const char *ssid, unsigned int ssid_len,
+ const char *identity, const char* passphrase,
+ const char *security, void *user_data)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ GSupplicantScanParams *scan_params = NULL;
+ struct scan_ssid *scan_ssid;
+ struct hidden_params *hidden;
+ int ret;
+ int driver_max_ssids = 0;
+ bool do_hidden;
+ bool scanning;
+
+ if (wifi_link_removed(wifi))
+ return -ENODEV;
+
+ if (wifi->p2p_device)
+ return 0;
+
+ if (type == CONNMAN_SERVICE_TYPE_P2P)
+ return p2p_find(device);
+
+ DBG("device %p wifi interface %p hidden ssid %s wifi %p", device, wifi->interface, ssid, wifi);
+
+ if (wifi->tethering)
+ return 0;
+
+ scanning = connman_device_get_scanning(device);
+
+ if (!ssid || ssid_len == 0 || ssid_len > 32) {
+ if (scanning)
+ return -EALREADY;
+
+ driver_max_ssids = g_supplicant_interface_get_max_scan_ssids(
+ wifi->interface);
+ DBG("max ssids %d", driver_max_ssids);
+ if (driver_max_ssids == 0)
+ return wifi_scan_simple(device);
+
+ do_hidden = false;
+ } else {
+ if (scanning && wifi->hidden && wifi->postpone_hidden)
+ return -EALREADY;
+
+ do_hidden = true;
+ }
+
+ scan_params = g_try_malloc0(sizeof(GSupplicantScanParams));
+ if (!scan_params)
+ return -ENOMEM;
+
+ if (do_hidden) {
+ scan_ssid = g_try_new(struct scan_ssid, 1);
+ if (!scan_ssid) {
+ g_free(scan_params);
+ return -ENOMEM;
+ }
+
+ memcpy(scan_ssid->ssid, ssid, ssid_len);
+ scan_ssid->ssid_len = ssid_len;
+ scan_params->ssids = g_slist_prepend(scan_params->ssids,
+ scan_ssid);
+ scan_params->num_ssids = 1;
+
+ hidden = g_try_new0(struct hidden_params, 1);
+ if (!hidden) {
+ g_supplicant_free_scan_params(scan_params);
+ return -ENOMEM;
+ }
+
+ if (wifi->hidden) {
+ hidden_free(wifi->hidden);
+ wifi->hidden = NULL;
+ }
+
+ memcpy(hidden->ssid, ssid, ssid_len);
+ hidden->ssid_len = ssid_len;
+ hidden->identity = g_strdup(identity);
+ hidden->passphrase = g_strdup(passphrase);
+ hidden->security = g_strdup(security);
+ hidden->user_data = user_data;
+ wifi->hidden = hidden;
+
+ if (scanning) {
+ /* Let's keep this active scan for later,
+ * when current scan will be over. */
+ wifi->postpone_hidden = TRUE;
+ hidden->scan_params = scan_params;
+
+ return 0;
+ }
+ } else if (wifi->connected) {
+ g_supplicant_free_scan_params(scan_params);
+ return wifi_scan_simple(device);
+ } else {
+ ret = get_latest_connections(driver_max_ssids, scan_params);
+ if (ret <= 0) {
+ g_supplicant_free_scan_params(scan_params);
+ return wifi_scan_simple(device);
+ }
+ }
+
+ connman_device_ref(device);
+
+ reset_autoscan(device);
+
+ /* Add ref to duration of GSupplicant's DBus call(s) */
+ wifi_data_ref(wifi);
+ wifi->scanning = true;
+
+ ret = g_supplicant_interface_scan(wifi->interface, scan_params,
+ scan_callback, device);
+ if (ret == 0) {
+ connman_device_set_scanning(device,
+ CONNMAN_SERVICE_TYPE_WIFI, true);
+ } else {
+ wifi_data_unref(wifi);
+ wifi->scanning = false;
+ g_supplicant_free_scan_params(scan_params);
+ connman_device_unref(device);
+
+ if (do_hidden) {
+ hidden_free(wifi->hidden);
+ wifi->hidden = NULL;
+ }
+ }
+
+ return ret;
+}
+
+static void wifi_regdom_callback(int result,
+ const char *alpha2,
+ void *user_data)
+{
+ struct connman_device *device = user_data;
+ struct wifi_data *wifi = connman_device_get_data(device);
+
+ if (wifi_link_removed(wifi))
+ goto done;
+
+ connman_device_regdom_notify(device, result, alpha2);
+
+done:
+ wifi_data_unref(wifi);
+ connman_device_unref(device);
+}
+
+static int wifi_set_regdom(struct connman_device *device, const char *alpha2)
+{
+ struct wifi_data *wifi = connman_device_get_data(device);
+ int ret;
+
+ if (wifi_link_removed(wifi))
+ return -ENODEV;
+
+ connman_device_ref(device);
+ wifi_data_ref(wifi);
+
+ ret = g_supplicant_interface_set_country(wifi->interface,
+ wifi_regdom_callback,
+ alpha2, device);
+ if (ret != 0) {
+ wifi_data_unref(wifi);
+ connman_device_unref(device);
+ }
+
+ return ret;
+}
+
+static struct connman_device_driver wifi_ng_driver = {
+ .name = "wifi",
+ .type = CONNMAN_DEVICE_TYPE_WIFI,
+ .priority = CONNMAN_DEVICE_PRIORITY_LOW,
+ .probe = wifi_probe,
+ .remove = wifi_remove,
+ .enable = wifi_enable,
+ .disable = wifi_disable,
+ .scan = wifi_scan,
+ .set_regdom = wifi_set_regdom,
+};
+
+static void system_ready(void)
+{
+ DBG("");
+
+ if (connman_device_driver_register(&wifi_ng_driver) < 0)
+ connman_error("Failed to register WiFi driver");
+}
+
+static void system_killed(void)
+{
+ DBG("");
+
+ connman_device_driver_unregister(&wifi_ng_driver);
+}
+
+static int network_probe(struct connman_network *network)
+{
+ DBG("network %p", network);
+
+ return 0;
+}
+
+static void network_remove(struct connman_network *network)
+{
+ struct connman_device *device = connman_network_get_device(network);
+ struct wifi_data *wifi;
+
+ DBG("network %p", network);
+
+ wifi = connman_device_get_data(device);
+ if (wifi_link_removed(wifi))
+ return;
+
+ if (wifi->network != network)
+ return;
+
+ wifi->network = NULL;
+}
+
+static void connect_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct connman_network *network = user_data;
+
+ DBG("network %p result %d", network, result);
+
+ if (result == -ENOKEY) {
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_INVALID_KEY);
+ } else if (result < 0) {
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
+ }
+
+ connman_network_unref(network);
+}
+
+static GSupplicantSecurity network_security(const char *security)
+{
+ if (g_str_equal(security, "none"))
+ return G_SUPPLICANT_SECURITY_NONE;
+ else if (g_str_equal(security, "wep"))
+ return G_SUPPLICANT_SECURITY_WEP;
+ else if (g_str_equal(security, "psk"))
+ return G_SUPPLICANT_SECURITY_PSK;
+ else if (g_str_equal(security, "wpa"))
+ return G_SUPPLICANT_SECURITY_PSK;
+ else if (g_str_equal(security, "rsn"))
+ return G_SUPPLICANT_SECURITY_PSK;
+ else if (g_str_equal(security, "ieee8021x"))
+ return G_SUPPLICANT_SECURITY_IEEE8021X;
+
+ return G_SUPPLICANT_SECURITY_UNKNOWN;
+}
+
+static void ssid_init(GSupplicantSSID *ssid, struct connman_network *network)
+{
+ const char *security;
+
+ memset(ssid, 0, sizeof(*ssid));
+ ssid->mode = G_SUPPLICANT_MODE_INFRA;
+ ssid->ssid = connman_network_get_blob(network, "WiFi.SSID",
+ &ssid->ssid_len);
+ ssid->scan_ssid = 1;
+ security = connman_network_get_string(network, "WiFi.Security");
+ ssid->security = network_security(security);
+ ssid->passphrase = connman_network_get_string(network,
+ "WiFi.Passphrase");
+
+ ssid->eap = connman_network_get_string(network, "WiFi.EAP");
+
+ /*
+ * If our private key password is unset,
+ * we use the supplied passphrase. That is needed
+ * for PEAP where 2 passphrases (identity and client
+ * cert may have to be provided.
+ */
+ if (!connman_network_get_string(network, "WiFi.PrivateKeyPassphrase"))
+ connman_network_set_string(network,
+ "WiFi.PrivateKeyPassphrase",
+ ssid->passphrase);
+ /* We must have an identity for both PEAP and TLS */
+ ssid->identity = connman_network_get_string(network, "WiFi.Identity");
+
+ /* Use agent provided identity as a fallback */
+ if (!ssid->identity || strlen(ssid->identity) == 0)
+ ssid->identity = connman_network_get_string(network,
+ "WiFi.AgentIdentity");
+
+ ssid->ca_cert_path = connman_network_get_string(network,
+ "WiFi.CACertFile");
+ ssid->client_cert_path = connman_network_get_string(network,
+ "WiFi.ClientCertFile");
+ ssid->private_key_path = connman_network_get_string(network,
+ "WiFi.PrivateKeyFile");
+ ssid->private_key_passphrase = connman_network_get_string(network,
+ "WiFi.PrivateKeyPassphrase");
+ ssid->phase2_auth = connman_network_get_string(network, "WiFi.Phase2");
+
+ ssid->use_wps = connman_network_get_bool(network, "WiFi.UseWPS");
+ ssid->pin_wps = connman_network_get_string(network, "WiFi.PinWPS");
+
+ if (connman_setting_get_bool("BackgroundScanning"))
+ ssid->bgscan = BGSCAN_DEFAULT;
+}
+
+static int network_connect(struct connman_network *network)
+{
+ struct connman_device *device = connman_network_get_device(network);
+ struct wifi_data *wifi;
+ GSupplicantInterface *interface;
+ GSupplicantSSID *ssid;
+ int ret;
+
+ DBG("network %p", network);
+
+ if (!device)
+ return -ENODEV;
+
+ wifi = connman_device_get_data(device);
+ if (wifi_link_removed(wifi))
+ return -ENODEV;
+
+ ssid = g_try_malloc0(sizeof(GSupplicantSSID));
+ if (!ssid)
+ return -ENOMEM;
+
+ interface = wifi->interface;
+
+ ssid_init(ssid, network);
+
+ if (wifi->disconnecting) {
+ wifi->pending_network = network;
+ g_free(ssid);
+ } else {
+ /*
+ * This is the network that is about to get added to wpa_s
+ * Before this network gets added mark the previous network
+ * (which is maintained in wifi->network) as not connectable
+ * and the current one as connectable. This flag will be later
+ * on used to ensure that network that is there in wpa_s never
+ * gets marked unavailable even if scans could not see this
+ * network.
+ */
+ if (wifi->network) {
+ connman_network_set_connectable(wifi->network, false);
+ }
+
+ wifi->network = connman_network_ref(network);
+ connman_network_set_connectable(wifi->network, true);
+ wifi->retries = 0;
+
+ ret = g_supplicant_interface_connect(interface, ssid,
+ connect_callback, network);
+
+ if (ret < 0 && ret != -EINPROGRESS) {
+ connman_network_unref(network);
+ }
+
+ return ret;
+ }
+
+ return -EINPROGRESS;
+}
+
+static void disconnect_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct wifi_data *wifi = user_data;
+
+ DBG("result %d supplicant interface %p wifi %p",
+ result, interface, wifi);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ if (result == -ECONNABORTED) {
+ DBG("wifi interface no longer available");
+ goto done;
+ }
+
+ if (wifi->network) {
+ connman_network_set_connectable(wifi->network, false);
+ /*
+ * if result < 0 supplican return an error because
+ * the network is not current.
+ * we wont receive G_SUPPLICANT_STATE_DISCONNECTED since it
+ * failed, call connman_network_set_connected to report
+ * disconnect is completed.
+ */
+ if (result < 0)
+ connman_network_set_connected(wifi->network, false);
+ }
+
+ wifi->network = NULL;
+
+ wifi->disconnecting = false;
+
+ if (wifi->pending_network) {
+ network_connect(wifi->pending_network);
+ wifi->pending_network = NULL;
+ }
+
+ start_autoscan(wifi->device);
+
+done:
+ wifi_data_unref(wifi);
+}
+
+static int network_disconnect(struct connman_network *network, bool user_initiated)
+{
+ struct connman_device *device = connman_network_get_device(network);
+ struct wifi_data *wifi;
+ int err;
+
+ DBG("network %p", network);
+
+ wifi = connman_device_get_data(device);
+ if (!wifi || !wifi->interface)
+ return -ENODEV;
+
+ connman_network_set_associating(network, false);
+
+ if (wifi->disconnecting)
+ return -EALREADY;
+
+ wifi->disconnecting = true;
+
+ wifi_data_ref(wifi);
+ err = g_supplicant_interface_disconnect(wifi->interface,
+ disconnect_callback, wifi);
+ if (err < 0) {
+ wifi->disconnecting = false;
+ wifi_data_unref(wifi);
+ }
+
+ return err;
+}
+
+static struct connman_network_driver network_driver = {
+ .name = "wifi",
+ .type = CONNMAN_NETWORK_TYPE_WIFI,
+ .priority = CONNMAN_NETWORK_PRIORITY_LOW,
+ .probe = network_probe,
+ .remove = network_remove,
+ .connect = network_connect,
+ .disconnect = network_disconnect,
+};
+
+static void interface_added(GSupplicantInterface *interface)
+{
+ const char *ifname = g_supplicant_interface_get_ifname(interface);
+ const char *driver = g_supplicant_interface_get_driver(interface);
+ struct wifi_data *wifi;
+
+ wifi = g_supplicant_interface_get_data(interface);
+ if (!wifi) {
+ wifi = get_pending_wifi_data(ifname);
+ if (!wifi)
+ return;
+
+ g_supplicant_interface_set_data(interface, wifi);
+ p2p_iface_list = g_list_append(p2p_iface_list, wifi);
+ wifi->p2p_device = true;
+ }
+ /*
+ * We can get here with a NULL wifi pointer when
+ * the interface added signal is sent before the
+ * interface creation callback is called.
+ */
+ if (wifi_link_removed(wifi))
+ return;
+
+ DBG("ifname %s driver %s wifi %p tethering %d",
+ ifname, driver, wifi, wifi->tethering);
+
+ if (!wifi->device) {
+ connman_error("WiFi device not set");
+ return;
+ }
+
+ connman_device_set_powered(wifi->device, true);
+}
+
+static bool is_idle(struct wifi_data *wifi)
+{
+ DBG("state %d", wifi->state);
+
+ switch (wifi->state) {
+ case G_SUPPLICANT_STATE_UNKNOWN:
+ case G_SUPPLICANT_STATE_DISABLED:
+ case G_SUPPLICANT_STATE_DISCONNECTED:
+ case G_SUPPLICANT_STATE_INACTIVE:
+ case G_SUPPLICANT_STATE_SCANNING:
+ return true;
+
+ case G_SUPPLICANT_STATE_AUTHENTICATING:
+ case G_SUPPLICANT_STATE_ASSOCIATING:
+ case G_SUPPLICANT_STATE_ASSOCIATED:
+ case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
+ case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
+ case G_SUPPLICANT_STATE_COMPLETED:
+ return false;
+ }
+
+ return false;
+}
+
+static bool is_idle_wps(GSupplicantInterface *interface,
+ struct wifi_data *wifi)
+{
+ /* First, let's check if WPS processing did not went wrong */
+ if (g_supplicant_interface_get_wps_state(interface) ==
+ G_SUPPLICANT_WPS_STATE_FAIL)
+ return false;
+
+ /* Unlike normal connection, being associated while processing wps
+ * actually means that we are idling. */
+ switch (wifi->state) {
+ case G_SUPPLICANT_STATE_UNKNOWN:
+ case G_SUPPLICANT_STATE_DISABLED:
+ case G_SUPPLICANT_STATE_DISCONNECTED:
+ case G_SUPPLICANT_STATE_INACTIVE:
+ case G_SUPPLICANT_STATE_SCANNING:
+ case G_SUPPLICANT_STATE_ASSOCIATED:
+ return true;
+ case G_SUPPLICANT_STATE_AUTHENTICATING:
+ case G_SUPPLICANT_STATE_ASSOCIATING:
+ case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
+ case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
+ case G_SUPPLICANT_STATE_COMPLETED:
+ return false;
+ }
+
+ return false;
+}
+
+static bool handle_wps_completion(GSupplicantInterface *interface,
+ struct connman_network *network,
+ struct connman_device *device,
+ struct wifi_data *wifi)
+{
+ bool wps;
+
+ wps = connman_network_get_bool(network, "WiFi.UseWPS");
+ if (wps) {
+ const unsigned char *ssid, *wps_ssid;
+ unsigned int ssid_len, wps_ssid_len;
+ const char *wps_key;
+ int ret;
+
+ /* Checking if we got associated with requested
+ * network */
+ ssid = connman_network_get_blob(network, "WiFi.SSID",
+ &ssid_len);
+
+ wps_ssid = g_supplicant_interface_get_wps_ssid(
+ interface, &wps_ssid_len);
+
+ if (!wps_ssid || wps_ssid_len != ssid_len ||
+ memcmp(ssid, wps_ssid, ssid_len) != 0) {
+ connman_network_set_associating(network, false);
+
+ wifi_data_ref(wifi);
+ ret = g_supplicant_interface_disconnect(wifi->interface,
+ disconnect_callback, wifi);
+ if (ret < 0) {
+ wifi_data_unref(wifi);
+ }
+
+ return false;
+ }
+
+ wps_key = g_supplicant_interface_get_wps_key(interface);
+ connman_network_set_string(network, "WiFi.Passphrase",
+ wps_key);
+
+ connman_network_set_string(network, "WiFi.PinWPS", NULL);
+ }
+
+ return true;
+}
+
+static bool handle_assoc_status_code(GSupplicantInterface *interface,
+ struct wifi_data *wifi)
+{
+ if (wifi->state == G_SUPPLICANT_STATE_ASSOCIATING && !wifi->connected &&
+ (wifi->assoc_statuscode == GSUP_80211_ASSOC_STATUS_NO_ADDITIONAL_CLIENT ||
+ wifi->assoc_statuscode == GSUP_80211_ASSOC_STATUS_UNSPECIFIED_FAILURE ||
+ wifi->assoc_statuscode == GSUP_80211_ASSOC_STATUS_REJECTED_TEMPORARILY) &&
+ wifi->wpa_sup_load_shaping_retries < WPA_SUP_LOAD_SHAPING_MAX_RETRIES) {
+ wifi->wpa_sup_load_shaping_retries ++;
+ return TRUE;
+ }
+ wifi->wpa_sup_load_shaping_retries = 0;
+ return FALSE;
+}
+
+static bool handle_4way_handshake_failure(GSupplicantInterface *interface,
+ struct connman_network *network,
+ struct wifi_data *wifi)
+{
+ struct connman_service *service;
+
+ if (wifi->state != G_SUPPLICANT_STATE_4WAY_HANDSHAKE)
+ return false;
+
+ if (wifi->connected)
+ return false;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return false;
+
+ wifi->retries++;
+
+ if (connman_service_get_favorite(service)) {
+ if (wifi->retries < FAVORITE_MAXIMUM_RETRIES)
+ return true;
+ }
+
+ wifi->retries = 0;
+ connman_network_set_error(network, CONNMAN_NETWORK_ERROR_INVALID_KEY);
+
+ return false;
+}
+
+static void interface_state(GSupplicantInterface *interface)
+{
+ struct connman_network *network;
+ struct connman_device *device;
+ struct wifi_data *wifi;
+ GSupplicantState state = g_supplicant_interface_get_state(interface);
+ bool wps;
+ bool old_connected;
+
+ wifi = g_supplicant_interface_get_data(interface);
+
+ DBG("wifi %p interface state %d", wifi, state);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ if (state == G_SUPPLICANT_STATE_COMPLETED) {
+ if (wifi->tethering_param) {
+ g_free(wifi->tethering_param->ssid);
+ g_free(wifi->tethering_param);
+ wifi->tethering_param = NULL;
+ }
+ }
+
+ device = wifi->device;
+ if (!device)
+ return;
+
+ if (g_supplicant_interface_get_ready(interface) &&
+ !wifi->interface_ready) {
+ wifi->interface_ready = true;
+ finalize_interface_creation(wifi);
+ }
+
+ network = wifi->network;
+ if (!network)
+ return;
+
+ switch (state) {
+ case G_SUPPLICANT_STATE_SCANNING:
+ if (wifi->connected)
+ connman_network_set_connected(network, false);
+
+ break;
+
+ case G_SUPPLICANT_STATE_AUTHENTICATING:
+ case G_SUPPLICANT_STATE_ASSOCIATING:
+ stop_autoscan(device);
+
+ if (!wifi->connected)
+ connman_network_set_associating(network, true);
+
+ break;
+
+ case G_SUPPLICANT_STATE_COMPLETED:
+ /* though it should be already stopped: */
+ stop_autoscan(device);
+
+ if (!handle_wps_completion(interface, network, device, wifi))
+ break;
+
+ connman_network_set_connected(network, true);
+
+ wifi->disconnect_reasoncode = 0;
+ wifi->assoc_statuscode = 0;
+ wifi->wpa_sup_load_shaping_retries = 0;
+ break;
+
+ case G_SUPPLICANT_STATE_DISCONNECTED:
+ /*
+ * If we're in one of the idle modes, we have
+ * not started association yet and thus setting
+ * those ones to FALSE could cancel an association
+ * in progress.
+ */
+ wps = connman_network_get_bool(network, "WiFi.UseWPS");
+ if (wps)
+ if (is_idle_wps(interface, wifi))
+ break;
+
+ if (is_idle(wifi))
+ break;
+
+ if (handle_assoc_status_code(interface, wifi))
+ break;
+
+ /* If previous state was 4way-handshake, then
+ * it's either: psk was incorrect and thus we retry
+ * or if we reach the maximum retries we declare the
+ * psk as wrong */
+ if (handle_4way_handshake_failure(interface,
+ network, wifi))
+ break;
+
+ connman_network_set_connected(network, false);
+ connman_network_set_associating(network, false);
+ wifi->disconnecting = false;
+
+ start_autoscan(device);
+
+ break;
+
+ case G_SUPPLICANT_STATE_INACTIVE:
+ connman_network_set_associating(network, false);
+ start_autoscan(device);
+
+ break;
+
+ case G_SUPPLICANT_STATE_UNKNOWN:
+ case G_SUPPLICANT_STATE_DISABLED:
+ case G_SUPPLICANT_STATE_ASSOCIATED:
+ case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
+ case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
+ break;
+ }
+
+ old_connected = wifi->connected;
+ wifi->state = state;
+
+ /* Saving wpa_s state policy:
+ * If connected and if the state changes are roaming related:
+ * --> We stay connected
+ * If completed
+ * --> We are connected
+ * All other case:
+ * --> We are not connected
+ * */
+ switch (state) {
+ case G_SUPPLICANT_STATE_AUTHENTICATING:
+ case G_SUPPLICANT_STATE_ASSOCIATING:
+ case G_SUPPLICANT_STATE_ASSOCIATED:
+ case G_SUPPLICANT_STATE_4WAY_HANDSHAKE:
+ case G_SUPPLICANT_STATE_GROUP_HANDSHAKE:
+ if (wifi->connected)
+ connman_warn("Probably roaming right now!"
+ " Staying connected...");
+ else
+ wifi->connected = false;
+ break;
+ case G_SUPPLICANT_STATE_SCANNING:
+ wifi->connected = false;
+
+ if (old_connected)
+ start_autoscan(device);
+ break;
+ case G_SUPPLICANT_STATE_COMPLETED:
+ wifi->connected = true;
+ break;
+ default:
+ wifi->connected = false;
+ break;
+ }
+
+ DBG("DONE");
+}
+
+static void interface_removed(GSupplicantInterface *interface)
+{
+ const char *ifname = g_supplicant_interface_get_ifname(interface);
+ struct wifi_data *wifi;
+
+ DBG("ifname %s", ifname);
+
+ wifi = g_supplicant_interface_get_data(interface);
+
+ if (wifi)
+ wifi->interface = NULL;
+
+ if (wifi && wifi->tethering)
+ return;
+
+ if (!wifi || !wifi->device) {
+ DBG("wifi interface already removed");
+ return;
+ }
+
+ if (wifi->tethering || wifi->shutting_down)
+ return;
+
+ wifi->interface = NULL;
+ connman_device_set_powered(wifi->device, false);
+
+ check_p2p_technology();
+}
+
+static void set_device_type(const char *type, char dev_type[17])
+{
+ const char *oui = "0050F204";
+ const char *category = "0001";
+ const char *sub_category = "0000";
+
+ if (!g_strcmp0(type, "handset")) {
+ category = "000A";
+ sub_category = "0005";
+ } else if (!g_strcmp0(type, "vm") || !g_strcmp0(type, "container"))
+ sub_category = "0001";
+ else if (!g_strcmp0(type, "server"))
+ sub_category = "0002";
+ else if (!g_strcmp0(type, "laptop"))
+ sub_category = "0005";
+ else if (!g_strcmp0(type, "desktop"))
+ sub_category = "0006";
+ else if (!g_strcmp0(type, "tablet"))
+ sub_category = "0009";
+ else if (!g_strcmp0(type, "watch"))
+ category = "00FF";
+
+ snprintf(dev_type, 17, "%s%s%s", category, oui, sub_category);
+}
+
+static void p2p_support(GSupplicantInterface *interface)
+{
+ char dev_type[17] = {};
+ const char *hostname;
+
+ DBG("");
+
+ if (!g_supplicant_interface_has_p2p(interface))
+ return;
+
+ if (connman_technology_driver_register(&p2p_tech_driver) < 0) {
+ DBG("Could not register P2P technology driver");
+ return;
+ }
+
+ hostname = connman_utsname_get_hostname();
+ if (!hostname)
+ hostname = "ConnMan";
+
+ set_device_type(connman_machine_get_type(), dev_type);
+ g_supplicant_interface_set_p2p_device_config(interface,
+ hostname, dev_type);
+ connman_peer_driver_register(&peer_driver);
+}
+
+static void scan_started(GSupplicantInterface *interface)
+{
+ DBG("");
+}
+
+static void scan_finished(GSupplicantInterface *interface)
+{
+ DBG("");
+}
+
+static void ap_create_fail(GSupplicantInterface *interface)
+{
+ struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
+ int ret;
+
+ if ((wifi->tethering) && (wifi->tethering_param)) {
+ DBG("%s create AP fail \n",
+ g_supplicant_interface_get_ifname(wifi->interface));
+
+ connman_inet_remove_from_bridge(wifi->index, wifi->bridge);
+ wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
+ wifi->tethering = false;
+
+ ret = tech_set_tethering(wifi->tethering_param->technology,
+ wifi->tethering_param->ssid->ssid,
+ wifi->tethering_param->ssid->passphrase,
+ wifi->bridge, true);
+
+ if ((ret == -EOPNOTSUPP) && (wifi_technology)) {
+ connman_technology_tethering_notify(wifi_technology,false);
+ }
+
+ g_free(wifi->tethering_param->ssid);
+ g_free(wifi->tethering_param);
+ wifi->tethering_param = NULL;
+ }
+
+ return;
+}
+
+static unsigned char calculate_strength(GSupplicantNetwork *supplicant_network)
+{
+ unsigned char strength;
+
+ strength = 120 + g_supplicant_network_get_signal(supplicant_network);
+ if (strength > 100)
+ strength = 100;
+
+ return strength;
+}
+
+static void network_added(GSupplicantNetwork *supplicant_network)
+{
+ struct connman_network *network;
+ GSupplicantInterface *interface;
+ struct wifi_data *wifi;
+ const char *name, *identifier, *security, *group, *mode;
+ const unsigned char *ssid;
+ unsigned int ssid_len;
+ bool wps;
+ bool wps_pbc;
+ bool wps_ready;
+ bool wps_advertizing;
+
+ mode = g_supplicant_network_get_mode(supplicant_network);
+ identifier = g_supplicant_network_get_identifier(supplicant_network);
+
+ DBG("%s", identifier);
+
+ if (!g_strcmp0(mode, "adhoc"))
+ return;
+
+ interface = g_supplicant_network_get_interface(supplicant_network);
+ wifi = g_supplicant_interface_get_data(interface);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ name = g_supplicant_network_get_name(supplicant_network);
+ security = g_supplicant_network_get_security(supplicant_network);
+ group = g_supplicant_network_get_identifier(supplicant_network);
+ wps = g_supplicant_network_get_wps(supplicant_network);
+ wps_pbc = g_supplicant_network_is_wps_pbc(supplicant_network);
+ wps_ready = g_supplicant_network_is_wps_active(supplicant_network);
+ wps_advertizing = g_supplicant_network_is_wps_advertizing(
+ supplicant_network);
+
+ ssid = g_supplicant_network_get_ssid(supplicant_network, &ssid_len);
+
+ network = connman_device_get_network(wifi->device, identifier);
+
+ if (!network) {
+ network = connman_network_create(identifier,
+ CONNMAN_NETWORK_TYPE_WIFI);
+ if (!network)
+ return;
+
+ connman_network_set_index(network, wifi->index);
+
+ if (connman_device_add_network(wifi->device, network) < 0) {
+ connman_network_unref(network);
+ return;
+ }
+
+ wifi->networks = g_slist_prepend(wifi->networks, network);
+ }
+
+ if (name && name[0] != '\0')
+ connman_network_set_name(network, name);
+
+ connman_network_set_blob(network, "WiFi.SSID",
+ ssid, ssid_len);
+ connman_network_set_string(network, "WiFi.Security", security);
+ connman_network_set_strength(network,
+ calculate_strength(supplicant_network));
+ connman_network_set_bool(network, "WiFi.WPS", wps);
+
+ if (wps) {
+ /* Is AP advertizing for WPS association?
+ * If so, we decide to use WPS by default */
+ if (wps_ready && wps_pbc &&
+ wps_advertizing)
+ connman_network_set_bool(network, "WiFi.UseWPS", true);
+ }
+
+ connman_network_set_frequency(network,
+ g_supplicant_network_get_frequency(supplicant_network));
+
+ connman_network_set_available(network, true);
+ connman_network_set_string(network, "WiFi.Mode", mode);
+
+ if (ssid)
+ connman_network_set_group(network, group);
+
+ if (wifi->hidden && ssid) {
+ if (!g_strcmp0(wifi->hidden->security, security) &&
+ wifi->hidden->ssid_len == ssid_len &&
+ !memcmp(wifi->hidden->ssid, ssid, ssid_len)) {
+ connman_network_connect_hidden(network,
+ wifi->hidden->identity,
+ wifi->hidden->passphrase,
+ wifi->hidden->user_data);
+ wifi->hidden->user_data = NULL;
+ hidden_free(wifi->hidden);
+ wifi->hidden = NULL;
+ }
+ }
+}
+
+static void network_removed(GSupplicantNetwork *network)
+{
+ GSupplicantInterface *interface;
+ struct wifi_data *wifi;
+ const char *name, *identifier;
+ struct connman_network *connman_network;
+
+ interface = g_supplicant_network_get_interface(network);
+ wifi = g_supplicant_interface_get_data(interface);
+ identifier = g_supplicant_network_get_identifier(network);
+ name = g_supplicant_network_get_name(network);
+
+ DBG("name %s", name);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ if (wifi->device == NULL)
+ return;
+
+ connman_network = connman_device_get_network(wifi->device, identifier);
+ if (!connman_network)
+ return;
+
+ /*
+ * wpa_s did not find this network in the last scan it did and
+ * hence this callback. In case if this is the network device
+ * was connected to , wpa_s will keep trying to connect with
+ * this network even though network_removed was called for
+ * this network. Once the network is back, wpa_s will procedd
+ * with this connection and on completion would change the state
+ * (supplicant state) to COMPLETED. Without this check, the network
+ * in connman would be removed and even after the connect complete
+ * connman's service state transition would not happen, leaving
+ * device with a L2 link but no IP address. This check ensures that
+ * if the network removed is the one wpa_s is having in its profile
+ * list, do not remove it as this is device's active profile.
+ */
+ if (wifi->network == connman_network)
+ return;
+
+ wifi->networks = g_slist_remove(wifi->networks, connman_network);
+
+ connman_device_remove_network(wifi->device, connman_network);
+ connman_network_unref(connman_network);
+}
+
+static void network_changed(GSupplicantNetwork *network, const char *property)
+{
+ GSupplicantInterface *interface;
+ struct wifi_data *wifi;
+ const char *name, *identifier;
+ struct connman_network *connman_network;
+
+ interface = g_supplicant_network_get_interface(network);
+ wifi = g_supplicant_interface_get_data(interface);
+ identifier = g_supplicant_network_get_identifier(network);
+ name = g_supplicant_network_get_name(network);
+
+ DBG("name %s", name);
+
+ if (wifi_link_removed(wifi))
+ return;
+
+ if (wifi->device == NULL)
+ return;
+
+ connman_network = connman_device_get_network(wifi->device, identifier);
+ if (!connman_network)
+ return;
+
+ if (g_str_equal(property, "Signal")) {
+ connman_network_set_strength(connman_network,
+ calculate_strength(network));
+ connman_network_update(connman_network);
+ }
+}
+
+static void apply_peer_services(GSupplicantPeer *peer,
+ struct connman_peer *connman_peer)
+{
+ const unsigned char *data;
+ int length;
+
+ DBG("");
+
+ connman_peer_reset_services(connman_peer);
+
+ data = g_supplicant_peer_get_widi_ies(peer, &length);
+ if (data) {
+ connman_peer_add_service(connman_peer,
+ CONNMAN_PEER_SERVICE_WIFI_DISPLAY, data, length);
+ }
+}
+
+static void peer_found(GSupplicantPeer *peer)
+{
+ GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
+ struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
+ struct connman_peer *connman_peer;
+ const char *identifier, *name;
+ int ret;
+
+ identifier = g_supplicant_peer_get_identifier(peer);
+ name = g_supplicant_peer_get_name(peer);
+
+ DBG("ident: %s", identifier);
+
+ connman_peer = connman_peer_get(wifi->device, identifier);
+ if (connman_peer)
+ return;
+
+ connman_peer = connman_peer_create(identifier);
+ connman_peer_set_name(connman_peer, name);
+ connman_peer_set_device(connman_peer, wifi->device);
+ apply_peer_services(peer, connman_peer);
+
+ ret = connman_peer_register(connman_peer);
+ if (ret < 0 && ret != -EALREADY)
+ connman_peer_unref(connman_peer);
+}
+
+static void peer_lost(GSupplicantPeer *peer)
+{
+ GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
+ struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
+ struct connman_peer *connman_peer;
+ const char *identifier;
+
+ if (!wifi)
+ return;
+
+ identifier = g_supplicant_peer_get_identifier(peer);
+
+ DBG("ident: %s", identifier);
+
+ connman_peer = connman_peer_get(wifi->device, identifier);
+ if (connman_peer) {
+ if (wifi->p2p_connecting &&
+ wifi->pending_peer == connman_peer) {
+ peer_connect_timeout(wifi);
+ }
+ connman_peer_unregister(connman_peer);
+ connman_peer_unref(connman_peer);
+ }
+}
+
+static void peer_changed(GSupplicantPeer *peer, GSupplicantPeerState state)
+{
+ GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
+ struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
+ enum connman_peer_state p_state = CONNMAN_PEER_STATE_UNKNOWN;
+ struct connman_peer *connman_peer;
+ const char *identifier;
+
+ identifier = g_supplicant_peer_get_identifier(peer);
+
+ DBG("ident: %s", identifier);
+
+ connman_peer = connman_peer_get(wifi->device, identifier);
+ if (!connman_peer)
+ return;
+
+ switch (state) {
+ case G_SUPPLICANT_PEER_SERVICES_CHANGED:
+ apply_peer_services(peer, connman_peer);
+ connman_peer_services_changed(connman_peer);
+ return;
+ case G_SUPPLICANT_PEER_GROUP_CHANGED:
+ if (!g_supplicant_peer_is_in_a_group(peer))
+ p_state = CONNMAN_PEER_STATE_IDLE;
+ else
+ p_state = CONNMAN_PEER_STATE_CONFIGURATION;
+ break;
+ case G_SUPPLICANT_PEER_GROUP_STARTED:
+ break;
+ case G_SUPPLICANT_PEER_GROUP_FINISHED:
+ p_state = CONNMAN_PEER_STATE_IDLE;
+ break;
+ case G_SUPPLICANT_PEER_GROUP_JOINED:
+ connman_peer_set_iface_address(connman_peer,
+ g_supplicant_peer_get_iface_address(peer));
+ break;
+ case G_SUPPLICANT_PEER_GROUP_DISCONNECTED:
+ p_state = CONNMAN_PEER_STATE_IDLE;
+ break;
+ case G_SUPPLICANT_PEER_GROUP_FAILED:
+ if (g_supplicant_peer_has_requested_connection(peer))
+ p_state = CONNMAN_PEER_STATE_IDLE;
+ else
+ p_state = CONNMAN_PEER_STATE_FAILURE;
+ break;
+ }
+
+ if (p_state == CONNMAN_PEER_STATE_CONFIGURATION ||
+ p_state == CONNMAN_PEER_STATE_FAILURE) {
+ if (wifi->p2p_connecting
+ && connman_peer == wifi->pending_peer)
+ peer_cancel_timeout(wifi);
+ else
+ p_state = CONNMAN_PEER_STATE_UNKNOWN;
+ }
+
+ if (p_state == CONNMAN_PEER_STATE_UNKNOWN)
+ return;
+
+ if (p_state == CONNMAN_PEER_STATE_CONFIGURATION) {
+ GSupplicantInterface *g_iface;
+ struct wifi_data *g_wifi;
+
+ g_iface = g_supplicant_peer_get_group_interface(peer);
+ if (!g_iface)
+ return;
+
+ g_wifi = g_supplicant_interface_get_data(g_iface);
+ if (!g_wifi)
+ return;
+
+ connman_peer_set_as_master(connman_peer,
+ !g_supplicant_peer_is_client(peer));
+ connman_peer_set_sub_device(connman_peer, g_wifi->device);
+ }
+
+ connman_peer_set_state(connman_peer, p_state);
+}
+
+static void peer_request(GSupplicantPeer *peer)
+{
+ GSupplicantInterface *iface = g_supplicant_peer_get_interface(peer);
+ struct wifi_data *wifi = g_supplicant_interface_get_data(iface);
+ struct connman_peer *connman_peer;
+ const char *identifier;
+
+ identifier = g_supplicant_peer_get_identifier(peer);
+
+ DBG("ident: %s", identifier);
+
+ connman_peer = connman_peer_get(wifi->device, identifier);
+ if (!connman_peer)
+ return;
+
+ connman_peer_request_connection(connman_peer);
+}
+
+static void debug(const char *str)
+{
+ if (getenv("CONNMAN_SUPPLICANT_DEBUG"))
+ connman_debug("%s", str);
+}
+
+static void wifi_disconnect_reasoncode(GSupplicantInterface *interface, int reasoncode)
+{
+ struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
+
+ if (wifi != NULL) {
+ wifi->disconnect_reasoncode = reasoncode;
+ }
+}
+
+static void wifi_assoc_status_code(GSupplicantInterface *interface, int status_code)
+{
+ struct wifi_data *wifi = g_supplicant_interface_get_data(interface);
+
+ if (wifi != NULL) {
+ wifi->assoc_statuscode = status_code;
+ }
+}
+
+static const GSupplicantCallbacks callbacks = {
+ .system_ready = system_ready,
+ .system_killed = system_killed,
+ .interface_added = interface_added,
+ .interface_state = interface_state,
+ .interface_removed = interface_removed,
+ .p2p_support = p2p_support,
+ .scan_started = scan_started,
+ .scan_finished = scan_finished,
+ .ap_create_fail = ap_create_fail,
+ .network_added = network_added,
+ .network_removed = network_removed,
+ .network_changed = network_changed,
+ .peer_found = peer_found,
+ .peer_lost = peer_lost,
+ .peer_changed = peer_changed,
+ .peer_request = peer_request,
+ .debug = debug,
+ .update_disconnect_reasoncode = wifi_disconnect_reasoncode,
+ .update_assoc_status_code = wifi_assoc_status_code,
+};
+
+
+static int tech_probe(struct connman_technology *technology)
+{
+ wifi_technology = technology;
+
+ return 0;
+}
+
+static void tech_remove(struct connman_technology *technology)
+{
+ wifi_technology = NULL;
+}
+
+static GSupplicantSSID *ssid_ap_init(const char *ssid, const char *passphrase)
+{
+ GSupplicantSSID *ap;
+
+ ap = g_try_malloc0(sizeof(GSupplicantSSID));
+ if (!ap)
+ return NULL;
+
+ ap->mode = G_SUPPLICANT_MODE_MASTER;
+ ap->ssid = ssid;
+ ap->ssid_len = strlen(ssid);
+ ap->scan_ssid = 0;
+ ap->freq = 2412;
+
+ if (!passphrase || strlen(passphrase) == 0) {
+ ap->security = G_SUPPLICANT_SECURITY_NONE;
+ ap->passphrase = NULL;
+ } else {
+ ap->security = G_SUPPLICANT_SECURITY_PSK;
+ ap->protocol = G_SUPPLICANT_PROTO_RSN;
+ ap->pairwise_cipher = G_SUPPLICANT_PAIRWISE_CCMP;
+ ap->group_cipher = G_SUPPLICANT_GROUP_CCMP;
+ ap->passphrase = passphrase;
+ }
+
+ return ap;
+}
+
+static void ap_start_callback(int result, GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct wifi_tethering_info *info = user_data;
+
+ if (!info->wifi || info->wifi->shutting_down)
+ goto done;
+
+ DBG("result %d index %d bridge %s",
+ result, info->wifi->index, info->wifi->bridge);
+
+ if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
+ connman_inet_remove_from_bridge(info->wifi->index,
+ info->wifi->bridge);
+
+ if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
+ connman_technology_tethering_notify(info->technology, false);
+ g_free(info->wifi->tethering_param->ssid);
+ g_free(info->wifi->tethering_param);
+ info->wifi->tethering_param = NULL;
+ }
+ }
+
+done:
+ wifi_data_unref(info->wifi);
+ g_free(info->ifname);
+ g_free(info);
+}
+
+static void ap_create_callback(int result,
+ GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct wifi_tethering_info *info = user_data;
+
+ DBG("result %d ifname %s", result,
+ g_supplicant_interface_get_ifname(interface));
+
+ if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
+ connman_inet_remove_from_bridge(info->wifi->index,
+ info->wifi->bridge);
+
+ if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
+ connman_technology_tethering_notify(info->technology, false);
+
+ g_free(info->wifi->tethering_param->ssid);
+ g_free(info->wifi->tethering_param);
+ info->wifi->tethering_param = NULL;
+ }
+ g_free(info->ifname);
+ g_free(info->ssid);
+ g_free(info);
+ return;
+ }
+
+ info->wifi->interface = interface;
+ g_supplicant_interface_set_data(interface, info->wifi);
+
+ if (g_supplicant_interface_set_apscan(interface, 2) < 0)
+ connman_error("Failed to set interface ap_scan property");
+
+ g_supplicant_interface_connect(interface, info->ssid,
+ ap_start_callback, info);
+}
+
+static void sta_remove_callback(int result,
+ GSupplicantInterface *interface,
+ void *user_data)
+{
+ struct wifi_tethering_info *info = user_data;
+ const char *driver = connman_option_get_string("wifi");
+
+ DBG("ifname %s result %d ", info->ifname, result);
+
+ if ((result < 0) || (info->wifi->ap_supported != WIFI_AP_SUPPORTED)) {
+ info->wifi->tethering = true;
+
+ g_free(info->ifname);
+ g_free(info->ssid);
+ g_free(info);
+
+ if (info->wifi->ap_supported == WIFI_AP_SUPPORTED) {
+ g_free(info->wifi->tethering_param->ssid);
+ g_free(info->wifi->tethering_param);
+ info->wifi->tethering_param = NULL;
+ }
+ return;
+ }
+
+ info->wifi->interface = NULL;
+
+ connman_technology_tethering_notify(info->technology, true);
+
+ g_supplicant_interface_create(info->ifname, driver,
+ info->wifi->bridge, ap_create_callback, info);
+}
+
+static int tech_set_tethering(struct connman_technology *technology,
+ const char *identifier, const char *passphrase,
+ const char *bridge, bool enabled)
+{
+ GList *list;
+ GSupplicantInterface *interface;
+ struct wifi_data *wifi;
+ struct wifi_tethering_info *info;
+ const char *ifname;
+ unsigned int mode;
+ int err;
+
+ DBG("");
+
+ if (!enabled) {
+ for (list = iface_list; list; list = list->next) {
+ wifi = list->data;
+
+ if (wifi->tethering) {
+ wifi->tethering = false;
+
+ connman_inet_remove_from_bridge(wifi->index,
+ bridge);
+ wifi->bridged = false;
+ }
+ }
+
+ connman_technology_tethering_notify(technology, false);
+
+ return 0;
+ }
+
+ for (list = iface_list; list; list = list->next) {
+ wifi = list->data;
+
+ interface = wifi->interface;
+
+ if (!interface)
+ continue;
+
+ if (wifi->ap_supported == WIFI_AP_NOT_SUPPORTED)
+ continue;
+
+ ifname = g_supplicant_interface_get_ifname(wifi->interface);
+
+ mode = g_supplicant_interface_get_mode(interface);
+ if ((mode & G_SUPPLICANT_CAPABILITY_MODE_AP) == 0) {
+ wifi->ap_supported = WIFI_AP_NOT_SUPPORTED;
+ DBG("%s does not support AP mode", ifname);
+ continue;
+ }
+
+ info = g_try_malloc0(sizeof(struct wifi_tethering_info));
+ if (!info)
+ return -ENOMEM;
+
+ wifi->tethering_param = g_try_malloc0(sizeof(struct wifi_tethering_info));
+ if (!wifi->tethering_param) {
+ g_free(info);
+ return -ENOMEM;
+ }
+
+ info->wifi = wifi;
+ info->technology = technology;
+ info->wifi->bridge = bridge;
+ info->ssid = ssid_ap_init(identifier, passphrase);
+ if (!info->ssid) {
+ g_free(info);
+ g_free(wifi->tethering_param);
+ wifi->tethering_param = NULL;
+ continue;
+ }
+ info->ifname = g_strdup(ifname);
+ if (!info->ifname) {
+ g_free(info->ssid);
+ g_free(wifi->tethering_param);
+ g_free(info);
+ wifi->tethering_param = NULL;
+ continue;
+ }
+
+ wifi->tethering_param->technology = technology;
+ wifi->tethering_param->ssid = ssid_ap_init(identifier, passphrase);
+ if (!wifi->tethering_param->ssid) {
+ g_free(info->ifname);
+ g_free(info->ssid);
+ g_free(wifi->tethering_param);
+ g_free(info);
+ wifi->tethering_param = NULL;
+ continue;
+ }
+
+ info->wifi->tethering = true;
+ info->wifi->ap_supported = WIFI_AP_SUPPORTED;
+
+ /* Add ref for duration of GSupplicant DBus call(s) */
+ wifi_data_ref(info->wifi);
+
+ err = g_supplicant_interface_remove(interface,
+ sta_remove_callback,
+ info);
+ if (err == 0)
+ return err;
+ else
+ wifi_data_unref(info->wifi);
+ }
+
+ return -EOPNOTSUPP;
+}
+
+static void regdom_callback(int result, const char *alpha2, void *user_data)
+{
+ DBG("");
+
+ if (!wifi_technology)
+ return;
+
+ if (result != 0)
+ alpha2 = NULL;
+
+ connman_technology_regdom_notify(wifi_technology, alpha2);
+}
+
+static int tech_set_regdom(struct connman_technology *technology, const char *alpha2)
+{
+ return g_supplicant_set_country(alpha2, regdom_callback, NULL);
+}
+
+static struct connman_technology_driver tech_driver = {
+ .name = "wifi",
+ .type = CONNMAN_SERVICE_TYPE_WIFI,
+ .probe = tech_probe,
+ .remove = tech_remove,
+ .set_tethering = tech_set_tethering,
+ .set_regdom = tech_set_regdom,
+};
+
+static int wifi_init(void)
+{
+ int err;
+
+ err = connman_network_driver_register(&network_driver);
+ if (err < 0)
+ return err;
+
+ err = g_supplicant_register(&callbacks);
+ if (err < 0) {
+ connman_network_driver_unregister(&network_driver);
+ return err;
+ }
+
+ err = connman_technology_driver_register(&tech_driver);
+ if (err < 0) {
+ g_supplicant_unregister(&callbacks);
+ connman_network_driver_unregister(&network_driver);
+ return err;
+ }
+
+ return 0;
+}
+
+static void wifi_exit(void)
+{
+ DBG();
+
+ connman_technology_driver_unregister(&tech_driver);
+
+ g_supplicant_unregister(&callbacks);
+
+ connman_network_driver_unregister(&network_driver);
+}
+
+CONNMAN_PLUGIN_DEFINE(wifi, "WiFi interface plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, wifi_init, wifi_exit)
diff --git a/scripts/connman.in b/scripts/connman.in
new file mode 100644
index 0000000..1692b95
--- /dev/null
+++ b/scripts/connman.in
@@ -0,0 +1,46 @@
+#!/bin/sh
+
+DAEMON=@sbindir@/connmand
+DESC="Connection Manager"
+
+. /lib/lsb/init-functions
+
+if [ -f @sysconfdir@/default/connman ] ; then
+ . @sysconfdir@/default/connman
+fi
+
+set -e
+
+do_start() {
+ start-stop-daemon --start --oknodo --exec $DAEMON -- $DAEMON_OPTS
+}
+
+do_stop() {
+ start-stop-daemon --stop --oknodo --quiet --exec $DAEMON
+}
+
+case "$1" in
+ start)
+ log_daemon_msg "Starting $DESC"
+ do_start
+ log_end_msg $?
+ ;;
+ stop)
+ log_daemon_msg "Stopping $DESC"
+ do_stop
+ log_end_msg $?
+ ;;
+ restart|force-reload)
+ log_daemon_msg "Restarting $DESC"
+ do_stop
+ sleep 1
+ do_start
+ log_end_msg $?
+ ;;
+ *)
+ log_success_msg "Usage: $0 {start|stop|restart|force-reload}" >&2
+ exit 1
+ ;;
+esac
+
+exit 0
diff --git a/scripts/libppp-plugin.c b/scripts/libppp-plugin.c
new file mode 100644
index 0000000..0dd8b47
--- /dev/null
+++ b/scripts/libppp-plugin.c
@@ -0,0 +1,317 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <pppd/pppd.h>
+#include <pppd/fsm.h>
+#include <pppd/ipcp.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <dbus/dbus.h>
+
+#define INET_ADDRES_LEN (INET_ADDRSTRLEN + 5)
+#define INET_DNS_LEN (2*INET_ADDRSTRLEN + 9)
+
+static char *busname;
+static char *interface;
+static char *path;
+
+static DBusConnection *connection;
+static int prev_phase;
+
+char pppd_version[] = VERSION;
+
+int plugin_init(void);
+
+static void append(DBusMessageIter *dict, const char *key, const char *value)
+{
+ DBusMessageIter entry;
+
+ /* We clean the environment before invoking pppd, but
+ * might as well still filter out the few things that get
+ * added that we're not interested in
+ */
+ if (!strcmp(key, "PWD") || !strcmp(key, "_") ||
+ !strcmp(key, "SHLVL") ||
+ !strcmp(key, "connman_busname") ||
+ !strcmp(key, "connman_network"))
+ return;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &value);
+
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+
+static int ppp_have_secret(void)
+{
+ return 1;
+}
+
+static int ppp_get_secret(char *username, char *password)
+{
+ DBusMessage *msg, *reply;
+ const char *user, *pass;
+ DBusError err;
+
+ if (!username && !password)
+ return -1;
+
+ if (!password)
+ return 1;
+
+ if (!connection)
+ return -1;
+
+ dbus_error_init(&err);
+
+ msg = dbus_message_new_method_call(busname, path, interface, "getsec");
+ if (!msg)
+ return -1;
+
+ dbus_message_append_args(msg, DBUS_TYPE_INVALID, DBUS_TYPE_INVALID);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ msg, -1, &err);
+ if (!reply) {
+ if (dbus_error_is_set(&err))
+ dbus_error_free(&err);
+
+ dbus_message_unref(msg);
+ return -1;
+ }
+
+ dbus_message_unref(msg);
+
+ dbus_error_init(&err);
+
+ if (!dbus_message_get_args(reply, &err, DBUS_TYPE_STRING, &user,
+ DBUS_TYPE_STRING, &pass,
+ DBUS_TYPE_INVALID)) {
+ if (dbus_error_is_set(&err))
+ dbus_error_free(&err);
+
+ dbus_message_unref(reply);
+ return -1;
+ }
+
+ if (username)
+ strcpy(username, user);
+
+ strcpy(password, pass);
+
+ dbus_message_unref(reply);
+
+ return 1;
+}
+
+static void ppp_up(void *data, int arg)
+{
+ char buf[INET_ADDRES_LEN];
+ char dns[INET_DNS_LEN];
+ const char *reason = "connect";
+ bool add_blank = FALSE;
+ DBusMessageIter iter, dict;
+ DBusMessage *msg;
+
+ if (!connection)
+ return;
+
+ if (ipcp_gotoptions[0].ouraddr == 0)
+ return;
+
+ msg = dbus_message_new_method_call(busname, path,
+ interface, "notify");
+ if (!msg)
+ return;
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_STRING, &reason, DBUS_TYPE_INVALID);
+
+ dbus_message_iter_init_append(msg, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ append(&dict, "INTERNAL_IFNAME", ifname);
+
+ inet_ntop(AF_INET, &ipcp_gotoptions[0].ouraddr, buf, INET_ADDRSTRLEN);
+ append(&dict, "INTERNAL_IP4_ADDRESS", buf);
+
+ strcpy(buf, "255.255.255.255");
+ append(&dict, "INTERNAL_IP4_NETMASK", buf);
+
+ if (ipcp_gotoptions[0].dnsaddr[0] || ipcp_gotoptions[0].dnsaddr[1]) {
+ memset(dns, 0, sizeof(dns));
+ dns[0] = '\0';
+
+ if (ipcp_gotoptions[0].dnsaddr[0]) {
+ inet_ntop(AF_INET, &ipcp_gotoptions[0].dnsaddr[0],
+ buf, INET_ADDRSTRLEN);
+ strcat(dns, buf);
+
+ add_blank = TRUE;
+ }
+
+ if (ipcp_gotoptions[0].dnsaddr[1]) {
+ inet_ntop(AF_INET, &ipcp_gotoptions[0].dnsaddr[1],
+ buf, INET_ADDRSTRLEN);
+ if (add_blank)
+ strcat(dns, " ");
+
+ strcat(dns, buf);
+ }
+ append(&dict, "INTERNAL_IP4_DNS", dns);
+ }
+
+ append(&dict, "MTU", "1400");
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ dbus_connection_send(connection, msg, NULL);
+
+ dbus_connection_flush(connection);
+
+ dbus_message_unref(msg);
+}
+
+static void ppp_exit(void *data, int arg)
+{
+ if (connection) {
+ dbus_connection_unref(connection);
+ connection = NULL;
+ }
+
+ if (busname) {
+ free(busname);
+ busname = NULL;
+ }
+
+ if (interface) {
+ free(interface);
+ interface = NULL;
+ }
+
+ if (path) {
+ free(path);
+ path = NULL;
+ }
+}
+
+static void ppp_phase_change(void *data, int arg)
+{
+ const char *reason = "disconnect";
+ DBusMessage *msg;
+ int send_msg = 0;
+
+ if (!connection)
+ return;
+
+ if (prev_phase == PHASE_AUTHENTICATE &&
+ arg == PHASE_TERMINATE) {
+ reason = "auth failed";
+ send_msg = 1;
+ }
+
+ if (send_msg > 0 || arg == PHASE_DEAD || arg == PHASE_DISCONNECT) {
+ msg = dbus_message_new_method_call(busname, path,
+ interface, "notify");
+ if (!msg)
+ return;
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_STRING, &reason, DBUS_TYPE_INVALID);
+
+ dbus_connection_send(connection, msg, NULL);
+
+ dbus_connection_flush(connection);
+
+ dbus_message_unref(msg);
+ }
+
+ prev_phase = arg;
+}
+
+int plugin_init(void)
+{
+ DBusError error;
+ static const char *bus, *inter, *p;
+
+ dbus_error_init(&error);
+
+ bus = getenv("CONNMAN_BUSNAME");
+ inter = getenv("CONNMAN_INTERFACE");
+ p = getenv("CONNMAN_PATH");
+
+ if (!bus || !inter || !p)
+ return -1;
+
+ busname = strdup(bus);
+ interface = strdup(inter);
+ path = strdup(p);
+
+ if (!busname || !interface || !path) {
+ ppp_exit(NULL, 0);
+ return -1;
+ }
+
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
+ if (!connection) {
+ if (dbus_error_is_set(&error))
+ dbus_error_free(&error);
+
+ ppp_exit(NULL, 0);
+ return -1;
+ }
+
+ pap_passwd_hook = ppp_get_secret;
+ chap_passwd_hook = ppp_get_secret;
+
+ chap_check_hook = ppp_have_secret;
+ pap_check_hook = ppp_have_secret;
+
+ add_notifier(&ip_up_notifier, ppp_up, NULL);
+ add_notifier(&phasechange, ppp_phase_change, NULL);
+ add_notifier(&exitnotify, ppp_exit, connection);
+
+ return 0;
+}
diff --git a/scripts/openconnect-script.c b/scripts/openconnect-script.c
new file mode 100644
index 0000000..5e04144
--- /dev/null
+++ b/scripts/openconnect-script.c
@@ -0,0 +1,155 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <libgen.h>
+
+#include <dbus/dbus.h>
+
+extern char **environ;
+
+static void print(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+ vsyslog(LOG_INFO, format, ap);
+ va_end(ap);
+}
+
+static void append(DBusMessageIter *dict, const char *pattern)
+{
+ DBusMessageIter entry;
+ const char *key, *value;
+ char *delim;
+
+ delim = strchr(pattern, '=');
+ *delim = '\0';
+
+ key = pattern;
+ value = delim + 1;
+
+ /* We clean the environment before invoking openconnect, but
+ might as well still filter out the few things that get
+ added that we're not interested in */
+ if (!strcmp(key, "PWD") || !strcmp(key, "_") ||
+ !strcmp(key, "SHLVL") || !strcmp(key, "connman_busname") ||
+ !strcmp(key, "connman_network"))
+ return;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &value);
+
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+int main(int argc, char *argv[])
+{
+ DBusConnection *conn;
+ DBusError error;
+ DBusMessage *msg;
+ DBusMessageIter iter, dict;
+ char **envp, *busname, *reason, *interface, *path;
+ int ret = 0;
+
+ openlog(basename(argv[0]), LOG_NDELAY | LOG_PID, LOG_DAEMON);
+
+ busname = getenv("CONNMAN_BUSNAME");
+ interface = getenv("CONNMAN_INTERFACE");
+ path = getenv("CONNMAN_PATH");
+
+ reason = getenv("reason");
+
+ if (!busname || !interface || !path || !reason) {
+ print("Required environment variables not set");
+ ret = 1;
+ goto out;
+ }
+
+ if (strcmp(reason, "pre-init") == 0)
+ goto out;
+
+ dbus_error_init(&error);
+
+ conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
+ if (!conn) {
+ if (dbus_error_is_set(&error)) {
+ print("%s", error.message);
+ dbus_error_free(&error);
+ } else
+ print("Failed to get on system bus");
+
+ goto out;
+ }
+
+ msg = dbus_message_new_method_call(busname, path,
+ interface, "notify");
+ if (!msg) {
+ dbus_connection_unref(conn);
+ print("Failed to allocate method call");
+ goto out;
+ }
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_STRING, &reason,
+ DBUS_TYPE_INVALID);
+
+ dbus_message_iter_init_append(msg, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ for (envp = environ; envp && *envp; envp++)
+ append(&dict, *envp);
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ if (!dbus_connection_send(conn, msg, NULL)) {
+ print("Failed to send message");
+ goto out;
+ }
+
+ dbus_connection_flush(conn);
+
+ dbus_message_unref(msg);
+
+ dbus_connection_unref(conn);
+
+out:
+ closelog();
+
+ return ret;
+}
diff --git a/scripts/openvpn-script.c b/scripts/openvpn-script.c
new file mode 100644
index 0000000..6ba0d29
--- /dev/null
+++ b/scripts/openvpn-script.c
@@ -0,0 +1,146 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2010,2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <libgen.h>
+
+#include <dbus/dbus.h>
+
+extern char **environ;
+
+static void print(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+ vsyslog(LOG_INFO, format, ap);
+ va_end(ap);
+}
+
+static void append(DBusMessageIter *dict, const char *pattern)
+{
+ DBusMessageIter entry;
+ const char *key, *value;
+ char *delim;
+
+ delim = strchr(pattern, '=');
+ *delim = '\0';
+
+ key = pattern;
+ value = delim + 1;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &value);
+
+ dbus_message_iter_close_container(dict, &entry);
+}
+
+int main(int argc, char *argv[])
+{
+ DBusConnection *conn;
+ DBusError error;
+ DBusMessage *msg;
+ DBusMessageIter iter, dict;
+ char **envp, *busname, *interface, *path, *reason;
+ int ret = 0;
+
+ openlog(basename(argv[0]), LOG_NDELAY | LOG_PID, LOG_DAEMON);
+
+ busname = getenv("CONNMAN_BUSNAME");
+ interface = getenv("CONNMAN_INTERFACE");
+ path = getenv("CONNMAN_PATH");
+
+ reason = getenv("script_type");
+
+ if (!busname || !interface || !path || !reason) {
+ print("Required environment variables not set; "
+ "bus=%s iface=%s path=%s reason=%s",
+ busname, interface, path, reason);
+ ret = 1;
+ goto out;
+ }
+ dbus_error_init(&error);
+
+ conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
+ if (!conn) {
+ if (dbus_error_is_set(&error)) {
+ print("%s", error.message);
+ dbus_error_free(&error);
+ } else
+ print("Failed to get on system bus");
+
+ goto out;
+ }
+
+ msg = dbus_message_new_method_call(busname, path,
+ interface, "notify");
+ if (!msg) {
+ dbus_connection_unref(conn);
+ print("Failed to allocate method call");
+ goto out;
+ }
+
+ dbus_message_set_no_reply(msg, TRUE);
+
+ dbus_message_append_args(msg,
+ DBUS_TYPE_STRING, &reason,
+ DBUS_TYPE_INVALID);
+
+ dbus_message_iter_init_append(msg, &iter);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ for (envp = environ; envp && *envp; envp++)
+ append(&dict, *envp);
+
+ dbus_message_iter_close_container(&iter, &dict);
+
+ if (!dbus_connection_send(conn, msg, NULL)) {
+ print("Failed to send message");
+ goto out;
+ }
+
+ dbus_connection_flush(conn);
+
+ dbus_message_unref(msg);
+
+ dbus_connection_unref(conn);
+
+out:
+ closelog();
+
+ return ret;
+}
diff --git a/src/6to4.c b/src/6to4.c
new file mode 100644
index 0000000..0e3a7a1
--- /dev/null
+++ b/src/6to4.c
@@ -0,0 +1,492 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011 Nokia Corporation. All rights reserved.
+ * Copyright (C) Alexey Kuznetsov et al. from iproute2 package.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <linux/ip.h>
+#include <linux/if_tunnel.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <sys/ioctl.h>
+#include <unistd.h>
+
+#include "connman.h"
+#include <connman/log.h>
+#include <connman/ipconfig.h>
+#include "gweb/gweb.h"
+
+static int tunnel_created;
+static int tunnel_pending;
+static char *tunnel_ip_address;
+static GWeb *web;
+static guint web_request_id;
+static unsigned int newlink_watch;
+static unsigned int newlink_flags;
+static int newlink_timeout_id;
+
+#define STATUS_URL "http://ipv6.connman.net/online/status.html"
+
+#ifndef IP_DF
+#define IP_DF 0x4000 /* Flag: "Don't Fragment" */
+#endif
+
+static int tunnel_create(struct in_addr *addr)
+{
+ struct ip_tunnel_parm p;
+ struct ifreq ifr;
+ int fd = -1;
+ int ret;
+
+ /* ip tunnel add tun6to4 mode sit remote any local 1.2.3.4 ttl 64 */
+
+ memset(&p, 0, sizeof(struct ip_tunnel_parm));
+ memset(&ifr, 0, sizeof(struct ifreq));
+
+ p.iph.version = 4;
+ p.iph.ihl = 5;
+ p.iph.frag_off = htons(IP_DF);
+ p.iph.protocol = IPPROTO_IPV6;
+ p.iph.saddr = addr->s_addr;
+ p.iph.ttl = 64;
+ strncpy(p.name, "tun6to4", sizeof(p.name) - 1);
+
+ strncpy(ifr.ifr_name, "sit0", sizeof(ifr.ifr_name) - 1);
+ ifr.ifr_ifru.ifru_data = (void *)&p;
+ fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (fd < 0)
+ return -errno;
+ ret = ioctl(fd, SIOCADDTUNNEL, &ifr);
+ if (ret)
+ connman_error("add tunnel %s failed: %s", ifr.ifr_name,
+ strerror(errno));
+ close(fd);
+
+ return -ret;
+}
+
+static void tunnel_destroy(void)
+{
+ struct ip_tunnel_parm p;
+ struct ifreq ifr;
+ int fd = -1;
+ int ret;
+
+ if (tunnel_created == 0)
+ return;
+
+ /* ip tunnel del tun6to4 */
+
+ memset(&p, 0, sizeof(struct ip_tunnel_parm));
+ memset(&ifr, 0, sizeof(struct ifreq));
+
+ p.iph.version = 4;
+ p.iph.ihl = 5;
+ p.iph.protocol = IPPROTO_IPV6;
+ strncpy(p.name, "tun6to4", sizeof(p.name) - 1);
+
+ strncpy(ifr.ifr_name, "tun6to4", sizeof(ifr.ifr_name) - 1);
+ ifr.ifr_ifru.ifru_data = (void *)&p;
+ fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (fd < 0) {
+ connman_error("socket failed: %s", strerror(errno));
+ return;
+ }
+
+ ret = ioctl(fd, SIOCDELTUNNEL, &ifr);
+ if (ret)
+ connman_error("del tunnel %s failed: %s", ifr.ifr_name,
+ strerror(errno));
+ else
+ tunnel_created = 0;
+
+ tunnel_pending = 0;
+ close(fd);
+
+ g_free(tunnel_ip_address);
+ tunnel_ip_address = NULL;
+}
+
+static int tunnel_add_route(void)
+{
+ struct __connman_inet_rtnl_handle rth;
+ struct in6_addr addr6;
+ int index;
+ int ret = 0;
+
+ /* ip -6 route add ::/0 via ::192.88.99.1 dev tun6to4 metric 1 */
+
+ index = if_nametoindex("tun6to4");
+ if (index == 0) {
+ DBG("Can not find device tun6to4");
+ return -1;
+ }
+
+ memset(&rth, 0, sizeof(rth));
+
+ rth.req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ rth.req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
+ rth.req.n.nlmsg_type = RTM_NEWROUTE;
+ rth.req.u.r.rt.rtm_family = AF_INET6;
+ rth.req.u.r.rt.rtm_table = RT_TABLE_MAIN;
+ rth.req.u.r.rt.rtm_protocol = RTPROT_BOOT;
+ rth.req.u.r.rt.rtm_scope = RT_SCOPE_UNIVERSE;
+ rth.req.u.r.rt.rtm_type = RTN_UNICAST;
+ rth.req.u.r.rt.rtm_dst_len = 0;
+
+ inet_pton(AF_INET6, "::192.88.99.1", &addr6);
+
+ __connman_inet_rtnl_addattr_l(&rth.req.n, sizeof(rth.req), RTA_GATEWAY,
+ &addr6.s6_addr, 16);
+ __connman_inet_rtnl_addattr32(&rth.req.n, sizeof(rth.req), RTA_OIF,
+ index);
+ __connman_inet_rtnl_addattr32(&rth.req.n, sizeof(rth.req),
+ RTA_PRIORITY, 1);
+
+ ret = __connman_inet_rtnl_open(&rth);
+ if (ret < 0)
+ goto done;
+
+ ret = __connman_inet_rtnl_send(&rth, &rth.req.n);
+
+done:
+ __connman_inet_rtnl_close(&rth);
+ return ret;
+}
+
+static int tunnel_set_addr(unsigned int a, unsigned int b,
+ unsigned int c, unsigned int d)
+{
+ struct __connman_inet_rtnl_handle rth;
+ struct in6_addr addr6;
+ char *ip6addr;
+ int ret;
+
+ /* ip -6 addr add dev tun6to4 2002:0102:0304::1/64 */
+
+ memset(&rth, 0, sizeof(rth));
+
+ rth.req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
+ rth.req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
+ rth.req.n.nlmsg_type = RTM_NEWADDR;
+ rth.req.u.i.ifa.ifa_family = AF_INET6;
+ rth.req.u.i.ifa.ifa_prefixlen = 64;
+ rth.req.u.i.ifa.ifa_index = if_nametoindex("tun6to4");
+ if (rth.req.u.i.ifa.ifa_index == 0) {
+ connman_error("Can not find device tun6to4");
+ ret = -1;
+ goto done;
+ }
+
+ ip6addr = g_strdup_printf("2002:%02x%02x:%02x%02x::1", a, b, c, d);
+ inet_pton(AF_INET6, ip6addr, &addr6);
+ DBG("ipv6 address %s", ip6addr);
+ g_free(ip6addr);
+
+ __connman_inet_rtnl_addattr_l(&rth.req.n, sizeof(rth.req), IFA_LOCAL,
+ &addr6.s6_addr, 16);
+ __connman_inet_rtnl_addattr_l(&rth.req.n, sizeof(rth.req), IFA_ADDRESS,
+ &addr6.s6_addr, 16);
+
+ ret = __connman_inet_rtnl_open(&rth);
+ if (ret < 0)
+ goto done;
+
+ ret = __connman_inet_rtnl_send(&rth, &rth.req.n);
+
+done:
+ __connman_inet_rtnl_close(&rth);
+ return ret;
+}
+
+static gboolean unref_web(gpointer user_data)
+{
+ g_web_unref(web);
+ return FALSE;
+}
+
+static bool web_result(GWebResult *result, gpointer user_data)
+{
+ guint16 status;
+
+ if (web_request_id == 0)
+ return false;
+
+ status = g_web_result_get_status(result);
+
+ DBG("status %u", status);
+
+ if (status >= 400 && status < 500)
+ tunnel_destroy();
+ else
+ tunnel_pending = 0;
+
+ web_request_id = 0;
+
+ g_timeout_add_seconds(1, unref_web, NULL);
+
+ return false;
+}
+
+static void web_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static gboolean newlink_timeout(gpointer user_data)
+{
+ /*
+ * Stop if the timeout has been cancelled already by tun_newlink()
+ */
+ if (newlink_timeout_id == 0)
+ return FALSE;
+
+ DBG("");
+
+ if (newlink_watch != 0) {
+ connman_rtnl_remove_watch(newlink_watch);
+ newlink_watch = 0;
+ }
+
+ newlink_flags = 0;
+
+ if (web_request_id == 0)
+ tunnel_destroy();
+
+ newlink_timeout_id = 0;
+
+ return FALSE;
+}
+
+static void tun_newlink(unsigned flags, unsigned change, void *user_data)
+{
+ int index = GPOINTER_TO_INT(user_data);
+
+ if ((newlink_flags & IFF_UP) == (flags & IFF_UP)) {
+ newlink_flags = flags;
+ return;
+ }
+
+ if (flags & IFF_UP) {
+ /*
+ * We try to verify that connectivity through tunnel works ok.
+ */
+ if (newlink_timeout_id > 0) {
+ g_source_remove(newlink_timeout_id);
+ newlink_timeout_id = 0;
+ }
+
+ web = g_web_new(index);
+ if (!web) {
+ tunnel_destroy();
+ return;
+ }
+
+ g_web_set_accept(web, NULL);
+ g_web_set_user_agent(web, "ConnMan/%s", VERSION);
+ g_web_set_close_connection(web, TRUE);
+
+ if (getenv("CONNMAN_WEB_DEBUG"))
+ g_web_set_debug(web, web_debug, "6to4");
+
+ web_request_id = g_web_request_get(web, STATUS_URL,
+ web_result, NULL, NULL);
+
+ newlink_timeout(NULL);
+ }
+
+ newlink_flags = flags;
+}
+
+static int init_6to4(struct in_addr *ip4addr)
+{
+ unsigned int a, b, c, d;
+ int ret, if_index;
+ in_addr_t addr;
+
+ DBG("");
+
+ addr = ntohl(ip4addr->s_addr);
+
+ a = (addr & 0xff000000) >> 24;
+ b = (addr & 0x00ff0000) >> 16;
+ c = (addr & 0x0000ff00) >> 8;
+ d = addr & 0x000000ff;
+
+ ret = tunnel_create(ip4addr);
+ if (ret)
+ return -1;
+
+ tunnel_created = 1;
+
+ ret = connman_inet_setup_tunnel("tun6to4", 1472);
+ if (ret)
+ goto error;
+
+ ret = tunnel_set_addr(a, b, c, d);
+ if (ret)
+ goto error;
+
+ ret = tunnel_add_route();
+ if (ret)
+ goto error;
+
+ if_index = connman_inet_ifindex("tun6to4");
+ if (if_index < 0)
+ goto error;
+
+ newlink_watch = connman_rtnl_add_newlink_watch(if_index,
+ tun_newlink, GINT_TO_POINTER(if_index));
+
+ newlink_timeout_id = g_timeout_add_seconds(1, newlink_timeout, NULL);
+
+ return 0;
+
+error:
+ tunnel_destroy();
+ return -1;
+}
+
+static void receive_rs_reply(struct nd_router_advert *reply,
+ unsigned int length, void *user_data)
+{
+ char *address = user_data;
+ struct in_addr ip4addr;
+
+ DBG("reply %p len %d address %s", reply, length, address);
+
+ /* We try to create tunnel if autoconfiguration did not work i.e.,
+ * we did not receive any reply to router solicitation message.
+ */
+ if (!reply && inet_aton(address, &ip4addr) != 0)
+ init_6to4(&ip4addr);
+
+ g_free(address);
+}
+
+int __connman_6to4_probe(struct connman_service *service)
+{
+ struct connman_ipconfig *ip4config, *ip6config;
+ enum connman_ipconfig_method method;
+ unsigned int a, b;
+ struct in_addr ip4addr;
+ in_addr_t addr;
+ const char *address;
+ char *ip_address;
+ int index;
+
+ DBG("service %p", service);
+
+ if (tunnel_created || tunnel_pending)
+ return 0;
+
+ if (!service)
+ return -1;
+
+ ip4config = __connman_service_get_ip4config(service);
+ if (!ip4config)
+ return -1;
+
+ ip6config = __connman_service_get_ip6config(service);
+ if (!ip6config)
+ return -1;
+
+ method = __connman_ipconfig_get_method(ip6config);
+ if (method != CONNMAN_IPCONFIG_METHOD_AUTO)
+ return -1;
+
+ address = __connman_ipconfig_get_local(ip4config);
+ if (!address)
+ return -1;
+
+ if (inet_aton(address, &ip4addr) == 0)
+ return -1;
+
+ addr = ntohl(ip4addr.s_addr);
+
+ a = (addr & 0xff000000) >> 24;
+ b = (addr & 0x00ff0000) >> 16;
+
+ /* 6to4 tunnel is only usable if we have a public IPv4 address */
+ if (a == 10 || (a == 192 && b == 168) ||
+ (a == 172 && (b >= 16 && b <= 31)))
+ return -1;
+
+ index = __connman_ipconfig_get_index(ip4config);
+ ip_address = g_strdup(address);
+ tunnel_pending = 1;
+
+ g_free(tunnel_ip_address);
+ tunnel_ip_address = g_strdup(address);
+
+ return __connman_inet_ipv6_send_rs(index, 2, receive_rs_reply,
+ ip_address);
+}
+
+void __connman_6to4_remove(struct connman_ipconfig *ip4config)
+{
+ const char *address;
+
+ DBG("tunnel ip address %s", tunnel_ip_address);
+
+ if (!ip4config)
+ return;
+
+ address = __connman_ipconfig_get_local(ip4config);
+ if (!address)
+ return;
+
+ if (g_strcmp0(address, tunnel_ip_address) != 0)
+ return;
+
+ if (tunnel_created)
+ tunnel_destroy();
+}
+
+int __connman_6to4_check(struct connman_ipconfig *ip4config)
+{
+ const char *address;
+
+ if (!ip4config || tunnel_created == 0 ||
+ tunnel_pending == 1)
+ return -1;
+
+ DBG("tunnel ip address %s", tunnel_ip_address);
+
+ address = __connman_ipconfig_get_local(ip4config);
+ if (!address)
+ return -1;
+
+ if (g_strcmp0(address, tunnel_ip_address) == 0)
+ return 1;
+
+ return 0;
+}
diff --git a/src/agent-connman.c b/src/agent-connman.c
new file mode 100644
index 0000000..8440451
--- /dev/null
+++ b/src/agent-connman.c
@@ -0,0 +1,798 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gdbus.h>
+#include <connman/agent.h>
+#include <connman/setting.h>
+#include <connman/service.h>
+
+#include "connman.h"
+
+static bool check_reply_has_dict(DBusMessage *reply)
+{
+ const char *signature = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
+
+ if (dbus_message_has_signature(reply, signature))
+ return true;
+
+ connman_warn("Reply %s to %s from %s has wrong signature %s",
+ signature,
+ dbus_message_get_interface(reply),
+ dbus_message_get_sender(reply),
+ dbus_message_get_signature(reply));
+
+ return false;
+}
+
+struct request_input_reply {
+ struct connman_service *service;
+ struct connman_peer *peer;
+ union {
+ authentication_cb_t service_callback;
+ peer_wps_cb_t peer_callback;
+ };
+ bool wps_requested;
+ void *user_data;
+};
+
+static void request_input_passphrase_reply(DBusMessage *reply, void *user_data)
+{
+ struct request_input_reply *passphrase_reply = user_data;
+ bool values_received = false;
+ bool wps = false;
+ const char *error = NULL;
+ char *identity = NULL;
+ char *passphrase = NULL;
+ char *wpspin = NULL;
+ char *key;
+ char *name = NULL;
+ int name_len = 0;
+ DBusMessageIter iter, dict;
+
+ if (!reply) {
+ error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
+ goto done;
+ }
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ error = dbus_message_get_error_name(reply);
+ goto done;
+ }
+
+ if (!check_reply_has_dict(reply))
+ goto done;
+
+ values_received = true;
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ if (g_str_equal(key, "Identity")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &identity);
+
+ } else if (g_str_equal(key, "Passphrase")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &passphrase);
+
+ } else if (g_str_equal(key, "WPS")) {
+ wps = true;
+
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &wpspin);
+ break;
+ } else if (g_str_equal(key, "Name")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &name);
+ name_len = strlen(name);
+ } else if (g_str_equal(key, "SSID")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_VARIANT)
+ break;
+ if (dbus_message_iter_get_element_type(&value)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_get_fixed_array(&value, &name,
+ &name_len);
+ }
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ passphrase_reply->service_callback(passphrase_reply->service,
+ values_received, name, name_len,
+ identity, passphrase, wps, wpspin,
+ error, passphrase_reply->user_data);
+
+ g_free(passphrase_reply);
+}
+
+static void request_input_append_alternates(DBusMessageIter *iter,
+ void *user_data)
+{
+ const char *str = user_data;
+ char **alternates, **alternative;
+
+ if (!str)
+ return;
+
+ alternates = g_strsplit(str, ",", 0);
+ if (!alternates)
+ return;
+
+ for (alternative = alternates; *alternative; alternative++)
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ alternative);
+
+ g_strfreev(alternates);
+}
+
+static void request_input_append_identity(DBusMessageIter *iter,
+ void *user_data)
+{
+ char *str = "string";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "mandatory";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void request_input_append_passphrase(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct connman_service *service = user_data;
+ char *value;
+ const char *phase2;
+
+ switch (__connman_service_get_security(service)) {
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ value = "wep";
+ break;
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ value = "psk";
+ break;
+ case CONNMAN_SERVICE_SECURITY_8021X:
+ phase2 = __connman_service_get_phase2(service);
+
+ if (phase2 && (
+ g_str_has_suffix(phase2, "GTC") ||
+ g_str_has_suffix(phase2, "OTP")))
+ value = "response";
+ else
+ value = "passphrase";
+
+ break;
+ default:
+ value = "string";
+ break;
+ }
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &value);
+ value = "mandatory";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &value);
+
+ if (__connman_service_wps_enabled(service)) {
+ connman_dbus_dict_append_array(iter, "Alternates",
+ DBUS_TYPE_STRING,
+ request_input_append_alternates,
+ "WPS");
+ }
+}
+
+struct request_wps_data {
+ bool peer;
+};
+
+static void request_input_append_wps(DBusMessageIter *iter, void *user_data)
+{
+ struct request_wps_data *wps = user_data;
+ const char *str = "wpspin";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ if (wps && wps->peer)
+ str = "mandatory";
+ else
+ str = "alternate";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void request_input_append_name(DBusMessageIter *iter, void *user_data)
+{
+ const char *str = "string";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "mandatory";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+ connman_dbus_dict_append_array(iter, "Alternates",
+ DBUS_TYPE_STRING,
+ request_input_append_alternates,
+ "SSID");
+}
+
+static void request_input_append_ssid(DBusMessageIter *iter, void *user_data)
+{
+ const char *str = "ssid";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "alternate";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void request_input_append_password(DBusMessageIter *iter,
+ void *user_data)
+{
+ char *str = "passphrase";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "mandatory";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+}
+
+struct previous_passphrase_data {
+ const char *passphrase;
+ const char *type;
+};
+
+static void request_input_append_previouspassphrase(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct previous_passphrase_data *data = user_data;
+ const char *requirement = "informational";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &data->type);
+
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &requirement);
+
+ connman_dbus_dict_append_basic(iter, "Value",
+ DBUS_TYPE_STRING, &data->passphrase);
+}
+
+static void previous_passphrase_handler(DBusMessageIter *iter,
+ struct connman_service *service)
+{
+ enum connman_service_security security;
+ struct previous_passphrase_data data;
+ struct connman_network *network;
+
+ network = __connman_service_get_network(service);
+ data.passphrase = connman_network_get_string(network, "WiFi.PinWPS");
+
+ if (connman_network_get_bool(network, "WiFi.UseWPS") &&
+ data.passphrase) {
+ data.type = "wpspin";
+ } else {
+ data.passphrase = __connman_service_get_passphrase(service);
+ if (!data.passphrase)
+ return;
+
+ security = __connman_service_get_security(service);
+ switch (security) {
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ data.type = "wep";
+ break;
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ data.type = "psk";
+ break;
+ /*
+ * This should never happen: no passphrase is set if security
+ * is not one of the above. */
+ default:
+ break;
+ }
+ }
+
+ connman_dbus_dict_append_dict(iter, "PreviousPassphrase",
+ request_input_append_previouspassphrase, &data);
+}
+
+static void request_input_login_reply(DBusMessage *reply, void *user_data)
+{
+ struct request_input_reply *username_password_reply = user_data;
+ const char *error = NULL;
+ bool values_received = false;
+ char *username = NULL;
+ char *password = NULL;
+ char *key;
+ DBusMessageIter iter, dict;
+
+ if (!reply) {
+ error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
+ goto done;
+ }
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ error = dbus_message_get_error_name(reply);
+ goto done;
+ }
+
+ if (!check_reply_has_dict(reply))
+ goto done;
+
+ values_received = true;
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ if (g_str_equal(key, "Username")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &username);
+
+ } else if (g_str_equal(key, "Password")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry) !=
+ DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &password);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ username_password_reply->service_callback(
+ username_password_reply->service, values_received,
+ NULL, 0, username, password, FALSE, NULL, error,
+ username_password_reply->user_data);
+
+ g_free(username_password_reply);
+}
+
+int __connman_agent_request_passphrase_input(struct connman_service *service,
+ authentication_cb_t callback,
+ const char *dbus_sender, void *user_data)
+{
+ DBusMessage *message;
+ const char *path, *agent_sender, *agent_path;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ struct request_input_reply *passphrase_reply;
+ int err;
+ void *agent;
+
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+
+ DBG("agent %p service %p path %s", agent, service, agent_path);
+
+ if (!service || !agent || !agent_path || !callback)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ CONNMAN_AGENT_INTERFACE,
+ "RequestInput");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = __connman_service_get_path(service);
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_OBJECT_PATH, &path);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ if (__connman_service_is_hidden(service)) {
+ connman_dbus_dict_append_dict(&dict, "Name",
+ request_input_append_name, NULL);
+ connman_dbus_dict_append_dict(&dict, "SSID",
+ request_input_append_ssid, NULL);
+ }
+
+ if (__connman_service_get_security(service) ==
+ CONNMAN_SERVICE_SECURITY_8021X) {
+ connman_dbus_dict_append_dict(&dict, "Identity",
+ request_input_append_identity, service);
+ }
+
+ if (__connman_service_get_security(service) !=
+ CONNMAN_SERVICE_SECURITY_NONE) {
+ connman_dbus_dict_append_dict(&dict, "Passphrase",
+ request_input_append_passphrase, service);
+
+ previous_passphrase_handler(&dict, service);
+ }
+
+ if (__connman_service_wps_enabled(service))
+ connman_dbus_dict_append_dict(&dict, "WPS",
+ request_input_append_wps, NULL);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ passphrase_reply = g_try_new0(struct request_input_reply, 1);
+ if (!passphrase_reply) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ passphrase_reply->service = service;
+ passphrase_reply->service_callback = callback;
+ passphrase_reply->user_data = user_data;
+
+ err = connman_agent_queue_message(service, message,
+ connman_timeout_input_request(),
+ request_input_passphrase_reply,
+ passphrase_reply, agent);
+
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending agent message", err);
+ dbus_message_unref(message);
+ g_free(passphrase_reply);
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+int __connman_agent_request_login_input(struct connman_service *service,
+ authentication_cb_t callback, void *user_data)
+{
+ DBusMessage *message;
+ const char *path, *agent_sender, *agent_path;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ struct request_input_reply *username_password_reply;
+ int err;
+ void *agent;
+
+ agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
+
+ if (!service || !agent || !agent_path || !callback)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ CONNMAN_AGENT_INTERFACE,
+ "RequestInput");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = __connman_service_get_path(service);
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_OBJECT_PATH, &path);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ connman_dbus_dict_append_dict(&dict, "Username",
+ request_input_append_identity, service);
+
+ connman_dbus_dict_append_dict(&dict, "Password",
+ request_input_append_password, service);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ username_password_reply = g_try_new0(struct request_input_reply, 1);
+ if (!username_password_reply) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ username_password_reply->service = service;
+ username_password_reply->service_callback = callback;
+ username_password_reply->user_data = user_data;
+
+ err = connman_agent_queue_message(service, message,
+ connman_timeout_input_request(),
+ request_input_login_reply, username_password_reply,
+ agent);
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending agent request", err);
+ dbus_message_unref(message);
+ g_free(username_password_reply);
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+struct request_browser_reply_data {
+ struct connman_service *service;
+ browser_authentication_cb_t callback;
+ void *user_data;
+};
+
+static void request_browser_reply(DBusMessage *reply, void *user_data)
+{
+ struct request_browser_reply_data *browser_reply_data = user_data;
+ bool result = false;
+ const char *error = NULL;
+
+ if (!reply) {
+ error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
+ goto done;
+ }
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ error = dbus_message_get_error_name(reply);
+ goto done;
+ }
+
+ result = true;
+
+done:
+ browser_reply_data->callback(browser_reply_data->service, result,
+ error, browser_reply_data->user_data);
+ g_free(browser_reply_data);
+}
+
+int __connman_agent_request_browser(struct connman_service *service,
+ browser_authentication_cb_t callback,
+ const char *url, void *user_data)
+{
+ struct request_browser_reply_data *browser_reply_data;
+ DBusMessage *message;
+ DBusMessageIter iter;
+ const char *path, *agent_sender, *agent_path;
+ int err;
+ void *agent;
+
+ agent = connman_agent_get_info(NULL, &agent_sender, &agent_path);
+
+ if (!service || !agent || !agent_path || !callback)
+ return -ESRCH;
+
+ if (!url)
+ url = "";
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ CONNMAN_AGENT_INTERFACE,
+ "RequestBrowser");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = __connman_service_get_path(service);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
+
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &url);
+
+ browser_reply_data = g_try_new0(struct request_browser_reply_data, 1);
+ if (!browser_reply_data) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ browser_reply_data->service = service;
+ browser_reply_data->callback = callback;
+ browser_reply_data->user_data = user_data;
+
+ err = connman_agent_queue_message(service, message,
+ connman_timeout_browser_launch(),
+ request_browser_reply, browser_reply_data,
+ agent);
+
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending browser request", err);
+ dbus_message_unref(message);
+ g_free(browser_reply_data);
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+int __connman_agent_report_peer_error(struct connman_peer *peer,
+ const char *path, const char *error,
+ report_error_cb_t callback,
+ const char *dbus_sender,
+ void *user_data)
+{
+ return connman_agent_report_error_full(peer, path, "ReportPeerError",
+ error, callback, dbus_sender, user_data);
+}
+
+static void request_peer_authorization_reply(DBusMessage *reply,
+ void *user_data)
+{
+ struct request_input_reply *auth_reply = user_data;
+ DBusMessageIter iter, dict;
+ const char *error = NULL;
+ bool choice_done = false;
+ char *wpspin = NULL;
+ char *key;
+
+ if (!reply) {
+ error = CONNMAN_ERROR_INTERFACE ".OperationAborted";
+ goto done;
+ }
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ error = dbus_message_get_error_name(reply);
+ goto done;
+ }
+
+ if (!check_reply_has_dict(reply))
+ goto done;
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ if (g_str_equal(key, "WPS")) {
+ choice_done = true;
+
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ dbus_message_iter_get_basic(&value, &wpspin);
+ break;
+ }
+ dbus_message_iter_next(&dict);
+ }
+
+ if (!auth_reply->wps_requested)
+ choice_done = true;
+
+done:
+ auth_reply->peer_callback(auth_reply->peer, choice_done, wpspin,
+ error, auth_reply->user_data);
+
+ g_free(auth_reply);
+}
+
+int __connman_agent_request_peer_authorization(struct connman_peer *peer,
+ peer_wps_cb_t callback,
+ bool wps_requested,
+ const char *dbus_sender,
+ void *user_data)
+{
+ struct request_wps_data wps = { .peer = true };
+ const char *path, *agent_sender, *agent_path;
+ struct request_input_reply *auth_reply;
+ DBusMessageIter dict, iter;
+ DBusMessage *message;
+ void *agent;
+ int err;
+
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ DBG("agent %p peer %p path %s", agent, peer, agent_path);
+
+ if (!peer || !agent || !agent_path || !callback)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ CONNMAN_AGENT_INTERFACE, "RequestPeerAuthorization");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = __connman_peer_get_path(peer);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH, &path);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ if (wps_requested)
+ connman_dbus_dict_append_dict(&dict, "WPS",
+ request_input_append_wps, &wps);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ auth_reply = g_try_new0(struct request_input_reply, 1);
+ if (!auth_reply) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ auth_reply->peer = peer;
+ auth_reply->peer_callback = callback;
+ auth_reply->wps_requested = wps_requested;
+ auth_reply->user_data = user_data;
+
+ err = connman_agent_queue_message(peer, message,
+ connman_timeout_input_request(),
+ request_peer_authorization_reply,
+ auth_reply, agent);
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending agent message", err);
+ dbus_message_unref(message);
+ g_free(auth_reply);
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
diff --git a/src/agent.c b/src/agent.c
new file mode 100644
index 0000000..bdeb0e7
--- /dev/null
+++ b/src/agent.c
@@ -0,0 +1,684 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gdbus.h>
+#include <connman/agent.h>
+#include <connman/setting.h>
+
+#include "connman.h"
+
+#define agent_ref(agent) \
+ agent_ref_debug(agent, __FILE__, __LINE__, __func__)
+#define agent_unref(agent) \
+ agent_unref_debug(agent, __FILE__, __LINE__, __func__)
+
+static DBusConnection *connection = NULL;
+static GHashTable *agent_hash = NULL;
+static struct connman_agent *default_agent = NULL;
+
+struct connman_agent {
+ int refcount;
+ char *owner;
+ char *path;
+ struct connman_agent_request *pending;
+ GList *queue; /* queued requests for this agent */
+ guint watch;
+};
+
+struct connman_agent_request {
+ void *user_context;
+ void *user_data;
+ DBusMessage *msg;
+ DBusPendingCall *call;
+ int timeout;
+ agent_queue_cb callback;
+ struct connman_agent_driver *driver;
+};
+
+static GSList *driver_list = NULL;
+
+void *connman_agent_get_info(const char *dbus_sender, const char **sender,
+ const char **path)
+{
+ struct connman_agent *agent;
+
+ if (!dbus_sender)
+ agent = default_agent;
+ else {
+ agent = g_hash_table_lookup(agent_hash, dbus_sender);
+ if (!agent)
+ agent = default_agent;
+ }
+
+ if (agent) {
+ if (sender)
+ *sender = agent->owner;
+ if (path)
+ *path = agent->path;
+ } else {
+ if (sender)
+ *sender = NULL;
+ if (path)
+ *path = NULL;
+ }
+
+ return agent;
+}
+
+static void agent_request_free(struct connman_agent_request *request)
+{
+ if (!request)
+ return;
+
+ if (request->user_context) {
+ if (request->driver && request->driver->context_unref)
+ request->driver->context_unref(request->user_context);
+ }
+
+ if (request->msg)
+ dbus_message_unref(request->msg);
+
+ if (request->call) {
+ dbus_pending_call_cancel(request->call);
+ dbus_pending_call_unref(request->call);
+ }
+
+ g_free(request);
+}
+
+static void agent_finalize_pending(struct connman_agent *agent,
+ DBusMessage *reply)
+{
+ struct connman_agent_request *pending = agent->pending;
+ if (pending) {
+ agent->pending = NULL;
+ pending->callback(reply, pending->user_data);
+ agent_request_free(pending);
+ }
+}
+
+static void agent_receive_message(DBusPendingCall *call, void *user_data);
+
+static int agent_send_next_request(struct connman_agent *agent)
+{
+ if (agent->pending)
+ return -EBUSY;
+
+ if (!agent->queue)
+ return 0;
+
+ agent->pending = agent->queue->data;
+ agent->queue = g_list_remove(agent->queue, agent->pending);
+
+ if (!agent->pending->msg)
+ goto fail;
+
+ if (!dbus_connection_send_with_reply(connection, agent->pending->msg,
+ &agent->pending->call,
+ agent->pending->timeout))
+ goto fail;
+
+ if (!agent->pending->call)
+ goto fail;
+
+ if (!dbus_pending_call_set_notify(agent->pending->call,
+ agent_receive_message,
+ agent, NULL))
+ goto fail;
+
+ dbus_message_unref(agent->pending->msg);
+ agent->pending->msg = NULL;
+ return 0;
+
+fail:
+ agent_finalize_pending(agent, NULL);
+ return -ESRCH;
+}
+
+static int send_cancel_request(struct connman_agent *agent,
+ struct connman_agent_request *request)
+{
+ DBusMessage *message;
+
+ DBG("send cancel req to %s %s", agent->owner, agent->path);
+
+ message = dbus_message_new_method_call(agent->owner,
+ agent->path,
+ request->driver->interface,
+ "Cancel");
+ if (!message) {
+ connman_error("Couldn't allocate D-Bus message");
+ return -ENOMEM;
+ }
+
+ g_dbus_send_message(connection, message);
+ return 0;
+}
+
+static void agent_receive_message(DBusPendingCall *call, void *user_data)
+{
+ struct connman_agent *agent = user_data;
+ DBusMessage *reply;
+ int err;
+
+ DBG("agent %p req %p", agent, agent->pending);
+
+ reply = dbus_pending_call_steal_reply(call);
+ dbus_pending_call_unref(call);
+ agent->pending->call = NULL;
+
+ if (dbus_message_is_error(reply,
+ "org.freedesktop.DBus.Error.Timeout") ||
+ dbus_message_is_error(reply,
+ "org.freedesktop.DBus.Error.TimedOut")) {
+ send_cancel_request(agent, agent->pending);
+ }
+
+ agent_finalize_pending(agent, reply);
+ dbus_message_unref(reply);
+
+ err = agent_send_next_request(agent);
+ if (err < 0 && err != -EBUSY)
+ DBG("send next request failed (%s/%d)", strerror(-err), -err);
+}
+
+static struct connman_agent_driver *get_driver(void)
+{
+ return g_slist_nth_data(driver_list, 0);
+}
+
+int connman_agent_queue_message(void *user_context,
+ DBusMessage *msg, int timeout,
+ agent_queue_cb callback, void *user_data,
+ void *agent_data)
+{
+ struct connman_agent_request *queue_data;
+ struct connman_agent_driver *driver;
+ struct connman_agent *agent = agent_data;
+ int err;
+
+ if (!user_context || !callback)
+ return -EBADMSG;
+
+ queue_data = g_new0(struct connman_agent_request, 1);
+ if (!queue_data)
+ return -ENOMEM;
+
+ driver = get_driver();
+ DBG("driver %p", driver);
+
+ if (driver && driver->context_ref) {
+ queue_data->user_context = driver->context_ref(user_context);
+ queue_data->driver = driver;
+ } else
+ queue_data->user_context = user_context;
+
+ queue_data->msg = dbus_message_ref(msg);
+ queue_data->timeout = timeout;
+ queue_data->callback = callback;
+ queue_data->user_data = user_data;
+ agent->queue = g_list_append(agent->queue, queue_data);
+
+ err = agent_send_next_request(agent);
+ if (err < 0 && err != -EBUSY)
+ DBG("send next request failed (%s/%d)", strerror(-err), -err);
+
+ return err;
+}
+
+static void set_default_agent(void)
+{
+ struct connman_agent *agent = NULL;
+ GHashTableIter iter;
+ gpointer key, value;
+
+ if (default_agent)
+ return;
+
+ g_hash_table_iter_init(&iter, agent_hash);
+ if (g_hash_table_iter_next(&iter, &key, &value))
+ agent = value;
+
+ if (agent)
+ DBG("default agent set to %s %s", agent->owner, agent->path);
+ else
+ DBG("default agent cleared");
+
+ default_agent = agent;
+}
+
+static void agent_disconnect(DBusConnection *conn, void *user_data)
+{
+ struct connman_agent *agent = user_data;
+
+ DBG("agent %s disconnected", agent->owner);
+
+ if (agent->watch > 0) {
+ g_dbus_remove_watch(conn, agent->watch);
+ agent->watch = 0;
+ }
+
+ g_hash_table_remove(agent_hash, agent->owner);
+}
+
+static struct connman_agent *agent_ref_debug(struct connman_agent *agent,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", agent, agent->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&agent->refcount, 1);
+
+ return agent;
+}
+
+static struct connman_agent *agent_create(const char *name, const char *path)
+{
+ struct connman_agent *agent;
+
+ agent = g_new0(struct connman_agent, 1);
+
+ agent->owner = g_strdup(name);
+ agent->path = g_strdup(path);
+
+ agent->watch = g_dbus_add_disconnect_watch(connection,
+ name, agent_disconnect,
+ agent, NULL);
+
+ return agent_ref(agent);
+}
+
+int connman_agent_register(const char *sender, const char *path)
+{
+ struct connman_agent *agent;
+
+ DBG("sender %s path %s", sender, path);
+
+ agent = g_hash_table_lookup(agent_hash, sender);
+ if (agent)
+ return -EEXIST;
+
+ agent = agent_create(sender, path);
+ if (!agent)
+ return -EINVAL;
+
+ DBG("agent %s", agent->owner);
+
+ g_hash_table_replace(agent_hash, agent->owner, agent);
+
+ if (!default_agent)
+ set_default_agent();
+
+ return 0;
+}
+
+struct report_error_data {
+ void *user_context;
+ report_error_cb_t callback;
+ void *user_data;
+};
+
+static void report_error_reply(DBusMessage *reply, void *user_data)
+{
+ struct report_error_data *report_error = user_data;
+ bool retry = false;
+ const char *dbus_err;
+
+ if (!reply)
+ goto out;
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ dbus_err = dbus_message_get_error_name(reply);
+ if (dbus_err &&
+ strcmp(dbus_err,
+ CONNMAN_AGENT_INTERFACE ".Error.Retry") == 0)
+ retry = true;
+ }
+
+ report_error->callback(report_error->user_context, retry,
+ report_error->user_data);
+out:
+ g_free(report_error);
+}
+
+int connman_agent_report_error_full(void *user_context, const char *path,
+ const char *method, const char *error,
+ report_error_cb_t callback,
+ const char *dbus_sender, void *user_data)
+{
+ DBusMessage *message;
+ DBusMessageIter iter;
+ struct report_error_data *report_error;
+ struct connman_agent *agent;
+ int err;
+
+ agent = connman_agent_get_info(dbus_sender, NULL, NULL);
+
+ DBG("agent %p sender %s context %p path %s", agent,
+ dbus_sender, user_context, agent ? agent->path : "-");
+
+ if (!user_context || !agent || !agent->path || !error || !callback)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent->owner, agent->path,
+ CONNMAN_AGENT_INTERFACE, method);
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_OBJECT_PATH, &path);
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_STRING, &error);
+
+ report_error = g_try_new0(struct report_error_data, 1);
+ if (!report_error) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ report_error->user_context = user_context;
+ report_error->callback = callback;
+ report_error->user_data = user_data;
+
+ err = connman_agent_queue_message(user_context, message,
+ connman_timeout_input_request(),
+ report_error_reply, report_error,
+ agent);
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending error request", err);
+ g_free(report_error);
+ dbus_message_unref(message);
+ return -ESRCH;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+int connman_agent_report_error(void *user_context, const char *path,
+ const char *error,
+ report_error_cb_t callback,
+ const char *dbus_sender, void *user_data)
+{
+ return connman_agent_report_error_full(user_context, path,
+ "ReportError", error, callback, dbus_sender,
+ user_data);
+}
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_agent_driver *driver1 = a;
+ const struct connman_agent_driver *driver2 = b;
+
+ return driver2->priority - driver1->priority;
+}
+
+/**
+ * connman_agent_driver_register:
+ * @driver: Agent driver definition
+ *
+ * Register a new agent driver
+ *
+ * Returns: %0 on success
+ */
+int connman_agent_driver_register(struct connman_agent_driver *driver)
+{
+ DBG("Registering driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+
+ return 0;
+}
+
+static void release_driver(void)
+{
+ connman_agent_driver_unregister(get_driver());
+}
+
+static void cancel_all_requests(struct connman_agent *agent)
+{
+ GList *list;
+
+ DBG("request %p pending %p", agent->pending, agent->queue);
+
+ if (agent->pending) {
+ if (agent->pending->call)
+ send_cancel_request(agent, agent->pending);
+
+ agent_finalize_pending(agent, NULL);
+ }
+
+ for (list = agent->queue; list; list = list->next) {
+ struct connman_agent_request *request = list->data;
+
+ if (!request)
+ continue;
+
+ request->callback(NULL, request->user_data);
+ agent_request_free(request);
+ }
+
+ g_list_free(agent->queue);
+ agent->queue = NULL;
+}
+
+void connman_agent_cancel(void *user_context)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ int err;
+
+ DBG("context %p", user_context);
+
+ g_hash_table_iter_init(&iter, agent_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ GList *list, *next;
+ struct connman_agent *agent = value;
+
+ /*
+ * Cancel all the pending requests to a given agent and service
+ */
+ list = agent->queue;
+ while (list) {
+ struct connman_agent_request *request = list->data;
+
+ next = list->next;
+
+ if (request && request->user_context &&
+ request->user_context ==
+ user_context) {
+ DBG("cancel pending %p", request);
+
+ request->callback(NULL, request->user_data);
+
+ agent_request_free(request);
+
+ agent->queue = g_list_delete_link(agent->queue,
+ list);
+ }
+
+ list = next;
+ }
+
+ /*
+ * If there is a request from client to a given service,
+ * we need to cancel it.
+ */
+ if (agent->pending && agent->pending->user_context &&
+ agent->pending->user_context == user_context) {
+ DBG("cancel request %p", agent->pending);
+
+ if (agent->pending->call)
+ send_cancel_request(agent, agent->pending);
+
+ agent_finalize_pending(agent, NULL);
+
+ err = agent_send_next_request(agent);
+ if (err < 0 && err != -EBUSY)
+ DBG("send next request failed (%s/%d)",
+ strerror(-err), -err);
+ }
+ }
+}
+
+static void agent_unref_debug(struct connman_agent *agent,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", agent, agent->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&agent->refcount, 1) != 1)
+ return;
+
+ cancel_all_requests(agent);
+
+ g_free(agent->owner);
+ g_free(agent->path);
+
+ if (agent == default_agent) {
+ default_agent = NULL;
+ set_default_agent();
+ }
+
+ g_free(agent);
+}
+
+static void agent_release(struct connman_agent *agent, const char *interface)
+{
+ DBusMessage *message;
+
+ DBG("release agent %s %s", agent->owner, agent->path);
+
+ message = dbus_message_new_method_call(agent->owner, agent->path,
+ interface, "Release");
+ if (message == NULL) {
+ connman_error("Couldn't allocate D-Bus message");
+ return;
+ }
+
+ dbus_message_set_no_reply(message, TRUE);
+ g_dbus_send_message(connection, message);
+}
+
+static void release_agents(void)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ g_hash_table_iter_init(&iter, agent_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value))
+ agent_release(value, get_driver()->interface);
+}
+
+/**
+ * connman_agent_driver_unregister:
+ * @driver: Agent driver definition
+ *
+ * Remove a previously registered agent driver
+ */
+void connman_agent_driver_unregister(struct connman_agent_driver *driver)
+{
+ GSList *list;
+
+ if (!driver)
+ return;
+
+ DBG("Unregistering driver %p name %s", driver, driver->name);
+
+ release_agents();
+
+ for (list = driver_list; list; list = list->next) {
+ if (driver != list->data)
+ continue;
+
+ g_hash_table_remove_all(agent_hash);
+ break;
+ }
+
+ driver_list = g_slist_remove(driver_list, driver);
+}
+
+static void agent_destroy(gpointer data)
+{
+ struct connman_agent *agent = data;
+
+ DBG("agent %s req %p", agent->owner, agent->pending);
+
+ if (agent->watch > 0) {
+ g_dbus_remove_watch(connection, agent->watch);
+ agent->watch = 0;
+ }
+
+ agent_unref(agent);
+}
+
+int connman_agent_unregister(const char *sender, const char *path)
+{
+ DBG("sender %s path %s", sender, path);
+
+ if (!g_hash_table_remove(agent_hash, sender))
+ return -ESRCH;
+
+ return 0;
+}
+
+int __connman_agent_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EINVAL;
+
+ agent_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, agent_destroy);
+ if (!agent_hash)
+ return -ENOMEM;
+
+ return 0;
+}
+
+void __connman_agent_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ g_hash_table_destroy(agent_hash);
+
+ release_driver();
+
+ dbus_connection_unref(connection);
+ connection = NULL;
+}
diff --git a/src/bridge.c b/src/bridge.c
new file mode 100644
index 0000000..ba20096
--- /dev/null
+++ b/src/bridge.c
@@ -0,0 +1,141 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <linux/sockios.h>
+#include <string.h>
+#include <fcntl.h>
+#include <linux/if_tun.h>
+
+#include "connman.h"
+
+static int set_forward_delay(const char *name, unsigned int delay)
+{
+ FILE *f;
+ char *forward_delay_path;
+
+ forward_delay_path =
+ g_strdup_printf("/sys/class/net/%s/bridge/forward_delay", name);
+
+ if (!forward_delay_path)
+ return -ENOMEM;
+
+ f = fopen(forward_delay_path, "r+");
+
+ g_free(forward_delay_path);
+
+ if (!f)
+ return -errno;
+
+ fprintf(f, "%d", delay);
+
+ fclose(f);
+
+ return 0;
+}
+
+int __connman_bridge_create(const char *name)
+{
+ int sk, err;
+
+ DBG("name %s", name);
+
+ sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -EOPNOTSUPP;
+
+ if (ioctl(sk, SIOCBRADDBR, name) == -1) {
+ err = -errno;
+ if (err != -EEXIST) {
+ close(sk);
+ return -EOPNOTSUPP;
+ }
+ }
+
+ err = set_forward_delay(name, 0);
+
+ if (err < 0)
+ ioctl(sk, SIOCBRDELBR, name);
+
+ close(sk);
+
+ return err;
+}
+
+int __connman_bridge_remove(const char *name)
+{
+ int sk, err;
+
+ DBG("name %s", name);
+
+ sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -EOPNOTSUPP;
+
+ err = ioctl(sk, SIOCBRDELBR, name);
+
+ close(sk);
+
+ if (err < 0)
+ return -EOPNOTSUPP;
+
+ return 0;
+}
+
+int __connman_bridge_enable(const char *name, const char *ip_address,
+ int prefix_len, const char *broadcast)
+{
+ int err, index;
+
+ index = connman_inet_ifindex(name);
+ if (index < 0)
+ return index;
+
+ err = __connman_inet_modify_address(RTM_NEWADDR,
+ NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
+ ip_address, NULL, prefix_len, broadcast);
+ if (err < 0)
+ return err;
+
+ return connman_inet_ifup(index);
+}
+
+int __connman_bridge_disable(const char *name)
+{
+ int index;
+
+ index = connman_inet_ifindex(name);
+ if (index < 0)
+ return index;
+
+ return connman_inet_ifdown(index);
+}
diff --git a/src/clock.c b/src/clock.c
new file mode 100644
index 0000000..f38db95
--- /dev/null
+++ b/src/clock.c
@@ -0,0 +1,449 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/time.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+enum timezone_updates {
+ TIMEZONE_UPDATES_UNKNOWN = 0,
+ TIMEZONE_UPDATES_MANUAL = 1,
+ TIMEZONE_UPDATES_AUTO = 2,
+};
+
+static enum time_updates time_updates_config = TIME_UPDATES_AUTO;
+static enum timezone_updates timezone_updates_config = TIMEZONE_UPDATES_AUTO;
+
+static char *timezone_config = NULL;
+
+static const char *time_updates2string(enum time_updates value)
+{
+ switch (value) {
+ case TIME_UPDATES_UNKNOWN:
+ break;
+ case TIME_UPDATES_MANUAL:
+ return "manual";
+ case TIME_UPDATES_AUTO:
+ return "auto";
+ }
+
+ return NULL;
+}
+
+static enum time_updates string2time_updates(const char *value)
+{
+ if (g_strcmp0(value, "manual") == 0)
+ return TIME_UPDATES_MANUAL;
+ else if (g_strcmp0(value, "auto") == 0)
+ return TIME_UPDATES_AUTO;
+
+ return TIME_UPDATES_UNKNOWN;
+}
+
+static const char *timezone_updates2string(enum timezone_updates value)
+{
+ switch (value) {
+ case TIMEZONE_UPDATES_UNKNOWN:
+ break;
+ case TIMEZONE_UPDATES_MANUAL:
+ return "manual";
+ case TIMEZONE_UPDATES_AUTO:
+ return "auto";
+ }
+
+ return NULL;
+}
+
+static enum timezone_updates string2timezone_updates(const char *value)
+{
+ if (g_strcmp0(value, "manual") == 0)
+ return TIMEZONE_UPDATES_MANUAL;
+ else if (g_strcmp0(value, "auto") == 0)
+ return TIMEZONE_UPDATES_AUTO;
+
+ return TIMEZONE_UPDATES_UNKNOWN;
+}
+
+static void clock_properties_load(void)
+{
+ GKeyFile *keyfile;
+ char *str, **strl;
+ enum time_updates time_value;
+ enum timezone_updates timezone_value;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ return;
+
+ /* check for global TimeUpdates config first. If NULL, check settings file */
+ strl = connman_setting_get_string_list("TimeUpdates");
+ if ( strl && strl[0] ) {
+ time_value = string2time_updates(strl[0]);
+ if (time_value != TIME_UPDATES_UNKNOWN)
+ time_updates_config = time_value;
+
+ } else {
+ str = g_key_file_get_string(keyfile, "global", "TimeUpdates", NULL);
+
+ time_value = string2time_updates(str);
+ if (time_value != TIME_UPDATES_UNKNOWN)
+ time_updates_config = time_value;
+
+ g_free(str);
+ }
+
+ str = g_key_file_get_string(keyfile, "global", "TimezoneUpdates",
+ NULL);
+
+ timezone_value = string2timezone_updates(str);
+ if (timezone_value != TIMEZONE_UPDATES_UNKNOWN)
+ timezone_updates_config = timezone_value;
+
+ g_free(str);
+
+ g_key_file_free(keyfile);
+}
+
+static void clock_properties_save(void)
+{
+ GKeyFile *keyfile;
+ const char *str;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ keyfile = g_key_file_new();
+
+ str = time_updates2string(time_updates_config);
+ if (str)
+ g_key_file_set_string(keyfile, "global", "TimeUpdates", str);
+ else
+ g_key_file_remove_key(keyfile, "global", "TimeUpdates", NULL);
+
+ str = timezone_updates2string(timezone_updates_config);
+ if (str)
+ g_key_file_set_string(keyfile, "global", "TimezoneUpdates",
+ str);
+ else
+ g_key_file_remove_key(keyfile, "global", "TimezoneUpdates",
+ NULL);
+
+ __connman_storage_save_global(keyfile);
+
+ g_key_file_free(keyfile);
+}
+
+enum time_updates __connman_clock_timeupdates(void)
+{
+ return time_updates_config;
+}
+
+static void append_timeservers(DBusMessageIter *iter, void *user_data)
+{
+ int i;
+ char **timeservers = __connman_timeserver_system_get();
+
+ if (!timeservers)
+ return;
+
+ for (i = 0; timeservers[i]; i++) {
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, ×ervers[i]);
+ }
+
+ g_strfreev(timeservers);
+}
+
+static DBusMessage *get_properties(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ DBusMessageIter array, dict;
+ struct timeval tv;
+ const char *str;
+
+ DBG("conn %p", conn);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &array);
+
+ connman_dbus_dict_open(&array, &dict);
+
+ if (gettimeofday(&tv, NULL) == 0) {
+ dbus_uint64_t val = tv.tv_sec;
+
+ connman_dbus_dict_append_basic(&dict, "Time",
+ DBUS_TYPE_UINT64, &val);
+ }
+
+ str = time_updates2string(time_updates_config);
+ if (str)
+ connman_dbus_dict_append_basic(&dict, "TimeUpdates",
+ DBUS_TYPE_STRING, &str);
+
+ if (timezone_config)
+ connman_dbus_dict_append_basic(&dict, "Timezone",
+ DBUS_TYPE_STRING, &timezone_config);
+
+ str = timezone_updates2string(timezone_updates_config);
+ if (str)
+ connman_dbus_dict_append_basic(&dict, "TimezoneUpdates",
+ DBUS_TYPE_STRING, &str);
+
+ connman_dbus_dict_append_array(&dict, "Timeservers",
+ DBUS_TYPE_STRING, append_timeservers, NULL);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ return reply;
+}
+
+static DBusMessage *set_property(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessageIter iter, value;
+ const char *name;
+ int type;
+
+ DBG("conn %p", conn);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ if (g_str_equal(name, "Time")) {
+ struct timeval tv;
+ dbus_uint64_t newval;
+
+ if (type != DBUS_TYPE_UINT64)
+ return __connman_error_invalid_arguments(msg);
+
+ if (time_updates_config != TIME_UPDATES_MANUAL)
+ return __connman_error_permission_denied(msg);
+
+ dbus_message_iter_get_basic(&value, &newval);
+
+ tv.tv_sec = newval;
+ tv.tv_usec = 0;
+
+ if (settimeofday(&tv, NULL) < 0)
+ return __connman_error_invalid_arguments(msg);
+
+ connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE, "Time",
+ DBUS_TYPE_UINT64, &newval);
+ } else if (g_str_equal(name, "TimeUpdates")) {
+ const char *strval;
+ enum time_updates newval;
+
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &strval);
+ newval = string2time_updates(strval);
+
+ if (newval == TIME_UPDATES_UNKNOWN)
+ return __connman_error_invalid_arguments(msg);
+
+ if (newval == time_updates_config)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ time_updates_config = newval;
+
+ clock_properties_save();
+ connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE, "TimeUpdates",
+ DBUS_TYPE_STRING, &strval);
+ } else if (g_str_equal(name, "Timezone")) {
+ const char *strval;
+
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ if (timezone_updates_config != TIMEZONE_UPDATES_MANUAL)
+ return __connman_error_permission_denied(msg);
+
+ dbus_message_iter_get_basic(&value, &strval);
+
+ if (__connman_timezone_change(strval) < 0)
+ return __connman_error_invalid_arguments(msg);
+ } else if (g_str_equal(name, "TimezoneUpdates")) {
+ const char *strval;
+ enum timezone_updates newval;
+
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &strval);
+ newval = string2timezone_updates(strval);
+
+ if (newval == TIMEZONE_UPDATES_UNKNOWN)
+ return __connman_error_invalid_arguments(msg);
+
+ if (newval == timezone_updates_config)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ timezone_updates_config = newval;
+
+ clock_properties_save();
+ connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE, "TimezoneUpdates",
+ DBUS_TYPE_STRING, &strval);
+ } else if (g_str_equal(name, "Timeservers")) {
+ DBusMessageIter entry;
+ char **str = NULL;
+ GSList *list = NULL;
+ int count = 0;
+
+ if (type != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&value, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *val;
+ GSList *new_head;
+
+ dbus_message_iter_get_basic(&entry, &val);
+
+ new_head = __connman_timeserver_add_list(list, val);
+ if (list != new_head) {
+ count++;
+ list = new_head;
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ if (list) {
+ str = g_new0(char *, count+1);
+
+ while (list) {
+ count--;
+ str[count] = list->data;
+ list = g_slist_delete_link(list, list);
+ };
+ }
+
+ __connman_timeserver_system_set(str);
+
+ if (str)
+ g_strfreev(str);
+
+ connman_dbus_property_changed_array(CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE, "Timeservers",
+ DBUS_TYPE_STRING, append_timeservers, NULL);
+ } else
+ return __connman_error_invalid_property(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable clock_methods[] = {
+ { GDBUS_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ get_properties) },
+ { GDBUS_METHOD("SetProperty",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }), NULL,
+ set_property) },
+ { },
+};
+
+static const GDBusSignalTable clock_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { },
+};
+
+static DBusConnection *connection = NULL;
+
+void __connman_clock_update_timezone(void)
+{
+ DBG("");
+
+ g_free(timezone_config);
+ timezone_config = __connman_timezone_lookup();
+
+ if (!timezone_config)
+ return;
+
+ connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE, "Timezone",
+ DBUS_TYPE_STRING, &timezone_config);
+}
+
+int __connman_clock_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ __connman_timezone_init();
+
+ timezone_config = __connman_timezone_lookup();
+
+ g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE,
+ clock_methods, clock_signals,
+ NULL, NULL, NULL);
+
+ clock_properties_load();
+ return 0;
+}
+
+void __connman_clock_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
+ CONNMAN_CLOCK_INTERFACE);
+
+ dbus_connection_unref(connection);
+
+ __connman_timezone_cleanup();
+
+ g_free(timezone_config);
+}
diff --git a/src/config.c b/src/config.c
new file mode 100644
index 0000000..3a4a08d
--- /dev/null
+++ b/src/config.c
@@ -0,0 +1,1716 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/vfs.h>
+#include <sys/inotify.h>
+#include <netdb.h>
+#include <glib.h>
+
+#include <connman/provision.h>
+#include <connman/ipaddress.h>
+#include "connman.h"
+
+struct connman_config_service {
+ char *ident;
+ char *name;
+ char *type;
+ void *ssid;
+ unsigned int ssid_len;
+ char *eap;
+ char *identity;
+ char *ca_cert_file;
+ char *client_cert_file;
+ char *private_key_file;
+ char *private_key_passphrase;
+ char *private_key_passphrase_type;
+ char *phase2;
+ char *passphrase;
+ enum connman_service_security security;
+ GSList *service_identifiers;
+ uint64_t xpan_id;
+ char *config_ident; /* file prefix */
+ char *config_entry; /* entry name */
+ bool hidden;
+ bool virtual;
+ char *virtual_file;
+ char *ipv4_address;
+ char *ipv4_netmask;
+ char *ipv4_gateway;
+ char *ipv6_address;
+ unsigned char ipv6_prefix_length;
+ char *ipv6_gateway;
+ char *ipv6_privacy;
+ char *mac;
+ char **nameservers;
+ char **search_domains;
+ char **timeservers;
+ char *domain_name;
+};
+
+struct connman_config {
+ char *ident;
+ char *name;
+ char *description;
+ GHashTable *service_table;
+};
+
+static GHashTable *config_table = NULL;
+
+static bool cleanup = false;
+
+/* Definition of possible strings in the .config files */
+#define CONFIG_KEY_NAME "Name"
+#define CONFIG_KEY_DESC "Description"
+
+#define SERVICE_KEY_TYPE "Type"
+#define SERVICE_KEY_NAME "Name"
+#define SERVICE_KEY_SSID "SSID"
+#define SERVICE_KEY_EAP "EAP"
+#define SERVICE_KEY_CA_CERT "CACertFile"
+#define SERVICE_KEY_CL_CERT "ClientCertFile"
+#define SERVICE_KEY_PRV_KEY "PrivateKeyFile"
+#define SERVICE_KEY_PRV_KEY_PASS "PrivateKeyPassphrase"
+#define SERVICE_KEY_PRV_KEY_PASS_TYPE "PrivateKeyPassphraseType"
+#define SERVICE_KEY_IDENTITY "Identity"
+#define SERVICE_KEY_PHASE2 "Phase2"
+#define SERVICE_KEY_PASSPHRASE "Passphrase"
+#define SERVICE_KEY_SECURITY "Security"
+#define SERVICE_KEY_HIDDEN "Hidden"
+
+#define SERVICE_KEY_IPv4 "IPv4"
+#define SERVICE_KEY_IPv6 "IPv6"
+#define SERVICE_KEY_IPv6_PRIVACY "IPv6.Privacy"
+#define SERVICE_KEY_MAC "MAC"
+#define SERVICE_KEY_NAMESERVERS "Nameservers"
+#define SERVICE_KEY_SEARCH_DOMAINS "SearchDomains"
+#define SERVICE_KEY_TIMESERVERS "Timeservers"
+#define SERVICE_KEY_DOMAIN "Domain"
+
+#define SERVICE_KEY_EXTENDED_PAN_ID "ExtendedPANID"
+
+#define MONITOR_CONFIG_DIR
+
+static const char *config_possible_keys[] = {
+ CONFIG_KEY_NAME,
+ CONFIG_KEY_DESC,
+ NULL,
+};
+
+static const char *service_possible_keys[] = {
+ SERVICE_KEY_TYPE,
+ SERVICE_KEY_NAME,
+ SERVICE_KEY_SSID,
+ SERVICE_KEY_EAP,
+ SERVICE_KEY_CA_CERT,
+ SERVICE_KEY_CL_CERT,
+ SERVICE_KEY_PRV_KEY,
+ SERVICE_KEY_PRV_KEY_PASS,
+ SERVICE_KEY_PRV_KEY_PASS_TYPE,
+ SERVICE_KEY_IDENTITY,
+ SERVICE_KEY_PHASE2,
+ SERVICE_KEY_PASSPHRASE,
+ SERVICE_KEY_SECURITY,
+ SERVICE_KEY_HIDDEN,
+ SERVICE_KEY_IPv4,
+ SERVICE_KEY_IPv6,
+ SERVICE_KEY_IPv6_PRIVACY,
+ SERVICE_KEY_MAC,
+ SERVICE_KEY_NAMESERVERS,
+ SERVICE_KEY_SEARCH_DOMAINS,
+ SERVICE_KEY_TIMESERVERS,
+ SERVICE_KEY_DOMAIN,
+ SERVICE_KEY_EXTENDED_PAN_ID,
+ NULL,
+};
+
+static void unregister_config(gpointer data)
+{
+ struct connman_config *config = data;
+
+ connman_info("Removing configuration %s", config->ident);
+
+ g_hash_table_destroy(config->service_table);
+
+ g_free(config->description);
+ g_free(config->name);
+ g_free(config->ident);
+ g_free(config);
+}
+
+static void unregister_service(gpointer data)
+{
+ struct connman_config_service *config_service = data;
+ struct connman_service *service;
+ struct connman_network *network;
+ char *service_id;
+ GSList *list;
+
+ if (cleanup)
+ goto free_only;
+
+ connman_info("Removing service configuration %s",
+ config_service->ident);
+
+ if (config_service->virtual)
+ goto free_only;
+
+ for (list = config_service->service_identifiers; list;
+ list = list->next) {
+ service_id = list->data;
+
+ service = __connman_service_lookup_from_ident(service_id);
+ if (service) {
+ enum connman_service_type service_type = connman_service_get_type(service);
+
+ /* Do not remove 6lowpan & wifi services
+ */
+ if ((service_type == CONNMAN_SERVICE_TYPE_LOWPAN) ||
+ (service_type == CONNMAN_SERVICE_TYPE_WIFI)) {
+ continue;
+ }
+
+ __connman_service_set_immutable(service, false);
+ __connman_service_set_config(service, NULL, NULL);
+ __connman_service_remove(service);
+ /*
+ * When the provisioned service is being deleted
+ * network object should forget the passphrase.
+ */
+ network = __connman_service_get_network(service);
+ if (network) {
+ connman_network_set_string(network,
+ "WiFi.Passphrase", NULL);
+ }
+ /*
+ * Ethernet or gadget service cannot be removed by
+ * __connman_service_remove() so reset the ipconfig
+ * here.
+ */
+ if (connman_service_get_type(service) ==
+ CONNMAN_SERVICE_TYPE_ETHERNET ||
+ connman_service_get_type(service) ==
+ CONNMAN_SERVICE_TYPE_GADGET) {
+ __connman_service_disconnect(service);
+ __connman_service_reset_ipconfig(service,
+ CONNMAN_IPCONFIG_TYPE_IPV4, NULL, NULL);
+ __connman_service_reset_ipconfig(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6, NULL, NULL);
+ __connman_service_set_ignore(service, true);
+
+ /*
+ * After these operations, user needs to
+ * reconnect ethernet cable to get IP
+ * address.
+ */
+ }
+ }
+
+ if (!__connman_storage_remove_service(service_id))
+ DBG("Could not remove all files for service %s",
+ service_id);
+ }
+
+free_only:
+ g_free(config_service->ident);
+ g_free(config_service->type);
+ g_free(config_service->name);
+ g_free(config_service->ssid);
+ g_free(config_service->eap);
+ g_free(config_service->identity);
+ g_free(config_service->ca_cert_file);
+ g_free(config_service->client_cert_file);
+ g_free(config_service->private_key_file);
+ g_free(config_service->private_key_passphrase);
+ g_free(config_service->private_key_passphrase_type);
+ g_free(config_service->phase2);
+ g_free(config_service->passphrase);
+ g_free(config_service->ipv4_address);
+ g_free(config_service->ipv4_gateway);
+ g_free(config_service->ipv4_netmask);
+ g_free(config_service->ipv6_address);
+ g_free(config_service->ipv6_gateway);
+ g_free(config_service->ipv6_privacy);
+ g_free(config_service->mac);
+ g_strfreev(config_service->nameservers);
+ g_strfreev(config_service->search_domains);
+ g_strfreev(config_service->timeservers);
+ g_free(config_service->domain_name);
+ g_slist_free_full(config_service->service_identifiers, g_free);
+ g_free(config_service->config_ident);
+ g_free(config_service->config_entry);
+ g_free(config_service->virtual_file);
+ g_free(config_service);
+}
+
+static void check_keys(GKeyFile *keyfile, const char *group,
+ const char **possible_keys)
+{
+ char **avail_keys;
+ gsize nb_avail_keys, i, j;
+
+ avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
+ if (!avail_keys)
+ return;
+
+ /*
+ * For each key in the configuration file,
+ * verify it is understood by connman
+ */
+ for (i = 0 ; i < nb_avail_keys; i++) {
+ for (j = 0; possible_keys[j] ; j++)
+ if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
+ break;
+
+ if (!possible_keys[j])
+ connman_warn("Unknown configuration key %s in [%s]",
+ avail_keys[i], group);
+ }
+
+ g_strfreev(avail_keys);
+}
+
+static int check_family(const char *address, int expected_family)
+{
+ int family;
+ int err = 0;
+
+ family = connman_inet_check_ipaddress(address);
+ if (family < 0) {
+ DBG("Cannot get address family of %s (%d/%s)", address,
+ family, gai_strerror(family));
+ err = -EINVAL;
+ goto out;
+ }
+
+ switch (family) {
+ case AF_INET:
+ if (expected_family != AF_INET) {
+ DBG("Wrong type address %s, expecting IPv4", address);
+ err = -EINVAL;
+ goto out;
+ }
+ break;
+ case AF_INET6:
+ if (expected_family != AF_INET6) {
+ DBG("Wrong type address %s, expecting IPv6", address);
+ err = -EINVAL;
+ goto out;
+ }
+ break;
+ default:
+ DBG("Unsupported address family %d", family);
+ err = -EINVAL;
+ goto out;
+ }
+
+out:
+ return err;
+}
+
+static int parse_address(const char *address_str, int address_family,
+ char **address, char **netmask, char **gateway)
+{
+ char *addr_str, *mask_str, *gw_str;
+ int err = 0;
+ char **route;
+
+ route = g_strsplit(address_str, "/", 0);
+ if (!route)
+ return -EINVAL;
+
+ addr_str = route[0];
+ if (!addr_str || addr_str[0] == '\0') {
+ err = -EINVAL;
+ goto out;
+ }
+
+ if ((err = check_family(addr_str, address_family)) < 0)
+ goto out;
+
+ mask_str = route[1];
+ if (!mask_str || mask_str[0] == '\0') {
+ err = -EINVAL;
+ goto out;
+ }
+
+ gw_str = route[2];
+ if (gw_str && gw_str[0]) {
+ if ((err = check_family(gw_str, address_family)) < 0)
+ goto out;
+ }
+
+ g_free(*address);
+ *address = g_strdup(addr_str);
+
+ g_free(*netmask);
+ *netmask = g_strdup(mask_str);
+
+ g_free(*gateway);
+ *gateway = g_strdup(gw_str);
+
+ if (*gateway)
+ DBG("address %s/%s via %s", *address, *netmask, *gateway);
+ else
+ DBG("address %s/%s", *address, *netmask);
+
+out:
+ g_strfreev(route);
+
+ return err;
+}
+
+static bool check_address(char *address_str, char **address)
+{
+ if (g_ascii_strcasecmp(address_str, "auto") == 0 ||
+ g_ascii_strcasecmp(address_str, "dhcp") == 0 ||
+ g_ascii_strcasecmp(address_str, "off") == 0) {
+ *address = address_str;
+ return false;
+ }
+
+ return true;
+}
+
+static bool load_service_generic(GKeyFile *keyfile,
+ const char *group, struct connman_config *config,
+ struct connman_config_service *service)
+{
+ char *str, *mask;
+ char **strlist;
+ gsize length;
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv4, NULL);
+ if (str && check_address(str, &service->ipv4_address)) {
+ mask = NULL;
+
+ if (parse_address(str, AF_INET, &service->ipv4_address,
+ &mask, &service->ipv4_gateway) < 0) {
+ connman_warn("Invalid format for IPv4 address %s",
+ str);
+ g_free(str);
+ goto err;
+ }
+
+ if (!g_strrstr(mask, ".")) {
+ /* We have netmask length */
+ in_addr_t addr;
+ struct in_addr netmask_in;
+ unsigned char prefix_len = 32;
+ char *ptr;
+ long int value = strtol(mask, &ptr, 10);
+
+ if (ptr != mask && *ptr == '\0' && value && value <= 32)
+ prefix_len = value;
+
+ addr = 0xffffffff << (32 - prefix_len);
+ netmask_in.s_addr = htonl(addr);
+ service->ipv4_netmask =
+ g_strdup(inet_ntoa(netmask_in));
+
+ g_free(mask);
+ } else
+ service->ipv4_netmask = mask;
+
+ g_free(str);
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv6, NULL);
+ if (str && check_address(str, &service->ipv6_address)) {
+ long int value;
+ char *ptr;
+
+ mask = NULL;
+
+ if (parse_address(str, AF_INET6, &service->ipv6_address,
+ &mask, &service->ipv6_gateway) < 0) {
+ connman_warn("Invalid format for IPv6 address %s",
+ str);
+ g_free(str);
+ goto err;
+ }
+
+ value = strtol(mask, &ptr, 10);
+ if (ptr != mask && *ptr == '\0' && value <= 128)
+ service->ipv6_prefix_length = value;
+ else
+ service->ipv6_prefix_length = 128;
+
+ g_free(mask);
+ g_free(str);
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IPv6_PRIVACY,
+ NULL);
+ if (str) {
+ g_free(service->ipv6_privacy);
+ service->ipv6_privacy = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_MAC, NULL);
+ if (str) {
+ g_free(service->mac);
+ service->mac = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_DOMAIN, NULL);
+ if (str) {
+ g_free(service->domain_name);
+ service->domain_name = str;
+ }
+
+ strlist = __connman_config_get_string_list(keyfile, group,
+ SERVICE_KEY_NAMESERVERS,
+ &length, NULL);
+ if (strlist) {
+ if (length != 0) {
+ g_strfreev(service->nameservers);
+ service->nameservers = strlist;
+ } else
+ g_strfreev(strlist);
+ }
+
+ strlist = __connman_config_get_string_list(keyfile, group,
+ SERVICE_KEY_SEARCH_DOMAINS,
+ &length, NULL);
+ if (strlist) {
+ if (length != 0) {
+ g_strfreev(service->search_domains);
+ service->search_domains = strlist;
+ } else
+ g_strfreev(strlist);
+ }
+
+ strlist = __connman_config_get_string_list(keyfile, group,
+ SERVICE_KEY_TIMESERVERS,
+ &length, NULL);
+ if (strlist) {
+ if (length != 0) {
+ g_strfreev(service->timeservers);
+ service->timeservers = strlist;
+ } else
+ g_strfreev(strlist);
+ }
+
+ return true;
+
+err:
+ g_free(service->ident);
+ g_free(service->type);
+ g_free(service->ipv4_address);
+ g_free(service->ipv4_netmask);
+ g_free(service->ipv4_gateway);
+ g_free(service->ipv6_address);
+ g_free(service->ipv6_gateway);
+ g_free(service->mac);
+ g_free(service);
+
+ return false;
+}
+
+static bool load_service(GKeyFile *keyfile, const char *group,
+ struct connman_config *config)
+{
+ struct connman_config_service *service;
+ const char *ident;
+ char *str, *hex_ssid;
+ enum connman_service_security security;
+ bool service_created = false;
+
+ /* Strip off "service_" prefix */
+ ident = group + 8;
+
+ if (strlen(ident) < 1)
+ return false;
+
+ /* Verify that provided keys are good */
+ check_keys(keyfile, group, service_possible_keys);
+
+ service = g_hash_table_lookup(config->service_table, ident);
+ if (!service) {
+ service = g_try_new0(struct connman_config_service, 1);
+ if (!service)
+ return false;
+
+ service->ident = g_strdup(ident);
+
+ service_created = true;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_TYPE, NULL);
+ if (str) {
+ g_free(service->type);
+ service->type = str;
+ } else {
+ DBG("Type of the configured service is missing for group %s",
+ group);
+ goto err;
+ }
+
+ if (!load_service_generic(keyfile, group, config, service))
+ return false;
+
+ if (g_strcmp0(str, "ethernet") == 0) {
+ service->config_ident = g_strdup(config->ident);
+ service->config_entry = g_strdup_printf("service_%s",
+ service->ident);
+
+ g_hash_table_insert(config->service_table, service->ident,
+ service);
+ return true;
+ }
+ else if (g_strcmp0(str, "lowpan") == 0) {
+ service->xpan_id = (uint64_t)g_key_file_get_uint64(keyfile, group, SERVICE_KEY_EXTENDED_PAN_ID, NULL);
+
+ // allow join, psk index and role are ignored for now.
+ // name, security and passphrase will be parsed later.
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_NAME, NULL);
+ if (str) {
+ g_free(service->name);
+ service->name = str;
+ }
+ else
+ {
+ if (g_strcmp0(service->type, "lowpan") == 0) {
+ connman_warn("Name is missing for lowpan provision");
+ goto err;
+ }
+ }
+
+ hex_ssid = __connman_config_get_string(keyfile, group, SERVICE_KEY_SSID,
+ NULL);
+ if (hex_ssid) {
+ char *ssid;
+ unsigned int i, j = 0, hex;
+ size_t hex_ssid_len = strlen(hex_ssid);
+
+ ssid = g_try_malloc0(hex_ssid_len / 2);
+ if (!ssid) {
+ g_free(hex_ssid);
+ goto err;
+ }
+
+ for (i = 0; i < hex_ssid_len; i += 2) {
+ if (sscanf(hex_ssid + i, "%02x", &hex) <= 0) {
+ connman_warn("Invalid SSID %s", hex_ssid);
+ g_free(ssid);
+ g_free(hex_ssid);
+ goto err;
+ }
+ ssid[j++] = hex;
+ }
+
+ g_free(hex_ssid);
+
+ g_free(service->ssid);
+ service->ssid = ssid;
+ service->ssid_len = hex_ssid_len / 2;
+ } else if (service->name && g_strcmp0(service->type, "wifi") == 0) {
+ char *ssid;
+ unsigned int ssid_len;
+
+ ssid_len = strlen(service->name);
+ ssid = g_try_malloc0(ssid_len);
+ if (!ssid)
+ goto err;
+
+ memcpy(ssid, service->name, ssid_len);
+ g_free(service->ssid);
+ service->ssid = ssid;
+ service->ssid_len = ssid_len;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_EAP, NULL);
+ if (str) {
+ g_free(service->eap);
+ service->eap = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CA_CERT, NULL);
+ if (str) {
+ g_free(service->ca_cert_file);
+ service->ca_cert_file = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_CL_CERT, NULL);
+ if (str) {
+ g_free(service->client_cert_file);
+ service->client_cert_file = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PRV_KEY, NULL);
+ if (str) {
+ g_free(service->private_key_file);
+ service->private_key_file = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group,
+ SERVICE_KEY_PRV_KEY_PASS, NULL);
+ if (str) {
+ g_free(service->private_key_passphrase);
+ service->private_key_passphrase = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group,
+ SERVICE_KEY_PRV_KEY_PASS_TYPE, NULL);
+ if (str) {
+ g_free(service->private_key_passphrase_type);
+ service->private_key_passphrase_type = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_IDENTITY, NULL);
+ if (str) {
+ g_free(service->identity);
+ service->identity = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PHASE2, NULL);
+ if (str) {
+ g_free(service->phase2);
+ service->phase2 = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_PASSPHRASE,
+ NULL);
+ if (str) {
+ g_free(service->passphrase);
+ service->passphrase = str;
+ }
+
+ str = __connman_config_get_string(keyfile, group, SERVICE_KEY_SECURITY,
+ NULL);
+ security = __connman_service_string2security(str);
+
+ if (service->eap) {
+
+ if (str && security != CONNMAN_SERVICE_SECURITY_8021X)
+ connman_info("Mismatch between EAP configuration and "
+ "setting %s = %s",
+ SERVICE_KEY_SECURITY, str);
+
+ service->security = CONNMAN_SERVICE_SECURITY_8021X;
+
+ } else if (service->passphrase) {
+
+ if (str) {
+ if (security == CONNMAN_SERVICE_SECURITY_PSK ||
+ security == CONNMAN_SERVICE_SECURITY_WEP) {
+ service->security = security;
+ } else {
+ connman_info("Mismatch with passphrase and "
+ "setting %s = %s",
+ SERVICE_KEY_SECURITY, str);
+
+ service->security =
+ CONNMAN_SERVICE_SECURITY_PSK;
+ }
+
+ } else
+ service->security = CONNMAN_SERVICE_SECURITY_PSK;
+ } else if (str) {
+
+ if (security != CONNMAN_SERVICE_SECURITY_NONE)
+ connman_info("Mismatch no security and "
+ "setting %s = %s",
+ SERVICE_KEY_SECURITY, str);
+
+ service->security = CONNMAN_SERVICE_SECURITY_NONE;
+ } else
+ service->security = CONNMAN_SERVICE_SECURITY_NONE;
+
+ service->config_ident = g_strdup(config->ident);
+ service->config_entry = g_strdup_printf("service_%s", service->ident);
+
+ if (g_strcmp0(service->type, "wifi") == 0)
+ service->hidden = __connman_config_get_bool(keyfile, group,
+ SERVICE_KEY_HIDDEN, NULL);
+
+ if (service_created)
+ g_hash_table_insert(config->service_table, service->ident,
+ service);
+
+ connman_info("Adding service configuration %s", service->ident);
+
+ return true;
+
+err:
+ if (service_created) {
+ g_free(service->ident);
+ g_free(service->type);
+ g_free(service->name);
+ g_free(service->ssid);
+ g_free(service);
+ }
+
+ return false;
+}
+
+static bool load_service_from_keyfile(GKeyFile *keyfile,
+ struct connman_config *config)
+{
+ bool found = false;
+ char **groups;
+ int i;
+
+ groups = g_key_file_get_groups(keyfile, NULL);
+
+ for (i = 0; groups[i]; i++) {
+ if (!g_str_has_prefix(groups[i], "service_"))
+ continue;
+ if (load_service(keyfile, groups[i], config))
+ found = true;
+ }
+
+ g_strfreev(groups);
+
+ return found;
+}
+
+static int load_config(struct connman_config *config)
+{
+ GKeyFile *keyfile;
+ char *str;
+
+ DBG("config %p", config);
+
+ keyfile = __connman_storage_load_config(config->ident);
+ if (!keyfile)
+ return -EIO;
+
+ g_key_file_set_list_separator(keyfile, ',');
+
+ /* Verify keys validity of the global section */
+ check_keys(keyfile, "global", config_possible_keys);
+
+ str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
+ if (str) {
+ g_free(config->name);
+ config->name = str;
+ }
+
+ str = __connman_config_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
+ if (str) {
+ g_free(config->description);
+ config->description = str;
+ }
+
+ if (!load_service_from_keyfile(keyfile, config))
+ connman_warn("Config file %s/%s.config does not contain any "
+ "configuration that can be provisioned!",
+ STORAGEDIR, config->ident);
+
+ g_key_file_free(keyfile);
+
+ return 0;
+}
+
+static struct connman_config *create_config(const char *ident)
+{
+ struct connman_config *config;
+
+ DBG("ident %s", ident);
+
+ if (g_hash_table_lookup(config_table, ident))
+ return NULL;
+
+ config = g_try_new0(struct connman_config, 1);
+ if (!config)
+ return NULL;
+
+ config->ident = g_strdup(ident);
+
+ config->service_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, unregister_service);
+
+ g_hash_table_insert(config_table, config->ident, config);
+
+ connman_info("Adding configuration %s", config->ident);
+
+ return config;
+}
+
+static bool validate_ident(const char *ident)
+{
+ unsigned int i;
+
+ if (!ident)
+ return false;
+
+ for (i = 0; i < strlen(ident); i++)
+ if (!g_ascii_isprint(ident[i]))
+ return false;
+
+ return true;
+}
+
+static int read_configs(void)
+{
+ GDir *dir;
+
+ DBG("");
+
+ dir = g_dir_open(STORAGEDIR, 0, NULL);
+ if (dir) {
+ const gchar *file;
+
+ while ((file = g_dir_read_name(dir))) {
+ GString *str;
+ gchar *ident;
+
+ if (!g_str_has_suffix(file, ".config"))
+ continue;
+
+ ident = g_strrstr(file, ".config");
+ if (!ident)
+ continue;
+
+ str = g_string_new_len(file, ident - file);
+ if (!str)
+ continue;
+
+ ident = g_string_free(str, FALSE);
+
+ if (validate_ident(ident)) {
+ struct connman_config *config;
+
+ config = create_config(ident);
+ if (config)
+ load_config(config);
+ } else {
+ connman_error("Invalid config ident %s", ident);
+ }
+ g_free(ident);
+ }
+
+ g_dir_close(dir);
+ }
+
+ return 0;
+}
+
+static void config_notify_handler(struct inotify_event *event,
+ const char *ident)
+{
+ char *ext;
+
+ if (!ident)
+ return;
+
+ if (!g_str_has_suffix(ident, ".config"))
+ return;
+
+ ext = g_strrstr(ident, ".config");
+ if (!ext)
+ return;
+
+ *ext = '\0';
+
+ if (!validate_ident(ident)) {
+ connman_error("Invalid config ident %s", ident);
+ return;
+ }
+
+ if (event->mask & (IN_CREATE | IN_MOVED_TO))
+ create_config(ident);
+
+ if (event->mask & (IN_MODIFY | IN_MOVED_TO)) {
+ struct connman_config *config;
+
+ config = g_hash_table_lookup(config_table, ident);
+ if (config) {
+ int ret;
+
+ g_hash_table_remove_all(config->service_table);
+ load_config(config);
+ ret = __connman_service_provision_changed(ident);
+ if (ret > 0) {
+ /*
+ * Re-scan the config file for any
+ * changes
+ */
+ g_hash_table_remove_all(config->service_table);
+ load_config(config);
+ __connman_service_provision_changed(ident);
+ }
+ }
+ }
+
+ if (event->mask & (IN_DELETE | IN_MOVED_FROM))
+ g_hash_table_remove(config_table, ident);
+}
+
+int __connman_config_init(void)
+{
+ DBG("");
+
+ config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, unregister_config);
+
+#ifdef MONITOR_CONFIG_DIR
+ connman_inotify_register(STORAGEDIR, config_notify_handler);
+#endif
+
+ return read_configs();
+}
+
+void __connman_config_cleanup(void)
+{
+ DBG("");
+
+ cleanup = true;
+
+#ifdef MONITOR_CONFIG_DIR
+ connman_inotify_unregister(STORAGEDIR, config_notify_handler);
+#endif
+
+ g_hash_table_destroy(config_table);
+ config_table = NULL;
+
+ cleanup = false;
+}
+
+char *__connman_config_get_string(GKeyFile *key_file,
+ const char *group_name, const char *key, GError **error)
+{
+ char *str = g_key_file_get_string(key_file, group_name, key, error);
+ if (!str)
+ return NULL;
+
+ /*
+ * Passphrase can have space anywhere in the string
+ * read out of example.config. If passphrase in example.config
+ * has \s (space) as the last character, it will be truncated and
+ * in the resulting service directory we will have wrong passphrase
+ * resulting in 4 way hand shake failure.
+ */
+ if (g_strcmp0(key, SERVICE_KEY_PASSPHRASE) == 0)
+ {
+ return str;
+ }
+
+ return g_strchomp(str);
+}
+
+char **__connman_config_get_string_list(GKeyFile *key_file,
+ const char *group_name, const char *key, gsize *length, GError **error)
+{
+ char **p;
+ char **strlist = g_key_file_get_string_list(key_file, group_name, key,
+ length, error);
+ if (!strlist)
+ return NULL;
+
+ p = strlist;
+ while (*p) {
+ *p = g_strstrip(*p);
+ p++;
+ }
+
+ return strlist;
+}
+
+bool __connman_config_get_bool(GKeyFile *key_file,
+ const char *group_name, const char *key, GError **error)
+{
+ char *valstr;
+ bool val = false;
+
+ valstr = g_key_file_get_value(key_file, group_name, key, error);
+ if (!valstr)
+ return false;
+
+ valstr = g_strchomp(valstr);
+ if (strcmp(valstr, "true") == 0 || strcmp(valstr, "1") == 0)
+ val = true;
+
+ g_free(valstr);
+
+ return val;
+}
+
+static char *config_pem_fsid(const char *pem_file)
+{
+ struct statfs buf;
+ unsigned *fsid = (unsigned *) &buf.f_fsid;
+ unsigned long long fsid64;
+
+ if (!pem_file)
+ return NULL;
+
+ if (statfs(pem_file, &buf) < 0) {
+ connman_error("statfs error %s for %s",
+ strerror(errno), pem_file);
+ return NULL;
+ }
+
+ fsid64 = ((unsigned long long) fsid[0] << 32) | fsid[1];
+
+ return g_strdup_printf("%llx", fsid64);
+}
+
+static void provision_service_wifi(struct connman_config_service *config,
+ struct connman_service *service,
+ struct connman_network *network,
+ const void *ssid, unsigned int ssid_len)
+{
+ if (config->eap)
+ __connman_service_set_string(service, "EAP", config->eap);
+
+ if (config->identity)
+ __connman_service_set_string(service, "Identity",
+ config->identity);
+
+ if (config->ca_cert_file)
+ __connman_service_set_string(service, "CACertFile",
+ config->ca_cert_file);
+
+ if (config->client_cert_file)
+ __connman_service_set_string(service, "ClientCertFile",
+ config->client_cert_file);
+
+ if (config->private_key_file)
+ __connman_service_set_string(service, "PrivateKeyFile",
+ config->private_key_file);
+
+ if (g_strcmp0(config->private_key_passphrase_type, "fsid") == 0 &&
+ config->private_key_file) {
+ char *fsid;
+
+ fsid = config_pem_fsid(config->private_key_file);
+ if (!fsid)
+ return;
+
+ g_free(config->private_key_passphrase);
+ config->private_key_passphrase = fsid;
+ }
+
+ if (config->private_key_passphrase) {
+ __connman_service_set_string(service, "PrivateKeyPassphrase",
+ config->private_key_passphrase);
+ /*
+ * TODO: Support for PEAP with both identity and key passwd.
+ * In that case, we should check if both of them are found
+ * from the config file. If not, we should not set the
+ * service passphrase in order for the UI to request for an
+ * additional passphrase.
+ */
+ }
+
+ if (config->phase2)
+ __connman_service_set_string(service, "Phase2", config->phase2);
+
+ if (config->passphrase)
+ __connman_service_set_string(service, "Passphrase",
+ config->passphrase);
+
+ if (config->hidden)
+ __connman_service_set_hidden(service);
+}
+
+static void provision_service_lowpan(struct connman_config_service *config,
+ struct connman_service *service,
+ struct connman_network *network)
+{
+ if (config->passphrase) {
+ DBG("provision_service_lowpan, load passphrase");
+ __connman_service_set_string(service, "Passphrase", config->passphrase);
+ }
+}
+
+struct connect_virtual {
+ struct connman_service *service;
+ const char *vfile;
+};
+
+static gboolean remove_virtual_config(gpointer user_data)
+{
+ struct connect_virtual *virtual = user_data;
+
+ __connman_service_connect(virtual->service,
+ CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+ g_hash_table_remove(config_table, virtual->vfile);
+
+ g_free(virtual);
+
+ return FALSE;
+}
+
+static int try_provision_service(struct connman_config_service *config,
+ struct connman_service *service)
+{
+ struct connman_network *network;
+ const void *service_id;
+ enum connman_service_type type;
+ const void *ssid;
+ unsigned int ssid_len;
+ const char *str;
+ uint64_t xpan_id;
+
+ network = __connman_service_get_network(service);
+ if (!network) {
+ connman_error("Service has no network set");
+ return -EINVAL;
+ }
+
+ DBG("network %p ident %s", network,
+ connman_network_get_identifier(network));
+
+ type = connman_service_get_type(service);
+
+ switch(type) {
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ if (__connman_service_string2type(config->type) != type)
+ return -ENOENT;
+
+ ssid = connman_network_get_blob(network, "WiFi.SSID",
+ &ssid_len);
+ if (!ssid) {
+ connman_error("Network SSID not set");
+ return -EINVAL;
+ }
+
+ if (!config->ssid || ssid_len != config->ssid_len)
+ return -ENOENT;
+
+ if (memcmp(config->ssid, ssid, ssid_len))
+ return -ENOENT;
+
+ str = connman_network_get_string(network, "WiFi.Security");
+ if (config->security != __connman_service_string2security(str))
+ return -ENOENT;
+
+ break;
+
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+
+ if (__connman_service_string2type(config->type) != type)
+ return -ENOENT;
+ break;
+
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ if (__connman_service_string2type(config->type) != type)
+ return -ENOENT;
+
+ str = connman_network_get_string(network, "Name");
+ if (!str || memcmp(str, config->name, strlen(config->name)))
+ return -ENOENT;
+
+ xpan_id = connman_network_get_lowpan_xpan_id(network);
+ if (xpan_id != config->xpan_id)
+ return -ENOENT;
+
+ str = connman_network_get_string(network, "WiFi.Security");
+ if (config->security != CONNMAN_SERVICE_SECURITY_NONE
+ && config->security != __connman_service_string2security(str))
+ return -ENOENT;
+
+ break;
+
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_P2P:
+
+ return -ENOENT;
+ }
+
+ connman_info("try_provision_service(): service %p ident %s", service,
+ __connman_service_get_ident(service));
+
+ if (config->mac) {
+ struct connman_device *device;
+ const char *device_addr;
+
+ device = connman_network_get_device(network);
+ if (!device) {
+ connman_error("Network device is missing");
+ return -ENODEV;
+ }
+
+ device_addr = connman_device_get_string(device, "Address");
+
+ DBG("wants %s has %s", config->mac, device_addr);
+
+ if (g_ascii_strcasecmp(device_addr, config->mac) != 0)
+ return -ENOENT;
+ }
+
+ if (!config->ipv6_address) {
+ connman_network_set_ipv6_method(network,
+ CONNMAN_IPCONFIG_METHOD_AUTO);
+ } else if (g_ascii_strcasecmp(config->ipv6_address, "off") == 0) {
+ connman_network_set_ipv6_method(network,
+ CONNMAN_IPCONFIG_METHOD_OFF);
+ } else if (g_ascii_strcasecmp(config->ipv6_address, "auto") == 0 ||
+ g_ascii_strcasecmp(config->ipv6_address, "dhcp") == 0) {
+ connman_network_set_ipv6_method(network,
+ CONNMAN_IPCONFIG_METHOD_AUTO);
+ } else {
+ struct connman_ipaddress *address;
+
+ if (config->ipv6_prefix_length == 0) {
+ DBG("IPv6 prefix missing");
+ return -EINVAL;
+ }
+
+ address = connman_ipaddress_alloc(AF_INET6);
+ if (!address)
+ return -ENOENT;
+
+ connman_ipaddress_set_ipv6(address, config->ipv6_address,
+ config->ipv6_prefix_length,
+ config->ipv6_gateway);
+
+ connman_network_set_ipv6_method(network,
+ CONNMAN_IPCONFIG_METHOD_FIXED);
+
+ if (connman_network_set_ipaddress(network, address) < 0)
+ DBG("Unable to set IPv6 address to network %p",
+ network);
+
+ connman_ipaddress_free(address);
+ }
+
+ if (config->ipv6_privacy) {
+ struct connman_ipconfig *ipconfig;
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (ipconfig)
+ __connman_ipconfig_ipv6_set_privacy(ipconfig,
+ config->ipv6_privacy);
+ }
+
+ if (!config->ipv4_address) {
+ connman_network_set_ipv4_method(network,
+ CONNMAN_IPCONFIG_METHOD_DHCP);
+ } else if (g_ascii_strcasecmp(config->ipv4_address, "off") == 0) {
+ connman_network_set_ipv4_method(network,
+ CONNMAN_IPCONFIG_METHOD_OFF);
+ } else if (g_ascii_strcasecmp(config->ipv4_address, "auto") == 0 ||
+ g_ascii_strcasecmp(config->ipv4_address, "dhcp") == 0) {
+ connman_network_set_ipv4_method(network,
+ CONNMAN_IPCONFIG_METHOD_DHCP);
+ } else {
+ struct connman_ipaddress *address;
+
+ if (!config->ipv4_netmask) {
+ DBG("IPv4 netmask missing");
+ return -EINVAL;
+ }
+
+ address = connman_ipaddress_alloc(AF_INET);
+ if (!address)
+ return -ENOENT;
+
+ connman_ipaddress_set_ipv4(address, config->ipv4_address,
+ config->ipv4_netmask,
+ config->ipv4_gateway);
+
+ connman_network_set_ipv4_method(network,
+ CONNMAN_IPCONFIG_METHOD_FIXED);
+
+ if (connman_network_set_ipaddress(network, address) < 0)
+ DBG("Unable to set IPv4 address to network %p",
+ network);
+
+ connman_ipaddress_free(address);
+ }
+
+
+ if (type != CONNMAN_SERVICE_TYPE_WIFI &&
+ type != CONNMAN_SERVICE_TYPE_LOWPAN)
+ __connman_service_disconnect(service);
+
+ service_id = __connman_service_get_ident(service);
+ config->service_identifiers =
+ g_slist_prepend(config->service_identifiers,
+ g_strdup(service_id));
+
+ __connman_service_set_favorite_delayed(service, true, true);
+
+ __connman_service_set_config(service, config->config_ident,
+ config->config_entry);
+
+ if (config->domain_name)
+ __connman_service_set_domainname(service, config->domain_name);
+
+ if (config->nameservers) {
+ int i;
+
+ __connman_service_nameserver_clear(service);
+
+ for (i = 0; config->nameservers[i]; i++) {
+ __connman_service_nameserver_append(service,
+ config->nameservers[i], false);
+ }
+ }
+
+ if (config->search_domains)
+ __connman_service_set_search_domains(service,
+ config->search_domains);
+
+ if (config->timeservers)
+ __connman_service_set_timeservers(service,
+ config->timeservers);
+
+ if (type == CONNMAN_SERVICE_TYPE_WIFI) {
+ provision_service_wifi(config, service, network,
+ ssid, ssid_len);
+ }
+ else if (type == CONNMAN_SERVICE_TYPE_LOWPAN) {
+ provision_service_lowpan(config, service, network);
+ }
+
+ __connman_service_mark_dirty();
+
+ __connman_service_load_modifiable(service);
+
+ if (config->virtual) {
+ struct connect_virtual *virtual;
+
+ virtual = g_malloc0(sizeof(struct connect_virtual));
+ virtual->service = service;
+ virtual->vfile = config->virtual_file;
+
+ g_timeout_add(0, remove_virtual_config, virtual);
+
+ return 0;
+ }
+
+ if (type != CONNMAN_SERVICE_TYPE_WIFI)
+ __connman_service_set_immutable(service, true);
+
+ if (type == CONNMAN_SERVICE_TYPE_ETHERNET ||
+ type == CONNMAN_SERVICE_TYPE_GADGET) {
+ __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+
+ return 0;
+ }
+
+ if (type != CONNMAN_SERVICE_TYPE_WIFI)
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+
+ return 0;
+}
+
+static int find_and_provision_service(struct connman_service *service)
+{
+ GHashTableIter iter, iter_service;
+ gpointer value, key, value_service, key_service;
+
+ g_hash_table_iter_init(&iter, config_table);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_config *config = value;
+
+ g_hash_table_iter_init(&iter_service, config->service_table);
+ while (g_hash_table_iter_next(&iter_service, &key_service,
+ &value_service)) {
+ if (!try_provision_service(value_service, service))
+ return 0;
+ }
+ }
+
+ return -ENOENT;
+}
+
+int __connman_config_provision_service(struct connman_service *service)
+{
+ enum connman_service_type type;
+
+ /* For now only WiFi, Gadget and Ethernet services are supported */
+ type = connman_service_get_type(service);
+
+ DBG("service %p type %d", service, type);
+
+ if (type != CONNMAN_SERVICE_TYPE_WIFI &&
+ type != CONNMAN_SERVICE_TYPE_LOWPAN &&
+ type != CONNMAN_SERVICE_TYPE_ETHERNET &&
+ type != CONNMAN_SERVICE_TYPE_GADGET)
+ return -ENOSYS;
+
+ return find_and_provision_service(service);
+}
+
+int __connman_config_provision_service_ident(struct connman_service *service,
+ const char *ident, const char *file, const char *entry)
+{
+ enum connman_service_type type;
+ struct connman_config *config;
+ int ret = 0;
+
+ /* For now only WiFi, Gadget and Ethernet services are supported */
+ type = connman_service_get_type(service);
+
+ DBG("service %p type %d", service, type);
+
+ if (type != CONNMAN_SERVICE_TYPE_WIFI &&
+ type != CONNMAN_SERVICE_TYPE_ETHERNET &&
+ type != CONNMAN_SERVICE_TYPE_GADGET &&
+ type != CONNMAN_SERVICE_TYPE_LOWPAN)
+ return -ENOSYS;
+
+ config = g_hash_table_lookup(config_table, ident);
+ if (config) {
+ GHashTableIter iter;
+ gpointer value, key;
+ bool found = false;
+
+ g_hash_table_iter_init(&iter, config->service_table);
+
+ /*
+ * Check if we need to remove individual service if it
+ * is missing from config file.
+ */
+ if (file && entry) {
+ while (g_hash_table_iter_next(&iter, &key,
+ &value)) {
+ struct connman_config_service *config_service;
+
+ config_service = value;
+
+ if (g_strcmp0(config_service->config_ident,
+ file) != 0)
+ continue;
+
+ if (g_strcmp0(config_service->config_entry,
+ entry) != 0)
+ continue;
+
+ found = true;
+ break;
+ }
+
+ DBG("found %d ident %s file %s entry %s", found, ident,
+ file, entry);
+
+ if (!found) {
+ /*
+ * The entry+8 will skip "service_" prefix
+ */
+ g_hash_table_remove(config->service_table,
+ entry + 8);
+ ret = 1;
+ }
+ }
+
+ find_and_provision_service(service);
+ }
+
+ return ret;
+}
+
+static void generate_random_string(char *str, int length)
+{
+ uint8_t val;
+ int i;
+ uint64_t rand;
+
+ memset(str, '\0', length);
+
+ for (i = 0; i < length-1; i++) {
+ do {
+ __connman_util_get_random(&rand);
+ val = (uint8_t)(rand % 122);
+ if (val < 48)
+ val += 48;
+ } while((val > 57 && val < 65) || (val > 90 && val < 97));
+
+ str[i] = val;
+ }
+}
+
+int connman_config_provision_mutable_service(GKeyFile *keyfile)
+{
+ struct connman_config_service *service_config;
+ struct connman_config *config;
+ char *vfile, *group;
+ char rstr[11];
+
+ DBG("");
+
+ generate_random_string(rstr, 11);
+
+ vfile = g_strdup_printf("service_mutable_%s.config", rstr);
+
+ config = create_config(vfile);
+ if (!config)
+ return -ENOMEM;
+
+ if (!load_service_from_keyfile(keyfile, config))
+ goto error;
+
+ group = g_key_file_get_start_group(keyfile);
+
+ service_config = g_hash_table_lookup(config->service_table, group+8);
+ if (!service_config)
+ goto error;
+
+ /* Specific to non file based config: */
+ g_free(service_config->config_ident);
+ service_config->config_ident = NULL;
+ g_free(service_config->config_entry);
+ service_config->config_entry = NULL;
+
+ service_config->virtual = true;
+ service_config->virtual_file = vfile;
+
+ __connman_service_provision_changed(vfile);
+
+ if (g_strcmp0(service_config->type, "wifi") == 0)
+ __connman_device_request_scan(CONNMAN_SERVICE_TYPE_WIFI);
+
+ return 0;
+
+error:
+ DBG("Could not proceed");
+ g_hash_table_remove(config_table, vfile);
+ g_free(vfile);
+
+ return -EINVAL;
+}
+
+struct connman_config_entry **connman_config_get_entries(const char *type)
+{
+ GHashTableIter iter_file, iter_config;
+ gpointer value, key;
+ struct connman_config_entry **entries = NULL;
+ int i = 0, count;
+
+ g_hash_table_iter_init(&iter_file, config_table);
+ while (g_hash_table_iter_next(&iter_file, &key, &value)) {
+ struct connman_config *config_file = value;
+
+ count = g_hash_table_size(config_file->service_table);
+
+ entries = g_try_realloc(entries, (i + count + 1) *
+ sizeof(struct connman_config_entry *));
+ if (!entries)
+ return NULL;
+
+ g_hash_table_iter_init(&iter_config,
+ config_file->service_table);
+ while (g_hash_table_iter_next(&iter_config, &key,
+ &value)) {
+ struct connman_config_service *config = value;
+
+ if (type &&
+ g_strcmp0(config->type, type) != 0)
+ continue;
+
+ entries[i] = g_try_new0(struct connman_config_entry,
+ 1);
+ if (!entries[i])
+ goto cleanup;
+
+ entries[i]->ident = g_strdup(config->ident);
+ entries[i]->name = g_strdup(config->name);
+ entries[i]->ssid = g_try_malloc0(config->ssid_len + 1);
+ if (!entries[i]->ssid)
+ goto cleanup;
+
+ memcpy(entries[i]->ssid, config->ssid,
+ config->ssid_len);
+ entries[i]->ssid_len = config->ssid_len;
+ entries[i]->hidden = config->hidden;
+
+ i++;
+ }
+ }
+
+ if (entries) {
+ entries = g_try_realloc(entries, (i + 1) *
+ sizeof(struct connman_config_entry *));
+ if (!entries)
+ return NULL;
+
+ entries[i] = NULL;
+
+ DBG("%d provisioned AP found", i);
+ }
+
+ return entries;
+
+cleanup:
+ connman_config_free_entries(entries);
+ return NULL;
+}
+
+void connman_config_free_entries(struct connman_config_entry **entries)
+{
+ int i;
+
+ if (!entries)
+ return;
+
+ for (i = 0; entries[i]; i++) {
+ g_free(entries[i]->ident);
+ g_free(entries[i]->name);
+ g_free(entries[i]->ssid);
+ g_free(entries[i]);
+ }
+
+ g_free(entries);
+ return;
+}
+
+bool __connman_config_address_provisioned(const char *address,
+ const char *netmask)
+{
+ GHashTableIter iter, siter;
+ gpointer value, key, svalue, skey;
+
+ if (!address || !netmask)
+ return false;
+
+ g_hash_table_iter_init(&iter, config_table);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_config *config = value;
+
+ g_hash_table_iter_init(&siter, config->service_table);
+ while (g_hash_table_iter_next(&siter, &skey, &svalue)) {
+ struct connman_config_service *service = svalue;
+
+ if (!g_strcmp0(address, service->ipv4_address) &&
+ !g_strcmp0(netmask,
+ service->ipv4_netmask))
+ return true;
+ }
+ }
+
+ return false;
+}
diff --git a/src/connection.c b/src/connection.c
new file mode 100644
index 0000000..dba24d0
--- /dev/null
+++ b/src/connection.c
@@ -0,0 +1,1147 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ * Copyright (C) 2011-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <net/if.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+struct gateway_config {
+ bool active;
+ char *gateway;
+
+ /* VPN extra data */
+ bool vpn;
+ char *vpn_ip;
+ int vpn_phy_index;
+ char *vpn_phy_ip;
+};
+
+struct gateway_data {
+ int index;
+ struct connman_service *service;
+ unsigned int order;
+ struct gateway_config *ipv4_gateway;
+ struct gateway_config *ipv6_gateway;
+ bool default_checked;
+};
+
+static GHashTable *gateway_hash = NULL;
+
+static struct gateway_config *find_gateway(int index, const char *gateway)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ if (!gateway)
+ return NULL;
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ if (data->ipv4_gateway && data->index == index &&
+ g_str_equal(data->ipv4_gateway->gateway,
+ gateway))
+ return data->ipv4_gateway;
+
+ if (data->ipv6_gateway && data->index == index &&
+ g_str_equal(data->ipv6_gateway->gateway,
+ gateway))
+ return data->ipv6_gateway;
+ }
+
+ return NULL;
+}
+
+static struct gateway_data *lookup_gateway_data(struct gateway_config *config)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ if (!config)
+ return NULL;
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ if (data->ipv4_gateway &&
+ data->ipv4_gateway == config)
+ return data;
+
+ if (data->ipv6_gateway &&
+ data->ipv6_gateway == config)
+ return data;
+ }
+
+ return NULL;
+}
+
+static struct gateway_data *find_vpn_gateway(int index, const char *gateway)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ if (!gateway)
+ return NULL;
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ if (data->ipv4_gateway && data->index == index &&
+ g_str_equal(data->ipv4_gateway->gateway,
+ gateway))
+ return data;
+
+ if (data->ipv6_gateway && data->index == index &&
+ g_str_equal(data->ipv6_gateway->gateway,
+ gateway))
+ return data;
+ }
+
+ return NULL;
+}
+
+struct get_gateway_params {
+ char *vpn_gateway;
+ int vpn_index;
+};
+
+static void get_gateway_cb(const char *gateway, int index, void *user_data)
+{
+ struct gateway_config *config;
+ struct gateway_data *data;
+ struct get_gateway_params *params = user_data;
+ int family;
+
+ if (index < 0)
+ goto out;
+
+ DBG("phy index %d phy gw %s vpn index %d vpn gw %s", index, gateway,
+ params->vpn_index, params->vpn_gateway);
+
+ data = find_vpn_gateway(params->vpn_index, params->vpn_gateway);
+ if (!data) {
+ DBG("Cannot find VPN link route, index %d addr %s",
+ params->vpn_index, params->vpn_gateway);
+ goto out;
+ }
+
+ family = connman_inet_check_ipaddress(params->vpn_gateway);
+
+ if (family == AF_INET)
+ config = data->ipv4_gateway;
+ else if (family == AF_INET6)
+ config = data->ipv6_gateway;
+ else
+ goto out;
+
+ config->vpn_phy_index = index;
+
+ DBG("vpn %s phy index %d", config->vpn_ip, config->vpn_phy_index);
+
+out:
+ g_free(params->vpn_gateway);
+ g_free(params);
+}
+
+static void set_vpn_routes(struct gateway_data *new_gateway,
+ struct connman_service *service,
+ const char *gateway,
+ enum connman_ipconfig_type type,
+ const char *peer,
+ struct gateway_data *active_gateway)
+{
+ struct gateway_config *config;
+ struct connman_ipconfig *ipconfig;
+ char *dest;
+
+ DBG("new %p service %p gw %s type %d peer %s active %p",
+ new_gateway, service, gateway, type, peer, active_gateway);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ ipconfig = __connman_service_get_ip4config(service);
+ config = new_gateway->ipv4_gateway;
+ } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ ipconfig = __connman_service_get_ip6config(service);
+ config = new_gateway->ipv6_gateway;
+ } else
+ return;
+
+ if (config) {
+ int index = __connman_ipconfig_get_index(ipconfig);
+ struct get_gateway_params *params;
+
+ config->vpn = true;
+ if (peer)
+ config->vpn_ip = g_strdup(peer);
+ else if (gateway)
+ config->vpn_ip = g_strdup(gateway);
+
+ params = g_try_malloc(sizeof(struct get_gateway_params));
+ if (!params)
+ return;
+
+ params->vpn_index = index;
+ params->vpn_gateway = g_strdup(gateway);
+
+ /*
+ * Find the gateway that is serving the VPN link
+ */
+ __connman_inet_get_route(gateway, get_gateway_cb, params);
+ }
+
+ if (!active_gateway)
+ return;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ /*
+ * Special route to VPN server via gateway. This
+ * is needed so that we can access hosts behind
+ * the VPN. The route might already exist depending
+ * on network topology.
+ */
+ if (!active_gateway->ipv4_gateway)
+ return;
+
+ DBG("active gw %s", active_gateway->ipv4_gateway->gateway);
+
+ if (g_strcmp0(active_gateway->ipv4_gateway->gateway,
+ "0.0.0.0") != 0)
+ dest = active_gateway->ipv4_gateway->gateway;
+ else
+ dest = NULL;
+
+ connman_inet_add_host_route(active_gateway->index, gateway,
+ dest);
+
+ } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+
+ if (!active_gateway->ipv6_gateway)
+ return;
+
+ DBG("active gw %s", active_gateway->ipv6_gateway->gateway);
+
+ if (g_strcmp0(active_gateway->ipv6_gateway->gateway,
+ "::") != 0)
+ dest = active_gateway->ipv6_gateway->gateway;
+ else
+ dest = NULL;
+
+ connman_inet_add_ipv6_host_route(active_gateway->index,
+ gateway, dest);
+ }
+}
+
+static int del_routes(struct gateway_data *data,
+ enum connman_ipconfig_type type)
+{
+ int status4 = 0, status6 = 0;
+ bool do_ipv4 = false, do_ipv6 = false;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ do_ipv4 = true;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ do_ipv6 = true;
+ else
+ do_ipv4 = do_ipv6 = true;
+
+ if (do_ipv4 && data->ipv4_gateway) {
+ if (data->ipv4_gateway->vpn) {
+ status4 = connman_inet_clear_gateway_address(
+ data->index,
+ data->ipv4_gateway->vpn_ip);
+
+ } else if (g_strcmp0(data->ipv4_gateway->gateway,
+ "0.0.0.0") == 0) {
+ status4 = connman_inet_clear_gateway_interface(
+ data->index);
+ } else {
+ connman_inet_del_host_route(data->index,
+ data->ipv4_gateway->gateway);
+ status4 = connman_inet_clear_gateway_address(
+ data->index,
+ data->ipv4_gateway->gateway);
+ }
+ }
+
+ if (do_ipv6 && data->ipv6_gateway) {
+ if (data->ipv6_gateway->vpn) {
+ status6 = connman_inet_clear_ipv6_gateway_address(
+ data->index,
+ data->ipv6_gateway->vpn_ip);
+
+ } else if (g_strcmp0(data->ipv6_gateway->gateway, "::") == 0) {
+ status6 = connman_inet_clear_ipv6_gateway_interface(
+ data->index);
+ } else {
+ connman_inet_del_ipv6_host_route(data->index,
+ data->ipv6_gateway->gateway);
+ status6 = connman_inet_clear_ipv6_gateway_address(
+ data->index,
+ data->ipv6_gateway->gateway);
+ }
+ }
+
+ return (status4 < 0 ? status4 : status6);
+}
+
+static int disable_gateway(struct gateway_data *data,
+ enum connman_ipconfig_type type)
+{
+ bool active = false;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ if (data->ipv4_gateway)
+ active = data->ipv4_gateway->active;
+ } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ if (data->ipv6_gateway)
+ active = data->ipv6_gateway->active;
+ } else
+ active = true;
+
+ DBG("type %d active %d", type, active);
+
+ if (active)
+ return del_routes(data, type);
+
+ return 0;
+}
+
+static struct gateway_data *add_gateway(struct connman_service *service,
+ int index, const char *gateway,
+ enum connman_ipconfig_type type)
+{
+ struct gateway_data *data, *old;
+ struct gateway_config *config;
+
+ if (!gateway || strlen(gateway) == 0)
+ return NULL;
+
+ data = g_try_new0(struct gateway_data, 1);
+ if (!data)
+ return NULL;
+
+ data->index = index;
+
+ config = g_try_new0(struct gateway_config, 1);
+ if (!config) {
+ g_free(data);
+ return NULL;
+ }
+
+ config->gateway = g_strdup(gateway);
+ config->vpn_ip = NULL;
+ config->vpn_phy_ip = NULL;
+ config->vpn = false;
+ config->vpn_phy_index = -1;
+ config->active = false;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ data->ipv4_gateway = config;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ data->ipv6_gateway = config;
+ else {
+ g_free(config->gateway);
+ g_free(config);
+ g_free(data);
+ return NULL;
+ }
+
+ data->service = service;
+
+ data->order = __connman_service_get_order(service);
+
+ /*
+ * If the service is already in the hash, then we
+ * must not replace it blindly but disable the gateway
+ * of the type we are replacing and take the other type
+ * from old gateway settings.
+ */
+ old = g_hash_table_lookup(gateway_hash, service);
+ if (old) {
+ DBG("Replacing gw %p ipv4 %p ipv6 %p", old,
+ old->ipv4_gateway, old->ipv6_gateway);
+ disable_gateway(old, type);
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ data->ipv6_gateway = old->ipv6_gateway;
+ old->ipv6_gateway = NULL;
+ } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ data->ipv4_gateway = old->ipv4_gateway;
+ old->ipv4_gateway = NULL;
+ }
+ }
+
+ connman_service_ref(data->service);
+ g_hash_table_replace(gateway_hash, service, data);
+
+ return data;
+}
+
+static void set_default_gateway(struct gateway_data *data,
+ enum connman_ipconfig_type type)
+{
+ int index;
+ int status4 = 0, status6 = 0;
+ bool do_ipv4 = false, do_ipv6 = false;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ do_ipv4 = true;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ do_ipv6 = true;
+ else
+ do_ipv4 = do_ipv6 = true;
+
+ DBG("type %d gateway ipv4 %p ipv6 %p", type, data->ipv4_gateway,
+ data->ipv6_gateway);
+
+ if (do_ipv4 && data->ipv4_gateway &&
+ data->ipv4_gateway->vpn) {
+ connman_inet_set_gateway_interface(data->index);
+ data->ipv4_gateway->active = true;
+
+ DBG("set %p index %d vpn %s index %d phy %s",
+ data, data->index, data->ipv4_gateway->vpn_ip,
+ data->ipv4_gateway->vpn_phy_index,
+ data->ipv4_gateway->vpn_phy_ip);
+
+ __connman_service_indicate_default(data->service);
+
+ return;
+ }
+
+ if (do_ipv6 && data->ipv6_gateway &&
+ data->ipv6_gateway->vpn) {
+ connman_inet_set_ipv6_gateway_interface(data->index);
+ data->ipv6_gateway->active = true;
+
+ DBG("set %p index %d vpn %s index %d phy %s",
+ data, data->index, data->ipv6_gateway->vpn_ip,
+ data->ipv6_gateway->vpn_phy_index,
+ data->ipv6_gateway->vpn_phy_ip);
+
+ __connman_service_indicate_default(data->service);
+
+ return;
+ }
+
+ index = __connman_service_get_index(data->service);
+
+ if (do_ipv4 && data->ipv4_gateway &&
+ g_strcmp0(data->ipv4_gateway->gateway,
+ "0.0.0.0") == 0) {
+ if (connman_inet_set_gateway_interface(index) < 0)
+ return;
+ goto done;
+ }
+
+ if (do_ipv6 && data->ipv6_gateway &&
+ g_strcmp0(data->ipv6_gateway->gateway,
+ "::") == 0) {
+ if (connman_inet_set_ipv6_gateway_interface(index) < 0)
+ return;
+ goto done;
+ }
+
+ if (do_ipv6 && data->ipv6_gateway)
+ status6 = __connman_inet_add_default_to_table(RT_TABLE_MAIN,
+ index, data->ipv6_gateway->gateway);
+
+ if (do_ipv4 && data->ipv4_gateway)
+ status4 = __connman_inet_add_default_to_table(RT_TABLE_MAIN,
+ index, data->ipv4_gateway->gateway);
+
+ if (status4 < 0 || status6 < 0)
+ return;
+
+done:
+ __connman_service_indicate_default(data->service);
+}
+
+static void unset_default_gateway(struct gateway_data *data,
+ enum connman_ipconfig_type type)
+{
+ int index;
+ bool do_ipv4 = false, do_ipv6 = false;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ do_ipv4 = true;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ do_ipv6 = true;
+ else
+ do_ipv4 = do_ipv6 = true;
+
+ DBG("type %d gateway ipv4 %p ipv6 %p", type, data->ipv4_gateway,
+ data->ipv6_gateway);
+
+ if (do_ipv4 && data->ipv4_gateway &&
+ data->ipv4_gateway->vpn) {
+ connman_inet_clear_gateway_interface(data->index);
+ data->ipv4_gateway->active = false;
+
+ DBG("unset %p index %d vpn %s index %d phy %s",
+ data, data->index, data->ipv4_gateway->vpn_ip,
+ data->ipv4_gateway->vpn_phy_index,
+ data->ipv4_gateway->vpn_phy_ip);
+
+ return;
+ }
+
+ if (do_ipv6 && data->ipv6_gateway &&
+ data->ipv6_gateway->vpn) {
+ connman_inet_clear_ipv6_gateway_interface(data->index);
+ data->ipv6_gateway->active = false;
+
+ DBG("unset %p index %d vpn %s index %d phy %s",
+ data, data->index, data->ipv6_gateway->vpn_ip,
+ data->ipv6_gateway->vpn_phy_index,
+ data->ipv6_gateway->vpn_phy_ip);
+
+ return;
+ }
+
+ index = __connman_service_get_index(data->service);
+
+ if (do_ipv4 && data->ipv4_gateway &&
+ g_strcmp0(data->ipv4_gateway->gateway,
+ "0.0.0.0") == 0) {
+ connman_inet_clear_gateway_interface(index);
+ return;
+ }
+
+ if (do_ipv6 && data->ipv6_gateway &&
+ g_strcmp0(data->ipv6_gateway->gateway,
+ "::") == 0) {
+ connman_inet_clear_ipv6_gateway_interface(index);
+ return;
+ }
+
+ if (do_ipv6 && data->ipv6_gateway)
+ connman_inet_clear_ipv6_gateway_address(index,
+ data->ipv6_gateway->gateway);
+
+ if (do_ipv4 && data->ipv4_gateway)
+ connman_inet_clear_gateway_address(index,
+ data->ipv4_gateway->gateway);
+}
+
+static struct gateway_data *find_default_gateway(void)
+{
+ struct gateway_data *found = NULL;
+ unsigned int order = 0;
+ GHashTableIter iter;
+ gpointer value, key;
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ if (!found || data->order > order) {
+ found = data;
+ order = data->order;
+
+ DBG("default %p order %d", found, order);
+ }
+ }
+
+ return found;
+}
+
+static bool choose_default_gateway(struct gateway_data *data,
+ struct gateway_data *candidate)
+{
+ bool downgraded = false;
+
+ /*
+ * If the current default is not active, then we mark
+ * this one as default. If the other one is already active
+ * we mark this one as non default.
+ */
+ if (data->ipv4_gateway) {
+ if (candidate->ipv4_gateway &&
+ !candidate->ipv4_gateway->active) {
+ DBG("ipv4 downgrading %p", candidate);
+ unset_default_gateway(candidate,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ }
+ if (candidate->ipv4_gateway &&
+ candidate->ipv4_gateway->active &&
+ candidate->order > data->order) {
+ DBG("ipv4 downgrading this %p", data);
+ unset_default_gateway(data,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ downgraded = true;
+ }
+ }
+
+ if (data->ipv6_gateway) {
+ if (candidate->ipv6_gateway &&
+ !candidate->ipv6_gateway->active) {
+ DBG("ipv6 downgrading %p", candidate);
+ unset_default_gateway(candidate,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ }
+
+ if (candidate->ipv6_gateway &&
+ candidate->ipv6_gateway->active &&
+ candidate->order > data->order) {
+ DBG("ipv6 downgrading this %p", data);
+ unset_default_gateway(data,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ downgraded = true;
+ }
+ }
+
+ return downgraded;
+}
+
+static void connection_newgateway(int index, const char *gateway)
+{
+ struct gateway_config *config;
+ struct gateway_data *data;
+ GHashTableIter iter;
+ gpointer value, key;
+ bool found = false;
+
+ DBG("index %d gateway %s", index, gateway);
+
+ config = find_gateway(index, gateway);
+ if (!config)
+ return;
+
+ config->active = true;
+
+ /*
+ * It is possible that we have two default routes atm
+ * if there are two gateways waiting rtnl activation at the
+ * same time.
+ */
+ data = lookup_gateway_data(config);
+ if (!data)
+ return;
+
+ if (data->default_checked)
+ return;
+
+ /*
+ * The next checks are only done once, otherwise setting
+ * the default gateway could lead into rtnl forever loop.
+ */
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *candidate = value;
+
+ if (candidate == data)
+ continue;
+
+ found = choose_default_gateway(data, candidate);
+ if (found)
+ break;
+ }
+
+ if (!found) {
+ if (data->ipv4_gateway)
+ set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ if (data->ipv6_gateway)
+ set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_IPV6);
+ }
+
+ data->default_checked = true;
+}
+
+static void remove_gateway(gpointer user_data)
+{
+ struct gateway_data *data = user_data;
+
+ DBG("gateway ipv4 %p ipv6 %p", data->ipv4_gateway, data->ipv6_gateway);
+
+ if (data->ipv4_gateway) {
+ g_free(data->ipv4_gateway->gateway);
+ g_free(data->ipv4_gateway->vpn_ip);
+ g_free(data->ipv4_gateway->vpn_phy_ip);
+ g_free(data->ipv4_gateway);
+ }
+
+ if (data->ipv6_gateway) {
+ g_free(data->ipv6_gateway->gateway);
+ g_free(data->ipv6_gateway->vpn_ip);
+ g_free(data->ipv6_gateway->vpn_phy_ip);
+ g_free(data->ipv6_gateway);
+ }
+
+ connman_service_unref(data->service);
+
+ g_free(data);
+}
+
+static void connection_delgateway(int index, const char *gateway)
+{
+ struct gateway_config *config;
+ struct gateway_data *data;
+
+ DBG("index %d gateway %s", index, gateway);
+
+ config = find_gateway(index, gateway);
+ if (config)
+ config->active = false;
+
+ data = find_default_gateway();
+ if (data)
+ set_default_gateway(data, CONNMAN_IPCONFIG_TYPE_ALL);
+}
+
+static struct connman_rtnl connection_rtnl = {
+ .name = "connection",
+ .newgateway = connection_newgateway,
+ .delgateway = connection_delgateway,
+};
+
+static struct gateway_data *find_active_gateway(void)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ DBG("");
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ if (data->ipv4_gateway &&
+ data->ipv4_gateway->active)
+ return data;
+
+ if (data->ipv6_gateway &&
+ data->ipv6_gateway->active)
+ return data;
+ }
+
+ return NULL;
+}
+
+static void update_order(void)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ DBG("");
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ data->order = __connman_service_get_order(data->service);
+ }
+}
+
+void __connman_connection_gateway_activate(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ struct gateway_data *data = NULL;
+
+ data = g_hash_table_lookup(gateway_hash, service);
+ if (!data)
+ return;
+
+ DBG("gateway %p/%p type %d", data->ipv4_gateway,
+ data->ipv6_gateway, type);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ data->ipv4_gateway->active = true;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ data->ipv6_gateway->active = true;
+}
+
+static void add_host_route(int family, int index, const char *gateway,
+ enum connman_service_type service_type)
+{
+ switch (family) {
+ case AF_INET:
+ if (g_strcmp0(gateway, "0.0.0.0") != 0) {
+ /*
+ * We must not set route to the phy dev gateway in
+ * VPN link. The packets to VPN link might be routed
+ * back to itself and not routed into phy link gateway.
+ */
+ if (service_type != CONNMAN_SERVICE_TYPE_VPN)
+ connman_inet_add_host_route(index, gateway,
+ NULL);
+ } else {
+ /*
+ * Add host route to P-t-P link so that services can
+ * be moved around and we can have some link to P-t-P
+ * network (although those P-t-P links have limited
+ * usage if default route is not directed to them)
+ */
+ char *dest;
+ if (connman_inet_get_dest_addr(index, &dest) == 0) {
+ connman_inet_add_host_route(index, dest, NULL);
+ g_free(dest);
+ }
+ }
+ break;
+
+ case AF_INET6:
+ if (g_strcmp0(gateway, "::") != 0) {
+ if (service_type != CONNMAN_SERVICE_TYPE_VPN)
+ connman_inet_add_ipv6_host_route(index,
+ gateway, NULL);
+ } else {
+ /* P-t-P link, add route to destination */
+ char *dest;
+ if (connman_inet_ipv6_get_dest_addr(index,
+ &dest) == 0) {
+ connman_inet_add_ipv6_host_route(index, dest,
+ NULL);
+ g_free(dest);
+ }
+ }
+ break;
+ }
+}
+
+int __connman_connection_gateway_add(struct connman_service *service,
+ const char *gateway,
+ enum connman_ipconfig_type type,
+ const char *peer)
+{
+ struct gateway_data *active_gateway = NULL;
+ struct gateway_data *new_gateway = NULL;
+ enum connman_ipconfig_type type4 = CONNMAN_IPCONFIG_TYPE_UNKNOWN,
+ type6 = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
+ enum connman_service_type service_type =
+ connman_service_get_type(service);
+ int index;
+
+ index = __connman_service_get_index(service);
+
+ /*
+ * If gateway is NULL, it's a point to point link and the default
+ * gateway for ipv4 is 0.0.0.0 and for ipv6 is ::, meaning the
+ * interface
+ */
+ if (!gateway && type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ gateway = "0.0.0.0";
+
+ if (!gateway && type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ gateway = "::";
+
+ DBG("service %p index %d gateway %s vpn ip %s type %d",
+ service, index, gateway, peer, type);
+
+ new_gateway = add_gateway(service, index, gateway, type);
+ if (!new_gateway)
+ return -EINVAL;
+
+ active_gateway = find_active_gateway();
+
+ DBG("active %p index %d new %p", active_gateway,
+ active_gateway ? active_gateway->index : -1, new_gateway);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+ new_gateway->ipv4_gateway) {
+ add_host_route(AF_INET, index, gateway, service_type);
+ __connman_service_nameserver_add_routes(service,
+ new_gateway->ipv4_gateway->gateway);
+ type4 = CONNMAN_IPCONFIG_TYPE_IPV4;
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+ new_gateway->ipv6_gateway) {
+ add_host_route(AF_INET6, index, gateway, service_type);
+ __connman_service_nameserver_add_routes(service,
+ new_gateway->ipv6_gateway->gateway);
+ type6 = CONNMAN_IPCONFIG_TYPE_IPV6;
+ }
+
+ if (service_type == CONNMAN_SERVICE_TYPE_VPN) {
+
+ set_vpn_routes(new_gateway, service, gateway, type, peer,
+ active_gateway);
+
+ } else {
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+ new_gateway->ipv4_gateway)
+ new_gateway->ipv4_gateway->vpn = false;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+ new_gateway->ipv6_gateway)
+ new_gateway->ipv6_gateway->vpn = false;
+ }
+
+ if (!active_gateway) {
+ set_default_gateway(new_gateway, type);
+ goto done;
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+ new_gateway->ipv4_gateway &&
+ new_gateway->ipv4_gateway->vpn) {
+ if (!__connman_service_is_split_routing(new_gateway->service))
+ connman_inet_clear_gateway_address(
+ active_gateway->index,
+ active_gateway->ipv4_gateway->gateway);
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+ new_gateway->ipv6_gateway &&
+ new_gateway->ipv6_gateway->vpn) {
+ if (!__connman_service_is_split_routing(new_gateway->service))
+ connman_inet_clear_ipv6_gateway_address(
+ active_gateway->index,
+ active_gateway->ipv6_gateway->gateway);
+ }
+
+done:
+ if (type4 == CONNMAN_IPCONFIG_TYPE_IPV4)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_READY,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ if (type6 == CONNMAN_IPCONFIG_TYPE_IPV6)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_READY,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ return 0;
+}
+
+void __connman_connection_gateway_remove(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ struct gateway_data *data = NULL;
+ bool set_default4 = false, set_default6 = false;
+ bool do_ipv4 = false, do_ipv6 = false;
+ int err;
+
+ DBG("service %p type %d", service, type);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ do_ipv4 = true;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ do_ipv6 = true;
+ else
+ do_ipv4 = do_ipv6 = true;
+
+ __connman_service_nameserver_del_routes(service, type);
+
+ data = g_hash_table_lookup(gateway_hash, service);
+ if (!data)
+ return;
+
+ if (do_ipv4 && data->ipv4_gateway)
+ set_default4 = data->ipv4_gateway->vpn;
+
+ if (do_ipv6 && data->ipv6_gateway)
+ set_default6 = data->ipv6_gateway->vpn;
+
+ DBG("ipv4 gateway %s ipv6 gateway %s vpn %d/%d",
+ data->ipv4_gateway ? data->ipv4_gateway->gateway : "<null>",
+ data->ipv6_gateway ? data->ipv6_gateway->gateway : "<null>",
+ set_default4, set_default6);
+
+ if (do_ipv4 && data->ipv4_gateway &&
+ data->ipv4_gateway->vpn && data->index >= 0)
+ connman_inet_del_host_route(data->ipv4_gateway->vpn_phy_index,
+ data->ipv4_gateway->gateway);
+
+ if (do_ipv6 && data->ipv6_gateway &&
+ data->ipv6_gateway->vpn && data->index >= 0)
+ connman_inet_del_ipv6_host_route(
+ data->ipv6_gateway->vpn_phy_index,
+ data->ipv6_gateway->gateway);
+
+ err = disable_gateway(data, type);
+
+ /*
+ * We remove the service from the hash only if all the gateway
+ * settings are to be removed.
+ */
+ if (do_ipv4 == do_ipv6 ||
+ (data->ipv4_gateway && !data->ipv6_gateway
+ && do_ipv4) ||
+ (data->ipv6_gateway && !data->ipv4_gateway
+ && do_ipv6)) {
+ g_hash_table_remove(gateway_hash, service);
+ } else
+ DBG("Not yet removing gw ipv4 %p/%d ipv6 %p/%d",
+ data->ipv4_gateway, do_ipv4,
+ data->ipv6_gateway, do_ipv6);
+
+ /* with vpn this will be called after the network was deleted,
+ * we need to call set_default here because we will not recieve any
+ * gateway delete notification.
+ * We hit the same issue if remove_gateway() fails.
+ */
+ if (set_default4 || set_default6 || err < 0) {
+ data = find_default_gateway();
+ if (data)
+ set_default_gateway(data, type);
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_CONFIGURATION,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_CONFIGURATION,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+}
+
+bool __connman_connection_update_gateway(void)
+{
+ struct gateway_data *default_gateway;
+ bool updated = false;
+ GHashTableIter iter;
+ gpointer value, key;
+
+ if (!gateway_hash)
+ return updated;
+
+ __connman_service_update_ordering();
+
+ update_order();
+
+ default_gateway = find_default_gateway();
+
+
+ DBG("default %p", default_gateway);
+
+ /*
+ * There can be multiple active gateways so we need to
+ * check them all.
+ */
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *active_gateway = value;
+
+ if (active_gateway == default_gateway)
+ continue;
+
+ if (active_gateway->ipv4_gateway &&
+ active_gateway->ipv4_gateway->active) {
+
+ unset_default_gateway(active_gateway,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ updated = true;
+ }
+
+ if (active_gateway->ipv6_gateway &&
+ active_gateway->ipv6_gateway->active) {
+
+ unset_default_gateway(active_gateway,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ updated = true;
+ }
+ }
+
+ if (updated && default_gateway) {
+ if (default_gateway->ipv4_gateway)
+ set_default_gateway(default_gateway,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ if (default_gateway->ipv6_gateway)
+ set_default_gateway(default_gateway,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ }
+
+ return updated;
+}
+
+int __connman_connection_get_vpn_index(int phy_index)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ if (data->ipv4_gateway &&
+ data->ipv4_gateway->vpn_phy_index == phy_index)
+ return data->index;
+
+ if (data->ipv6_gateway &&
+ data->ipv6_gateway->vpn_phy_index == phy_index)
+ return data->index;
+ }
+
+ return -1;
+}
+
+int __connman_connection_init(void)
+{
+ int err;
+
+ DBG("");
+
+ gateway_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, remove_gateway);
+
+ err = connman_rtnl_register(&connection_rtnl);
+ if (err < 0)
+ connman_error("Failed to setup RTNL gateway driver");
+
+ return err;
+}
+
+void __connman_connection_cleanup(void)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ DBG("");
+
+ connman_rtnl_unregister(&connection_rtnl);
+
+ g_hash_table_iter_init(&iter, gateway_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct gateway_data *data = value;
+
+ disable_gateway(data, CONNMAN_IPCONFIG_TYPE_ALL);
+ }
+
+ g_hash_table_destroy(gateway_hash);
+ gateway_hash = NULL;
+}
diff --git a/src/connman-dbus.conf b/src/connman-dbus.conf
new file mode 100644
index 0000000..98a773e
--- /dev/null
+++ b/src/connman-dbus.conf
@@ -0,0 +1,17 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <policy user="root">
+ <allow own="net.connman"/>
+ <allow send_destination="net.connman"/>
+ <allow send_interface="net.connman.Agent"/>
+ <allow send_interface="net.connman.Counter"/>
+ <allow send_interface="net.connman.Notification"/>
+ </policy>
+ <policy at_console="true">
+ <allow send_destination="net.connman"/>
+ </policy>
+ <policy context="default">
+ <deny send_destination="net.connman"/>
+ </policy>
+</busconfig>
diff --git a/src/connman-polkit.conf b/src/connman-polkit.conf
new file mode 100644
index 0000000..b13d339
--- /dev/null
+++ b/src/connman-polkit.conf
@@ -0,0 +1,13 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <policy user="root">
+ <allow own="net.connman"/>
+ <allow send_interface="net.connman.Agent"/>
+ <allow send_interface="net.connman.Counter"/>
+ <allow send_interface="net.connman.Notification"/>
+ </policy>
+ <policy context="default">
+ <allow send_destination="net.connman"/>
+ </policy>
+</busconfig>
diff --git a/src/connman.h b/src/connman.h
new file mode 100644
index 0000000..14b62eb
--- /dev/null
+++ b/src/connman.h
@@ -0,0 +1,1042 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdbool.h>
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+
+#include <connman/dbus.h>
+
+dbus_bool_t __connman_dbus_append_objpath_dict_array(DBusMessage *msg,
+ connman_dbus_append_cb_t function, void *user_data);
+dbus_bool_t __connman_dbus_append_objpath_array(DBusMessage *msg,
+ connman_dbus_append_cb_t function, void *user_data);
+int __connman_dbus_init(DBusConnection *conn);
+void __connman_dbus_cleanup(void);
+
+DBusMessage *__connman_error_failed(DBusMessage *msg, int errnum);
+DBusMessage *__connman_error_invalid_arguments(DBusMessage *msg);
+DBusMessage *__connman_error_permission_denied(DBusMessage *msg);
+DBusMessage *__connman_error_passphrase_required(DBusMessage *msg);
+DBusMessage *__connman_error_not_registered(DBusMessage *msg);
+DBusMessage *__connman_error_not_unique(DBusMessage *msg);
+DBusMessage *__connman_error_not_supported(DBusMessage *msg);
+DBusMessage *__connman_error_not_implemented(DBusMessage *msg);
+DBusMessage *__connman_error_not_found(DBusMessage *msg);
+DBusMessage *__connman_error_no_carrier(DBusMessage *msg);
+DBusMessage *__connman_error_in_progress(DBusMessage *msg);
+DBusMessage *__connman_error_already_exists(DBusMessage *msg);
+DBusMessage *__connman_error_already_enabled(DBusMessage *msg);
+DBusMessage *__connman_error_already_disabled(DBusMessage *msg);
+DBusMessage *__connman_error_already_at_order(DBusMessage *msg);
+DBusMessage *__connman_error_already_connected(DBusMessage *msg);
+DBusMessage *__connman_error_not_connected(DBusMessage *msg);
+DBusMessage *__connman_error_operation_aborted(DBusMessage *msg);
+DBusMessage *__connman_error_operation_timeout(DBusMessage *msg);
+DBusMessage *__connman_error_invalid_service(DBusMessage *msg);
+DBusMessage *__connman_error_invalid_property(DBusMessage *msg);
+
+int __connman_manager_init(void);
+void __connman_manager_cleanup(void);
+
+enum time_updates {
+ TIME_UPDATES_UNKNOWN = 0,
+ TIME_UPDATES_MANUAL = 1,
+ TIME_UPDATES_AUTO = 2,
+};
+
+enum time_updates __connman_clock_timeupdates(void);
+int __connman_clock_init(void);
+void __connman_clock_cleanup(void);
+
+void __connman_clock_update_timezone(void);
+
+int __connman_timezone_init(void);
+void __connman_timezone_cleanup(void);
+
+char *__connman_timezone_lookup(void);
+int __connman_timezone_change(const char *zone);
+
+int __connman_agent_init(void);
+void __connman_agent_cleanup(void);
+
+void __connman_counter_send_usage(const char *path,
+ DBusMessage *message);
+int __connman_counter_register(const char *owner, const char *path,
+ unsigned int interval);
+int __connman_counter_unregister(const char *owner, const char *path);
+
+int __connman_counter_init(void);
+void __connman_counter_cleanup(void);
+
+#include <connman/agent.h>
+
+struct connman_service;
+struct connman_peer;
+
+void __connman_agent_cancel(struct connman_service *service);
+
+typedef void (* authentication_cb_t) (struct connman_service *service,
+ bool values_received,
+ const char *name, int name_len,
+ const char *identifier, const char *secret,
+ bool wps, const char *wpspin,
+ const char *error, void *user_data);
+typedef void (* browser_authentication_cb_t) (struct connman_service *service,
+ bool authentication_done,
+ const char *error, void *user_data);
+typedef void (* peer_wps_cb_t) (struct connman_peer *peer, bool choice_done,
+ const char *wpspin, const char *error,
+ void *user_data);
+int __connman_agent_request_passphrase_input(struct connman_service *service,
+ authentication_cb_t callback,
+ const char *dbus_sender, void *user_data);
+int __connman_agent_request_login_input(struct connman_service *service,
+ authentication_cb_t callback, void *user_data);
+int __connman_agent_request_browser(struct connman_service *service,
+ browser_authentication_cb_t callback,
+ const char *url, void *user_data);
+int __connman_agent_report_peer_error(struct connman_peer *peer,
+ const char *path, const char *error,
+ report_error_cb_t callback,
+ const char *dbus_sender,
+ void *user_data);
+int __connman_agent_request_peer_authorization(struct connman_peer *peer,
+ peer_wps_cb_t callback,
+ bool wps_requested,
+ const char *dbus_sender,
+ void *user_data);
+
+#include <connman/log.h>
+
+int __connman_log_init(const char *program, const char *debug,
+ gboolean detach, gboolean backtrace,
+ const char *program_name, const char *program_version);
+void __connman_log_cleanup(gboolean backtrace);
+void __connman_log_enable(struct connman_debug_desc *start,
+ struct connman_debug_desc *stop);
+
+#include <connman/option.h>
+
+#include <connman/setting.h>
+
+#include <connman/plugin.h>
+
+int __connman_plugin_init(const char *pattern, const char *exclude);
+void __connman_plugin_cleanup(void);
+
+#include <connman/task.h>
+
+int __connman_task_init(void);
+void __connman_task_cleanup(void);
+
+#include <connman/inet.h>
+
+char **__connman_inet_get_running_interfaces(void);
+int __connman_inet_modify_address(int cmd, int flags, int index, int family,
+ const char *address,
+ const char *peer,
+ unsigned char prefixlen,
+ const char *broadcast);
+int __connman_inet_get_interface_address(int index, int family, void *address);
+int __connman_inet_get_interface_ll_address(int index, int family, void *address);
+
+#include <netinet/ip6.h>
+#include <netinet/icmp6.h>
+
+typedef void (*__connman_inet_rs_cb_t) (struct nd_router_advert *reply,
+ unsigned int length, void *user_data);
+
+int __connman_inet_ipv6_send_rs(int index, int timeout,
+ __connman_inet_rs_cb_t callback, void *user_data);
+int __connman_inet_ipv6_send_ra(int index, struct in6_addr *src_addr,
+ GSList *prefixes, int router_lifetime);
+
+typedef void (*__connman_inet_ns_cb_t) (struct nd_neighbor_advert *reply,
+ unsigned int length,
+ struct in6_addr *addr,
+ void *user_data);
+int __connman_inet_ipv6_do_dad(int index, int timeout_ms,
+ struct in6_addr *addr,
+ __connman_inet_ns_cb_t callback, void *user_data);
+
+typedef void (*__connman_inet_recv_rs_cb_t) (struct nd_router_solicit *reply,
+ unsigned int length, void *user_data);
+int __connman_inet_ipv6_start_recv_rs(int index,
+ __connman_inet_recv_rs_cb_t callback,
+ void *user_data, void **context);
+void __connman_inet_ipv6_stop_recv_rs(void *context);
+
+int __connman_network_refresh_rs_ipv6(struct connman_network *network, int index);
+
+GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
+ unsigned int length);
+typedef void (*connman_inet_addr_cb_t) (const char *src_address, int index,
+ void *user_data);
+int __connman_inet_get_route(const char *dst_address,
+ connman_inet_addr_cb_t callback, void *user_data);
+
+struct __connman_inet_rtnl_handle {
+ int fd;
+ struct sockaddr_nl local;
+ struct sockaddr_nl peer;
+ __u32 seq;
+ __u32 dump;
+
+ struct {
+ struct nlmsghdr n;
+ union {
+ struct {
+ struct rtmsg rt;
+ } r;
+ struct {
+ struct ifaddrmsg ifa;
+ } i;
+ } u;
+ char buf[1024];
+ } req;
+};
+
+int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth);
+typedef void (*__connman_inet_rtnl_cb_t) (struct nlmsghdr *answer,
+ void *user_data);
+int __connman_inet_rtnl_talk(struct __connman_inet_rtnl_handle *rtnl,
+ struct nlmsghdr *n, int timeout,
+ __connman_inet_rtnl_cb_t callback, void *user_data);
+static inline
+int __connman_inet_rtnl_send(struct __connman_inet_rtnl_handle *rtnl,
+ struct nlmsghdr *n)
+{
+ return __connman_inet_rtnl_talk(rtnl, n, 0, NULL, NULL);
+}
+
+void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth);
+int __connman_inet_rtnl_addattr_l(struct nlmsghdr *n, size_t max_length,
+ int type, const void *data, size_t data_length);
+int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen,
+ int type, __u32 data);
+
+int __connman_inet_add_fwmark_rule(uint32_t table_id, int family, uint32_t fwmark);
+int __connman_inet_del_fwmark_rule(uint32_t table_id, int family, uint32_t fwmark);
+int __connman_inet_add_default_to_table(uint32_t table_id, int ifindex, const char *gateway);
+int __connman_inet_del_default_from_table(uint32_t table_id, int ifindex, const char *gateway);
+int __connman_inet_get_address_netmask(int ifindex,
+ struct sockaddr_in *address, struct sockaddr_in *netmask);
+
+#include <connman/resolver.h>
+
+int __connman_resolver_init(gboolean dnsproxy);
+void __connman_resolver_cleanup(void);
+int __connman_resolvfile_append(int index, const char *domain, const char *server);
+int __connman_resolvfile_remove(int index, const char *domain, const char *server);
+int __connman_resolver_redo_servers(int index);
+
+GKeyFile *__connman_storage_open_global(void);
+GKeyFile *__connman_storage_load_global(void);
+int __connman_storage_save_global(GKeyFile *keyfile);
+void __connman_storage_delete_global(void);
+
+GKeyFile *__connman_storage_load_config(const char *ident);
+GKeyFile *__connman_storage_load_provider_config(const char *ident);
+
+GKeyFile *__connman_storage_open_service(const char *ident);
+int __connman_storage_save_service(GKeyFile *keyfile, const char *ident);
+GKeyFile *__connman_storage_load_provider(const char *identifier);
+void __connman_storage_save_provider(GKeyFile *keyfile, const char *identifier);
+bool __connman_storage_remove_provider(const char *identifier);
+char **__connman_storage_get_providers(void);
+bool __connman_storage_remove_service(const char *service_id);
+
+int __connman_detect_init(void);
+void __connman_detect_cleanup(void);
+
+#include <connman/inotify.h>
+
+int __connman_inotify_init(void);
+void __connman_inotify_cleanup(void);
+
+#include <connman/proxy.h>
+
+int __connman_proxy_init(void);
+void __connman_proxy_cleanup(void);
+
+#include <connman/ipconfig.h>
+
+struct connman_ipaddress {
+ int family;
+ unsigned char prefixlen;
+ char *local;
+ char *peer;
+ char *broadcast;
+ char *gateway;
+};
+
+struct connman_ipconfig_ops {
+ void (*up) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*down) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*lower_up) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*lower_down) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*ip_bound) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*ip_release) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*route_set) (struct connman_ipconfig *ipconfig, const char *ifname);
+ void (*route_unset) (struct connman_ipconfig *ipconfig, const char *ifname);
+};
+
+struct connman_ipconfig *__connman_ipconfig_create(int index,
+ enum connman_ipconfig_type type);
+
+#define __connman_ipconfig_ref(ipconfig) \
+ __connman_ipconfig_ref_debug(ipconfig, __FILE__, __LINE__, __func__)
+#define __connman_ipconfig_unref(ipconfig) \
+ __connman_ipconfig_unref_debug(ipconfig, __FILE__, __LINE__, __func__)
+
+struct connman_ipconfig *
+__connman_ipconfig_ref_debug(struct connman_ipconfig *ipconfig,
+ const char *file, int line, const char *caller);
+void __connman_ipconfig_unref_debug(struct connman_ipconfig *ipconfig,
+ const char *file, int line, const char *caller);
+
+void __connman_ipconfig_clear_address(struct connman_ipconfig *ipconfig);
+void *__connman_ipconfig_get_data(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_data(struct connman_ipconfig *ipconfig, void *data);
+
+int __connman_ipconfig_get_index(struct connman_ipconfig *ipconfig);
+
+void __connman_ipconfig_set_ops(struct connman_ipconfig *ipconfig,
+ const struct connman_ipconfig_ops *ops);
+int __connman_ipconfig_set_method(struct connman_ipconfig *ipconfig,
+ enum connman_ipconfig_method method);
+void __connman_ipconfig_disable_ipv6(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_enable_ipv6(struct connman_ipconfig *ipconfig);
+
+int __connman_ipconfig_init(void);
+void __connman_ipconfig_cleanup(void);
+
+struct rtnl_link_stats;
+
+void __connman_ipconfig_newlink(int index, unsigned short type,
+ unsigned int flags, const char *address,
+ unsigned short mtu,
+ struct rtnl_link_stats *stats);
+void __connman_ipconfig_dellink(int index, struct rtnl_link_stats *stats);
+int __connman_ipconfig_newaddr(int index, int family, const char *label,
+ unsigned char prefixlen, const char *address);
+void __connman_ipconfig_deladdr(int index, int family, const char *label,
+ unsigned char prefixlen, const char *address);
+void __connman_ipconfig_newroute(int index, int family, unsigned char scope,
+ const char *dst, const char *gateway);
+void __connman_ipconfig_delroute(int index, int family, unsigned char scope,
+ const char *dst, const char *gateway);
+
+void __connman_ipconfig_foreach(void (*function) (int index, void *user_data),
+ void *user_data);
+enum connman_ipconfig_type __connman_ipconfig_get_config_type(
+ struct connman_ipconfig *ipconfig);
+unsigned short __connman_ipconfig_get_type_from_index(int index);
+unsigned int __connman_ipconfig_get_flags_from_index(int index);
+const char *__connman_ipconfig_get_gateway_from_index(int index,
+ enum connman_ipconfig_type type);
+void __connman_ipconfig_set_index(struct connman_ipconfig *ipconfig, int index);
+
+const char *__connman_ipconfig_get_local(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_local(struct connman_ipconfig *ipconfig, const char *address);
+const char *__connman_ipconfig_get_peer(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_peer(struct connman_ipconfig *ipconfig, const char *address);
+const char *__connman_ipconfig_get_broadcast(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_broadcast(struct connman_ipconfig *ipconfig, const char *broadcast);
+const char *__connman_ipconfig_get_gateway(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_gateway(struct connman_ipconfig *ipconfig, const char *gateway);
+unsigned char __connman_ipconfig_get_prefixlen(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_prefixlen(struct connman_ipconfig *ipconfig, unsigned char prefixlen);
+
+int __connman_ipconfig_enable(struct connman_ipconfig *ipconfig);
+int __connman_ipconfig_disable(struct connman_ipconfig *ipconfig);
+bool __connman_ipconfig_is_usable(struct connman_ipconfig *ipconfig);
+
+const char *__connman_ipconfig_method2string(enum connman_ipconfig_method method);
+const char *__connman_ipconfig_type2string(enum connman_ipconfig_type type);
+enum connman_ipconfig_method __connman_ipconfig_string2method(const char *method);
+
+void __connman_ipconfig_append_ipv4(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter);
+void __connman_ipconfig_append_ipv4config(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter);
+void __connman_ipconfig_append_ipv6(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter,
+ struct connman_ipconfig *ip4config);
+void __connman_ipconfig_append_ipv6config(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter);
+int __connman_ipconfig_set_config(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *array);
+void __connman_ipconfig_append_ethernet(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter);
+enum connman_ipconfig_method __connman_ipconfig_get_method(
+ struct connman_ipconfig *ipconfig);
+
+int __connman_ipconfig_address_add(struct connman_ipconfig *ipconfig);
+int __connman_ipconfig_address_remove(struct connman_ipconfig *ipconfig);
+int __connman_ipconfig_address_unset(struct connman_ipconfig *ipconfig);
+int __connman_ipconfig_gateway_add(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_gateway_remove(struct connman_ipconfig *ipconfig);
+
+int __connman_ipconfig_set_proxy_autoconfig(struct connman_ipconfig *ipconfig,
+ const char *url);
+const char *__connman_ipconfig_get_proxy_autoconfig(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_dhcp_address(struct connman_ipconfig *ipconfig,
+ const char *address);
+char *__connman_ipconfig_get_dhcp_address(struct connman_ipconfig *ipconfig);
+void __connman_ipconfig_set_dhcpv6_prefixes(struct connman_ipconfig *ipconfig,
+ char **prefixes);
+char **__connman_ipconfig_get_dhcpv6_prefixes(struct connman_ipconfig *ipconfig);
+
+int __connman_ipconfig_load(struct connman_ipconfig *ipconfig,
+ GKeyFile *keyfile, const char *identifier, const char *prefix);
+int __connman_ipconfig_save(struct connman_ipconfig *ipconfig,
+ GKeyFile *keyfile, const char *identifier, const char *prefix);
+bool __connman_ipconfig_ipv6_privacy_enabled(struct connman_ipconfig *ipconfig);
+int __connman_ipconfig_ipv6_reset_privacy(struct connman_ipconfig *ipconfig);
+int __connman_ipconfig_ipv6_set_privacy(struct connman_ipconfig *ipconfig,
+ const char *value);
+bool __connman_ipconfig_ipv6_is_enabled(struct connman_ipconfig *ipconfig);
+
+int __connman_ipconfig_set_rp_filter();
+void __connman_ipconfig_unset_rp_filter(int old_value);
+
+#include <connman/utsname.h>
+
+int __connman_utsname_set_hostname(const char *hostname);
+int __connman_utsname_set_domainname(const char *domainname);
+
+#include <connman/timeserver.h>
+
+int __connman_timeserver_init(void);
+void __connman_timeserver_cleanup(void);
+
+char **__connman_timeserver_system_get();
+
+GSList *__connman_timeserver_add_list(GSList *server_list,
+ const char *timeserver);
+GSList *__connman_timeserver_get_all(struct connman_service *service);
+int __connman_timeserver_sync(struct connman_service *service);
+void __connman_timeserver_sync_next();
+
+enum __connman_dhcpv6_status {
+ CONNMAN_DHCPV6_STATUS_FAIL = 0,
+ CONNMAN_DHCPV6_STATUS_SUCCEED = 1,
+ CONNMAN_DHCPV6_STATUS_RESTART = 2,
+};
+
+typedef void (* dhcpv6_cb) (struct connman_network *network,
+ enum __connman_dhcpv6_status status, gpointer data);
+
+typedef void (* dhcp_cb) (struct connman_ipconfig *ipconfig,
+ struct connman_network *opt_network,
+ bool success, gpointer data);
+char *__connman_dhcp_get_server_address(struct connman_ipconfig *ipconfig);
+int __connman_dhcp_start(struct connman_ipconfig *ipconfig,
+ struct connman_network *network, dhcp_cb callback,
+ gpointer user_data);
+void __connman_dhcp_stop(struct connman_ipconfig *ipconfig);
+int __connman_dhcp_init(void);
+void __connman_dhcp_cleanup(void);
+int __connman_dhcpv6_init(void);
+void __connman_dhcpv6_cleanup(void);
+int __connman_dhcpv6_start_info(struct connman_network *network,
+ dhcpv6_cb callback);
+void __connman_dhcpv6_stop(struct connman_network *network);
+int __connman_dhcpv6_start(struct connman_network *network,
+ GSList *prefixes, dhcpv6_cb callback);
+int __connman_dhcpv6_start_renew(struct connman_network *network,
+ dhcpv6_cb callback);
+int __connman_dhcpv6_start_release(struct connman_network *network,
+ dhcpv6_cb callback);
+int __connman_dhcpv6_start_pd(int index, GSList *prefixes, dhcpv6_cb callback);
+void __connman_dhcpv6_stop_pd(int index);
+int __connman_dhcpv6_start_pd_renew(struct connman_network *network,
+ dhcpv6_cb callback);
+int __connman_dhcpv6_start_pd_release(struct connman_network *network,
+ dhcpv6_cb callback);
+
+int __connman_ipv4_init(void);
+void __connman_ipv4_cleanup(void);
+
+int __connman_connection_init(void);
+void __connman_connection_cleanup(void);
+
+int __connman_connection_gateway_add(struct connman_service *service,
+ const char *gateway,
+ enum connman_ipconfig_type type,
+ const char *peer);
+void __connman_connection_gateway_remove(struct connman_service *service,
+ enum connman_ipconfig_type type);
+int __connman_connection_get_vpn_index(int phy_index);
+
+bool __connman_connection_update_gateway(void);
+void __connman_connection_gateway_activate(struct connman_service *service,
+ enum connman_ipconfig_type type);
+
+int __connman_ntp_start(char *server);
+void __connman_ntp_stop();
+
+int __connman_wpad_init(void);
+void __connman_wpad_cleanup(void);
+int __connman_wpad_start(struct connman_service *service);
+void __connman_wpad_stop(struct connman_service *service);
+
+int __connman_wispr_init(void);
+void __connman_wispr_cleanup(void);
+int __connman_wispr_start(struct connman_service *service,
+ enum connman_ipconfig_type type);
+void __connman_wispr_stop(struct connman_service *service);
+
+#include <connman/technology.h>
+
+void __connman_technology_list_struct(DBusMessageIter *array);
+
+int __connman_technology_add_device(struct connman_device *device);
+int __connman_technology_remove_device(struct connman_device *device);
+int __connman_technology_enabled(enum connman_service_type type);
+int __connman_technology_disabled(enum connman_service_type type);
+int __connman_technology_set_offlinemode(bool offlinemode);
+bool __connman_technology_get_offlinemode(void);
+void __connman_technology_set_connected(enum connman_service_type type,
+ bool connected);
+
+int __connman_technology_add_rfkill(unsigned int index,
+ enum connman_service_type type,
+ bool softblock,
+ bool hardblock);
+int __connman_technology_update_rfkill(unsigned int index,
+ enum connman_service_type type,
+ bool softblock,
+ bool hardblock);
+int __connman_technology_remove_rfkill(unsigned int index,
+ enum connman_service_type type);
+
+void __connman_technology_scan_started(struct connman_device *device);
+void __connman_technology_scan_stopped(struct connman_device *device,
+ enum connman_service_type type);
+void __connman_technology_add_interface(enum connman_service_type type,
+ int index, const char *ident);
+void __connman_technology_remove_interface(enum connman_service_type type,
+ int index, const char *ident);
+void __connman_technology_notify_regdom_by_device(struct connman_device *device,
+ int result, const char *alpha2);
+
+#include <connman/device.h>
+
+int __connman_device_init(const char *device, const char *nodevice);
+void __connman_device_cleanup(void);
+
+void __connman_device_list(DBusMessageIter *iter, void *user_data);
+
+enum connman_service_type __connman_device_get_service_type(struct connman_device *device);
+struct connman_device *__connman_device_find_device(enum connman_service_type type);
+int __connman_device_request_scan(enum connman_service_type type);
+int __connman_device_request_hidden_scan(struct connman_device *device,
+ const char *ssid, unsigned int ssid_len,
+ const char *identity, const char *passphrase,
+ const char *security, void *user_data);
+
+bool __connman_device_isfiltered(const char *devname);
+
+void __connman_device_set_network(struct connman_device *device,
+ struct connman_network *network);
+void __connman_device_cleanup_networks(struct connman_device *device);
+
+int __connman_device_enable(struct connman_device *device);
+int __connman_device_disable(struct connman_device *device);
+int __connman_device_disconnect(struct connman_device *device);
+
+bool __connman_device_has_driver(struct connman_device *device);
+
+const char *__connman_device_get_type(struct connman_device *device);
+
+int __connman_rfkill_init(void);
+void __connman_rfkill_cleanup(void);
+int __connman_rfkill_block(enum connman_service_type type, bool block);
+
+#include <connman/network.h>
+
+int __connman_network_init(void);
+void __connman_network_cleanup(void);
+
+void __connman_network_set_device(struct connman_network *network,
+ struct connman_device *device);
+
+int __connman_network_connect(struct connman_network *network);
+int __connman_network_disconnect(struct connman_network *network, bool user_initiated);
+int __connman_network_clear_ipconfig(struct connman_network *network,
+ struct connman_ipconfig *ipconfig);
+int __connman_network_enable_ipconfig(struct connman_network *network,
+ struct connman_ipconfig *ipconfig);
+
+const char *__connman_network_get_type(struct connman_network *network);
+const char *__connman_network_get_group(struct connman_network *network);
+const char *__connman_network_get_ident(struct connman_network *network);
+bool __connman_network_get_weakness(struct connman_network *network);
+
+int __connman_config_init();
+void __connman_config_cleanup(void);
+
+int __connman_config_load_service(GKeyFile *keyfile, const char *group,
+ bool persistent);
+int __connman_config_provision_service(struct connman_service *service);
+int __connman_config_provision_service_ident(struct connman_service *service,
+ const char *ident, const char *file, const char *entry);
+
+char *__connman_config_get_string(GKeyFile *key_file,
+ const char *group_name, const char *key, GError **error);
+
+char **__connman_config_get_string_list(GKeyFile *key_file,
+ const char *group_name, const char *key, gsize *length, GError **error);
+
+bool __connman_config_get_bool(GKeyFile *key_file,
+ const char *group_name, const char *key, GError **error);
+bool __connman_config_address_provisioned(const char *address,
+ const char *netmask);
+
+int __connman_tethering_init(void);
+void __connman_tethering_cleanup(void);
+
+const char *__connman_tethering_get_bridge(void);
+void __connman_tethering_set_enabled(void);
+void __connman_tethering_set_disabled(void);
+
+int __connman_private_network_request(DBusMessage *msg, const char *owner);
+int __connman_private_network_release(const char *path);
+
+int __connman_ipv6pd_setup(const char *bridge);
+void __connman_ipv6pd_cleanup(void);
+
+#include <connman/provider.h>
+
+bool __connman_provider_check_routes(struct connman_provider *provider);
+int __connman_provider_append_user_route(struct connman_provider *provider,
+ int family, const char *network, const char *netmask);
+void __connman_provider_append_properties(struct connman_provider *provider, DBusMessageIter *iter);
+void __connman_provider_list(DBusMessageIter *iter, void *user_data);
+bool __connman_provider_is_immutable(struct connman_provider *provider);
+int __connman_provider_create_and_connect(DBusMessage *msg);
+const char * __connman_provider_get_ident(struct connman_provider *provider);
+int __connman_provider_indicate_state(struct connman_provider *provider,
+ enum connman_provider_state state);
+int __connman_provider_indicate_error(struct connman_provider *provider,
+ enum connman_provider_error error);
+int __connman_provider_connect(struct connman_provider *provider);
+int __connman_provider_remove_by_path(const char *path);
+void __connman_provider_cleanup(void);
+int __connman_provider_init(void);
+
+#include <connman/service.h>
+
+int __connman_service_init(void);
+void __connman_service_cleanup(void);
+int __connman_service_load_modifiable(struct connman_service *service);
+
+void __connman_service_list_struct(DBusMessageIter *iter);
+
+struct connman_service *__connman_service_lookup_from_index(int index);
+struct connman_service *__connman_service_lookup_from_ident(const char *identifier);
+struct connman_service *__connman_service_create_from_network(struct connman_network *network);
+struct connman_service *__connman_service_create_from_provider(struct connman_provider *provider);
+bool __connman_service_index_is_default(int index);
+struct connman_service *__connman_service_get_default(void);
+void __connman_service_update_from_network(struct connman_network *network);
+void __connman_service_remove_from_network(struct connman_network *network);
+void __connman_service_read_ip4config(struct connman_service *service);
+void __connman_service_read_ip6config(struct connman_service *service);
+
+struct connman_ipconfig *__connman_service_get_ip4config(
+ struct connman_service *service);
+struct connman_ipconfig *__connman_service_get_ip6config(
+ struct connman_service *service);
+struct connman_ipconfig *__connman_service_get_ipconfig(
+ struct connman_service *service, int family);
+bool __connman_service_is_connected_state(struct connman_service *service,
+ enum connman_ipconfig_type type);
+const char *__connman_service_get_ident(struct connman_service *service);
+const char *__connman_service_get_path(struct connman_service *service);
+const char *__connman_service_get_name(struct connman_service *service);
+unsigned int __connman_service_get_order(struct connman_service *service);
+enum connman_service_state __connman_service_get_state(struct connman_service *service);
+void __connman_service_update_ordering(void);
+struct connman_network *__connman_service_get_network(struct connman_service *service);
+enum connman_service_security __connman_service_get_security(struct connman_service *service);
+const char *__connman_service_get_phase2(struct connman_service *service);
+bool __connman_service_wps_enabled(struct connman_service *service);
+int __connman_service_set_favorite(struct connman_service *service,
+ bool favorite);
+int __connman_service_set_favorite_delayed(struct connman_service *service,
+ bool favorite,
+ bool delay_ordering);
+int __connman_service_set_immutable(struct connman_service *service,
+ bool immutable);
+int __connman_service_set_ignore(struct connman_service *service,
+ bool ignore);
+void __connman_service_set_search_domains(struct connman_service *service,
+ char **domains);
+
+void __connman_service_set_string(struct connman_service *service,
+ const char *key, const char *value);
+int __connman_service_online_check_failed(struct connman_service *service,
+ enum connman_ipconfig_type type);
+int __connman_service_ipconfig_indicate_state(struct connman_service *service,
+ enum connman_service_state new_state,
+ enum connman_ipconfig_type type);
+enum connman_service_state __connman_service_ipconfig_get_state(
+ struct connman_service *service,
+ enum connman_ipconfig_type type);
+
+int __connman_service_indicate_error(struct connman_service *service,
+ enum connman_service_error error);
+int __connman_service_clear_error(struct connman_service *service);
+int __connman_service_indicate_default(struct connman_service *service);
+
+int __connman_service_connect(struct connman_service *service,
+ enum connman_service_connect_reason reason);
+int __connman_service_disconnect(struct connman_service *service);
+int __connman_service_disconnect_all(void);
+int __connman_service_needs_input(struct connman_service *service);
+void __connman_service_set_active_session(bool enable, GSList *list);
+void __connman_service_auto_connect(enum connman_service_connect_reason reason);
+bool __connman_service_remove(struct connman_service *service);
+bool __connman_service_is_provider_pending(struct connman_service *service);
+void __connman_service_set_provider_pending(struct connman_service *service,
+ DBusMessage *msg);
+void __connman_service_set_hidden_data(struct connman_service *service,
+ gpointer user_data);
+void __connman_service_return_error(struct connman_service *service,
+ int error, gpointer user_data);
+
+int __connman_service_provision_changed(const char *ident);
+void __connman_service_set_config(struct connman_service *service,
+ const char *file_id, const char *section);
+
+const char *__connman_service_type2string(enum connman_service_type type);
+enum connman_service_type __connman_service_string2type(const char *str);
+enum connman_service_security __connman_service_string2security(const char *str);
+
+int __connman_service_nameserver_append(struct connman_service *service,
+ const char *nameserver, bool is_auto);
+int __connman_service_nameserver_remove(struct connman_service *service,
+ const char *nameserver, bool is_auto);
+void __connman_service_nameserver_clear(struct connman_service *service);
+void __connman_service_nameserver_add_routes(struct connman_service *service,
+ const char *gw);
+void __connman_service_nameserver_del_routes(struct connman_service *service,
+ enum connman_ipconfig_type type);
+void __connman_service_set_timeservers(struct connman_service *service,
+ char **timeservers);
+int __connman_service_timeserver_append(struct connman_service *service,
+ const char *timeserver);
+int __connman_service_timeserver_remove(struct connman_service *service,
+ const char *timeserver);
+void __connman_service_timeserver_changed(struct connman_service *service,
+ GSList *ts_list);
+void __connman_service_set_pac(struct connman_service *service,
+ const char *pac);
+bool __connman_service_is_hidden(struct connman_service *service);
+bool __connman_service_is_split_routing(struct connman_service *service);
+bool __connman_service_index_is_split_routing(int index);
+int __connman_service_get_index(struct connman_service *service);
+void __connman_service_set_hidden(struct connman_service *service);
+void __connman_service_set_hostname(struct connman_service *service,
+ const char *hostname);
+const char *__connman_service_get_hostname(struct connman_service *service);
+void __connman_service_set_domainname(struct connman_service *service,
+ const char *domainname);
+const char *__connman_service_get_nameserver(struct connman_service *service);
+void __connman_service_set_proxy_autoconfig(struct connman_service *service,
+ const char *url);
+
+void __connman_service_set_identity(struct connman_service *service,
+ const char *identity);
+void __connman_service_set_agent_identity(struct connman_service *service,
+ const char *agent_identity);
+int __connman_service_set_passphrase(struct connman_service *service,
+ const char *passphrase);
+const char *__connman_service_get_passphrase(struct connman_service *service);
+int __connman_service_reset_ipconfig(struct connman_service *service,
+ enum connman_ipconfig_type type, DBusMessageIter *array,
+ enum connman_service_state *new_state);
+
+void __connman_service_notify(struct connman_service *service,
+ unsigned int rx_packets, unsigned int tx_packets,
+ unsigned int rx_bytes, unsigned int tx_bytes,
+ unsigned int rx_error, unsigned int tx_error,
+ unsigned int rx_dropped, unsigned int tx_dropped);
+
+int __connman_service_counter_register(const char *counter);
+void __connman_service_counter_unregister(const char *counter);
+
+#include <connman/peer.h>
+
+int __connman_peer_init(void);
+void __connman_peer_cleanup(void);
+
+void __connman_peer_list_struct(DBusMessageIter *array);
+const char *__connman_peer_get_path(struct connman_peer *peer);
+
+int __connman_peer_service_init(void);
+void __connman_peer_service_cleanup(void);
+
+void __connman_peer_service_set_driver(struct connman_peer_driver *driver);
+int __connman_peer_service_register(const char *owner, DBusMessage *msg,
+ const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version,
+ bool master);
+int __connman_peer_service_unregister(const char *owner,
+ const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version);
+
+#include <connman/session.h>
+
+typedef void (* service_iterate_cb) (struct connman_service *service,
+ void *user_data);
+
+int __connman_service_iterate_services(service_iterate_cb cb, void *user_data);
+
+void __connman_service_mark_dirty();
+void __connman_service_save(struct connman_service *service);
+
+#include <connman/notifier.h>
+
+int __connman_technology_init(void);
+void __connman_technology_cleanup(void);
+
+int __connman_notifier_init(void);
+void __connman_notifier_cleanup(void);
+
+void __connman_notifier_service_add(struct connman_service *service,
+ const char *name);
+void __connman_notifier_service_remove(struct connman_service *service);
+void __connman_notifier_enter_online(enum connman_service_type type);
+void __connman_notifier_leave_online(enum connman_service_type type);
+void __connman_notifier_connect(enum connman_service_type type);
+void __connman_notifier_disconnect(enum connman_service_type type);
+void __connman_notifier_offlinemode(bool enabled);
+void __connman_notifier_default_changed(struct connman_service *service);
+void __connman_notifier_proxy_changed(struct connman_service *service);
+void __connman_notifier_service_state_changed(struct connman_service *service,
+ enum connman_service_state state);
+void __connman_notifier_ipconfig_changed(struct connman_service *service,
+ struct connman_ipconfig *ipconfig);
+void __connman_notifier_sleep_event(void *identifier, bool cansleep,
+ time_t valid_until);
+
+bool __connman_notifier_is_connected(void);
+const char *__connman_notifier_get_state(void);
+
+#include <connman/rtnl.h>
+
+int __connman_rtnl_init(void);
+void __connman_rtnl_start(void);
+void __connman_rtnl_cleanup(void);
+
+enum connman_device_type __connman_rtnl_get_device_type(int index);
+unsigned int __connman_rtnl_update_interval_add(unsigned int interval);
+unsigned int __connman_rtnl_update_interval_remove(unsigned int interval);
+int __connman_rtnl_request_update(void);
+int __connman_rtnl_send(const void *buf, size_t len);
+
+bool __connman_session_policy_autoconnect(enum connman_service_connect_reason reason);
+
+int __connman_session_create(DBusMessage *msg);
+int __connman_session_destroy(DBusMessage *msg);
+
+int __connman_session_init(void);
+void __connman_session_cleanup(void);
+
+struct connman_stats_data {
+ unsigned int rx_packets;
+ unsigned int tx_packets;
+ unsigned int rx_bytes;
+ unsigned int tx_bytes;
+ unsigned int rx_errors;
+ unsigned int tx_errors;
+ unsigned int rx_dropped;
+ unsigned int tx_dropped;
+ unsigned int time;
+};
+
+int __connman_stats_init(void);
+void __connman_stats_cleanup(void);
+int __connman_stats_service_register(struct connman_service *service);
+void __connman_stats_service_unregister(struct connman_service *service);
+int __connman_stats_update(struct connman_service *service,
+ bool roaming,
+ struct connman_stats_data *data);
+int __connman_stats_get(struct connman_service *service,
+ bool roaming,
+ struct connman_stats_data *data);
+
+int __connman_iptables_dump(const char *table_name);
+int __connman_iptables_new_chain(const char *table_name,
+ const char *chain);
+int __connman_iptables_delete_chain(const char *table_name,
+ const char *chain);
+int __connman_iptables_flush_chain(const char *table_name,
+ const char *chain);
+int __connman_iptables_change_policy(const char *table_name,
+ const char *chain,
+ const char *policy);
+int __connman_iptables_append(const char *table_name,
+ const char *chain,
+ const char *rule_spec);
+int __connman_iptables_insert(const char *table_name,
+ const char *chain,
+ const char *rule_spec);
+int __connman_iptables_delete(const char *table_name,
+ const char *chain,
+ const char *rule_spec);
+
+typedef void (*connman_iptables_iterate_chains_cb_t) (const char *chain_name,
+ void *user_data);
+int __connman_iptables_iterate_chains(const char *table_name,
+ connman_iptables_iterate_chains_cb_t cb,
+ void *user_data);
+
+int __connman_iptables_init(void);
+void __connman_iptables_cleanup(void);
+int __connman_iptables_commit(const char *table_name);
+
+int __connman_dnsproxy_init(void);
+void __connman_dnsproxy_cleanup(void);
+int __connman_dnsproxy_add_listener(int index);
+void __connman_dnsproxy_remove_listener(int index);
+int __connman_dnsproxy_append(int index, const char *domain, const char *server);
+int __connman_dnsproxy_remove(int index, const char *domain, const char *server);
+
+int __connman_6to4_probe(struct connman_service *service);
+void __connman_6to4_remove(struct connman_ipconfig *ipconfig);
+int __connman_6to4_check(struct connman_ipconfig *ipconfig);
+
+struct connman_ippool;
+
+typedef void (*ippool_collision_cb_t) (struct connman_ippool *pool,
+ void *user_data);
+
+int __connman_ippool_init(void);
+void __connman_ippool_cleanup(void);
+
+#define __connman_ippool_ref(ipconfig) \
+ __connman_ippool_ref_debug(ipconfig, __FILE__, __LINE__, __func__)
+#define __connman_ippool_unref(ipconfig) \
+ __connman_ippool_unref_debug(ipconfig, __FILE__, __LINE__, __func__)
+
+struct connman_ippool *__connman_ippool_ref_debug(struct connman_ippool *pool,
+ const char *file, int line, const char *caller);
+void __connman_ippool_unref_debug(struct connman_ippool *pool,
+ const char *file, int line, const char *caller);
+
+struct connman_ippool *__connman_ippool_create(int index,
+ unsigned int start,
+ unsigned int range,
+ ippool_collision_cb_t collision_cb,
+ void *user_data);
+
+const char *__connman_ippool_get_gateway(struct connman_ippool *pool);
+const char *__connman_ippool_get_broadcast(struct connman_ippool *pool);
+const char *__connman_ippool_get_subnet_mask(struct connman_ippool *pool);
+const char *__connman_ippool_get_start_ip(struct connman_ippool *pool);
+const char *__connman_ippool_get_end_ip(struct connman_ippool *pool);
+
+void __connman_ippool_newaddr(int index, const char *address,
+ unsigned char prefixlen);
+void __connman_ippool_deladdr(int index, const char *address,
+ unsigned char prefixlen);
+
+int __connman_bridge_create(const char *name);
+int __connman_bridge_remove(const char *name);
+int __connman_bridge_enable(const char *name, const char *ip_address,
+ int prefix_len, const char *broadcast);
+int __connman_bridge_disable(const char *name);
+
+int __connman_nat_init(void);
+void __connman_nat_cleanup(void);
+
+int __connman_nat_enable(const char *name, const char *address,
+ unsigned char prefixlen);
+void __connman_nat_disable(const char *name);
+
+struct firewall_context;
+
+struct firewall_context *__connman_firewall_create(void);
+void __connman_firewall_destroy(struct firewall_context *ctx);
+int __connman_firewall_add_rule(struct firewall_context *ctx,
+ const char *table,
+ const char *chain,
+ const char *rule_fmt, ...);
+int __connman_firewall_enable(struct firewall_context *ctx);
+int __connman_firewall_disable(struct firewall_context *ctx);
+bool __connman_firewall_is_up(void);
+
+int __connman_firewall_init(void);
+void __connman_firewall_cleanup(void);
+
+typedef int (* connman_nfacct_flush_cb_t) (unsigned int error, void *user_data);
+
+int __connman_nfacct_flush(connman_nfacct_flush_cb_t cb, void *user_data);
+
+struct nfacct_context;
+
+typedef void (* connman_nfacct_enable_cb_t) (unsigned int error,
+ struct nfacct_context *ctx,
+ void *user_data);
+typedef void (* connman_nfacct_disable_cb_t) (unsigned int error,
+ struct nfacct_context *ctx,
+ void *user_data);
+typedef void (* connman_nfacct_stats_cb_t) (struct nfacct_context *ctx,
+ uint64_t packets,
+ uint64_t bytes,
+ void *user_data);
+
+struct nfacct_context *__connman_nfacct_create_context(void);
+void __connman_nfacct_destroy_context(struct nfacct_context *ctx);
+
+int __connman_nfacct_add(struct nfacct_context *ctx, const char *name,
+ connman_nfacct_stats_cb_t cb,
+ void *user_data);
+int __connman_nfacct_enable(struct nfacct_context *ctx,
+ connman_nfacct_enable_cb_t cb,
+ void *user_data);
+int __connman_nfacct_disable(struct nfacct_context *ctx,
+ connman_nfacct_disable_cb_t cb,
+ void *user_data);
+
+void __connman_nfacct_cleanup(void);
+
+#include <connman/machine.h>
+
+int __connman_machine_init(void);
+void __connman_machine_cleanup(void);
+
+int __connman_util_get_random(uint64_t *val);
+int __connman_util_init(void);
+void __connman_util_cleanup(void);
+int __connman_rlimits_init(const gchar *path);
diff --git a/src/connman.service.in b/src/connman.service.in
new file mode 100644
index 0000000..ba4dedd
--- /dev/null
+++ b/src/connman.service.in
@@ -0,0 +1,16 @@
+[Unit]
+Description=Connection service
+Requires=dbus.socket
+After=dbus.socket
+Before=remote-fs-pre.target
+Wants=remote-fs-pre.target
+
+[Service]
+Type=dbus
+BusName=net.connman
+Restart=on-failure
+ExecStart=@sbindir@/connmand -n
+StandardOutput=null
+
+[Install]
+WantedBy=multi-user.target
diff --git a/src/connman.ver b/src/connman.ver
new file mode 100644
index 0000000..03a0eec
--- /dev/null
+++ b/src/connman.ver
@@ -0,0 +1,7 @@
+{
+ global:
+ connman_*;
+ g_dbus_*;
+ local:
+ *;
+};
diff --git a/src/counter.c b/src/counter.c
new file mode 100644
index 0000000..8ea6205
--- /dev/null
+++ b/src/counter.c
@@ -0,0 +1,200 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+static DBusConnection *connection;
+
+static GHashTable *counter_table;
+static GHashTable *owner_mapping;
+
+struct connman_counter {
+ char *owner;
+ char *path;
+ unsigned int interval;
+ guint watch;
+};
+
+static void remove_counter(gpointer user_data)
+{
+ struct connman_counter *counter = user_data;
+
+ DBG("owner %s path %s", counter->owner, counter->path);
+
+ __connman_rtnl_update_interval_remove(counter->interval);
+
+ __connman_service_counter_unregister(counter->path);
+
+ g_free(counter->owner);
+ g_free(counter->path);
+ g_free(counter);
+}
+
+static void owner_disconnect(DBusConnection *conn, void *user_data)
+{
+ struct connman_counter *counter = user_data;
+
+ DBG("owner %s path %s", counter->owner, counter->path);
+
+ g_hash_table_remove(owner_mapping, counter->owner);
+ g_hash_table_remove(counter_table, counter->path);
+}
+
+int __connman_counter_register(const char *owner, const char *path,
+ unsigned int interval)
+{
+ struct connman_counter *counter;
+ int err;
+
+ DBG("owner %s path %s interval %u", owner, path, interval);
+
+ counter = g_hash_table_lookup(counter_table, path);
+ if (counter)
+ return -EEXIST;
+
+ counter = g_try_new0(struct connman_counter, 1);
+ if (!counter)
+ return -ENOMEM;
+
+ counter->owner = g_strdup(owner);
+ counter->path = g_strdup(path);
+
+ err = __connman_service_counter_register(counter->path);
+ if (err < 0) {
+ g_free(counter->owner);
+ g_free(counter->path);
+ g_free(counter);
+ return err;
+ }
+
+ g_hash_table_replace(counter_table, counter->path, counter);
+ g_hash_table_replace(owner_mapping, counter->owner, counter);
+
+ counter->interval = interval;
+ __connman_rtnl_update_interval_add(counter->interval);
+
+ counter->watch = g_dbus_add_disconnect_watch(connection, owner,
+ owner_disconnect, counter, NULL);
+
+ return 0;
+}
+
+int __connman_counter_unregister(const char *owner, const char *path)
+{
+ struct connman_counter *counter;
+
+ DBG("owner %s path %s", owner, path);
+
+ counter = g_hash_table_lookup(counter_table, path);
+ if (!counter)
+ return -ESRCH;
+
+ if (g_strcmp0(owner, counter->owner) != 0)
+ return -EACCES;
+
+ if (counter->watch > 0)
+ g_dbus_remove_watch(connection, counter->watch);
+
+ g_hash_table_remove(owner_mapping, counter->owner);
+ g_hash_table_remove(counter_table, counter->path);
+
+ return 0;
+}
+
+void __connman_counter_send_usage(const char *path,
+ DBusMessage *message)
+{
+ struct connman_counter *counter;
+
+ counter = g_hash_table_lookup(counter_table, path);
+ if (!counter) {
+ if (message)
+ dbus_message_unref(message);
+ return;
+ }
+
+ dbus_message_set_destination(message, counter->owner);
+ dbus_message_set_path(message, counter->path);
+ dbus_message_set_interface(message, CONNMAN_COUNTER_INTERFACE);
+ dbus_message_set_member(message, "Usage");
+ dbus_message_set_no_reply(message, TRUE);
+
+ g_dbus_send_message(connection, message);
+}
+
+static void release_counter(gpointer key, gpointer value, gpointer user_data)
+{
+ struct connman_counter *counter = value;
+ DBusMessage *message;
+
+ DBG("owner %s path %s", counter->owner, counter->path);
+
+ if (counter->watch > 0)
+ g_dbus_remove_watch(connection, counter->watch);
+
+ message = dbus_message_new_method_call(counter->owner, counter->path,
+ CONNMAN_COUNTER_INTERFACE, "Release");
+ if (!message)
+ return;
+
+ dbus_message_set_no_reply(message, TRUE);
+
+ g_dbus_send_message(connection, message);
+}
+
+int __connman_counter_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ counter_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_counter);
+ owner_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ return 0;
+}
+
+void __connman_counter_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ g_hash_table_foreach(counter_table, release_counter, NULL);
+
+ g_hash_table_destroy(owner_mapping);
+ g_hash_table_destroy(counter_table);
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/dbus.c b/src/dbus.c
new file mode 100644
index 0000000..d80a46c
--- /dev/null
+++ b/src/dbus.c
@@ -0,0 +1,710 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+#include <gdbus.h>
+
+#include "connman.h"
+
+dbus_bool_t connman_dbus_validate_ident(const char *ident)
+{
+ unsigned int i;
+
+ if (!ident)
+ return FALSE;
+
+ for (i = 0; i < strlen(ident); i++) {
+ if (ident[i] >= '0' && ident[i] <= '9')
+ continue;
+ if (ident[i] >= 'a' && ident[i] <= 'z')
+ continue;
+ if (ident[i] >= 'A' && ident[i] <= 'Z')
+ continue;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+char *connman_dbus_encode_string(const char *value)
+{
+ GString *str;
+ unsigned int i, size;
+
+ if (!value)
+ return NULL;
+
+ size = strlen(value);
+
+ str = g_string_new(NULL);
+ if (!str)
+ return NULL;
+
+ for (i = 0; i < size; i++) {
+ const char tmp = value[i];
+ if ((tmp < '0' || tmp > '9') && (tmp < 'A' || tmp > 'Z') &&
+ (tmp < 'a' || tmp > 'z'))
+ g_string_append_printf(str, "_%02x", tmp);
+ else
+ str = g_string_append_c(str, tmp);
+ }
+
+ return g_string_free(str, FALSE);
+}
+
+void connman_dbus_property_append_basic(DBusMessageIter *iter,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter value;
+ const char *signature;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ switch (type) {
+ case DBUS_TYPE_BOOLEAN:
+ signature = DBUS_TYPE_BOOLEAN_AS_STRING;
+ break;
+ case DBUS_TYPE_STRING:
+ signature = DBUS_TYPE_STRING_AS_STRING;
+ break;
+ case DBUS_TYPE_BYTE:
+ signature = DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT16:
+ signature = DBUS_TYPE_UINT16_AS_STRING;
+ break;
+ case DBUS_TYPE_INT16:
+ signature = DBUS_TYPE_INT16_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT32:
+ signature = DBUS_TYPE_UINT32_AS_STRING;
+ break;
+ case DBUS_TYPE_INT32:
+ signature = DBUS_TYPE_INT32_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT64:
+ signature = DBUS_TYPE_UINT64_AS_STRING;
+ break;
+ case DBUS_TYPE_INT64:
+ signature = DBUS_TYPE_INT64_AS_STRING;
+ break;
+ case DBUS_TYPE_OBJECT_PATH:
+ signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ break;
+ default:
+ signature = DBUS_TYPE_VARIANT_AS_STRING;
+ break;
+ }
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ signature, &value);
+ dbus_message_iter_append_basic(&value, type, val);
+ dbus_message_iter_close_container(iter, &value);
+}
+
+void connman_dbus_property_append_dict(DBusMessageIter *iter, const char *key,
+ connman_dbus_append_cb_t function, void *user_data)
+{
+ DBusMessageIter value, dict;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &value);
+
+ connman_dbus_dict_open(&value, &dict);
+ if (function)
+ function(&dict, user_data);
+ connman_dbus_dict_close(&value, &dict);
+
+ dbus_message_iter_close_container(iter, &value);
+}
+
+void connman_dbus_property_append_fixed_array(DBusMessageIter *iter,
+ const char *key, int type, void *val, int len)
+{
+ DBusMessageIter value, array;
+ const char *variant_sig, *array_sig;
+
+ switch (type) {
+ case DBUS_TYPE_BYTE:
+ variant_sig = DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_BYTE_AS_STRING;
+ array_sig = DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ default:
+ return;
+ }
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ variant_sig, &value);
+
+ dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
+ array_sig, &array);
+ dbus_message_iter_append_fixed_array(&array, type, val, len);
+ dbus_message_iter_close_container(&value, &array);
+
+ dbus_message_iter_close_container(iter, &value);
+}
+
+void connman_dbus_property_append_array(DBusMessageIter *iter,
+ const char *key, int type,
+ connman_dbus_append_cb_t function, void *user_data)
+{
+ DBusMessageIter value, array;
+ const char *variant_sig, *array_sig;
+
+ switch (type) {
+ case DBUS_TYPE_STRING:
+ variant_sig = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING;
+ array_sig = DBUS_TYPE_STRING_AS_STRING;
+ break;
+ case DBUS_TYPE_OBJECT_PATH:
+ variant_sig = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ array_sig = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ break;
+ case DBUS_TYPE_DICT_ENTRY:
+ variant_sig = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING;
+ array_sig = DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING;
+ break;
+ default:
+ return;
+ }
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ variant_sig, &value);
+
+ dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY,
+ array_sig, &array);
+ if (function)
+ function(&array, user_data);
+ dbus_message_iter_close_container(&value, &array);
+
+ dbus_message_iter_close_container(iter, &value);
+}
+
+static DBusConnection *connection = NULL;
+
+dbus_bool_t connman_dbus_property_changed_basic(const char *path,
+ const char *interface, const char *key,
+ int type, void *val)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ if (!path)
+ return FALSE;
+
+ signal = dbus_message_new_signal(path, interface, "PropertyChanged");
+ if (!signal)
+ return FALSE;
+
+ dbus_message_iter_init_append(signal, &iter);
+ connman_dbus_property_append_basic(&iter, key, type, val);
+
+ g_dbus_send_message(connection, signal);
+
+ return TRUE;
+}
+
+dbus_bool_t connman_dbus_property_changed_dict(const char *path,
+ const char *interface, const char *key,
+ connman_dbus_append_cb_t function, void *user_data)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ if (!path)
+ return FALSE;
+
+ signal = dbus_message_new_signal(path, interface, "PropertyChanged");
+ if (!signal)
+ return FALSE;
+
+ dbus_message_iter_init_append(signal, &iter);
+ connman_dbus_property_append_dict(&iter, key, function, user_data);
+
+ g_dbus_send_message(connection, signal);
+
+ return TRUE;
+}
+
+dbus_bool_t connman_dbus_property_changed_array(const char *path,
+ const char *interface, const char *key, int type,
+ connman_dbus_append_cb_t function, void *user_data)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ if (!path)
+ return FALSE;
+
+ signal = dbus_message_new_signal(path, interface, "PropertyChanged");
+ if (!signal)
+ return FALSE;
+
+ dbus_message_iter_init_append(signal, &iter);
+ connman_dbus_property_append_array(&iter, key, type,
+ function, user_data);
+
+ g_dbus_send_message(connection, signal);
+
+ return TRUE;
+}
+
+dbus_bool_t connman_dbus_setting_changed_basic(const char *owner,
+ const char *path, const char *key,
+ int type, void *val)
+{
+ DBusMessage *msg;
+ DBusMessageIter array, dict;
+
+ if (!owner || !path)
+ return FALSE;
+
+ msg = dbus_message_new_method_call(owner, path,
+ CONNMAN_NOTIFICATION_INTERFACE,
+ "Update");
+ if (!msg)
+ return FALSE;
+
+ dbus_message_iter_init_append(msg, &array);
+ connman_dbus_dict_open(&array, &dict);
+
+ connman_dbus_dict_append_basic(&dict, key, type, val);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ g_dbus_send_message(connection, msg);
+
+ return TRUE;
+}
+
+dbus_bool_t connman_dbus_setting_changed_dict(const char *owner,
+ const char *path, const char *key,
+ connman_dbus_append_cb_t function,
+ void *user_data)
+{
+ DBusMessage *msg;
+ DBusMessageIter array, dict;
+
+ if (!owner || !path)
+ return FALSE;
+
+ msg = dbus_message_new_method_call(owner, path,
+ CONNMAN_NOTIFICATION_INTERFACE,
+ "Update");
+ if (!msg)
+ return FALSE;
+
+ dbus_message_iter_init_append(msg, &array);
+ connman_dbus_dict_open(&array, &dict);
+
+ connman_dbus_dict_append_dict(&dict, key, function, user_data);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ g_dbus_send_message(connection, msg);
+
+ return TRUE;
+}
+
+dbus_bool_t connman_dbus_setting_changed_array(const char *owner,
+ const char *path, const char *key, int type,
+ connman_dbus_append_cb_t function,
+ void *user_data)
+{
+ DBusMessage *msg;
+ DBusMessageIter array, dict;
+
+ if (!owner || !path)
+ return FALSE;
+
+ msg = dbus_message_new_method_call(owner, path,
+ CONNMAN_NOTIFICATION_INTERFACE,
+ "Update");
+ if (!msg)
+ return FALSE;
+
+ dbus_message_iter_init_append(msg, &array);
+ connman_dbus_dict_open(&array, &dict);
+
+ connman_dbus_dict_append_array(&dict, key, type, function, user_data);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ g_dbus_send_message(connection, msg);
+
+ return TRUE;
+}
+
+dbus_bool_t __connman_dbus_append_objpath_dict_array(DBusMessage *msg,
+ connman_dbus_append_cb_t function, void *user_data)
+{
+ DBusMessageIter iter, array;
+
+ if (!msg || !function)
+ return FALSE;
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_STRUCT_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_OBJECT_PATH_AS_STRING
+ DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING
+ DBUS_STRUCT_END_CHAR_AS_STRING, &array);
+
+ function(&array, user_data);
+
+ dbus_message_iter_close_container(&iter, &array);
+
+ return TRUE;
+}
+
+dbus_bool_t __connman_dbus_append_objpath_array(DBusMessage *msg,
+ connman_dbus_append_cb_t function, void *user_data)
+{
+ DBusMessageIter iter, array;
+
+ if (!msg || !function)
+ return FALSE;
+
+ dbus_message_iter_init_append(msg, &iter);
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+ DBUS_TYPE_OBJECT_PATH_AS_STRING, &array);
+
+ function(&array, user_data);
+
+ dbus_message_iter_close_container(&iter, &array);
+
+ return TRUE;
+}
+
+struct callback_data {
+ void *cb;
+ void *user_data;
+};
+
+static void get_connection_unix_user_reply(DBusPendingCall *call,
+ void *user_data)
+{
+ struct callback_data *data = user_data;
+ connman_dbus_get_connection_unix_user_cb_t cb = data->cb;
+ DBusMessageIter iter;
+ DBusMessage *reply;
+ int err = 0;
+ unsigned int uid = 0;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ DBG("Failed to retrieve UID");
+ err = -EIO;
+ goto done;
+ }
+
+ if (!dbus_message_has_signature(reply, "u")) {
+ DBG("Message signature is wrong");
+ err = -EINVAL;
+ goto done;
+ }
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_get_basic(&iter, &uid);
+
+done:
+ (*cb)(uid, data->user_data, err);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int connman_dbus_get_connection_unix_user(DBusConnection *connection,
+ const char *bus_name,
+ connman_dbus_get_connection_unix_user_cb_t func,
+ void *user_data)
+{
+ struct callback_data *data;
+ DBusPendingCall *call;
+ DBusMessage *msg = NULL;
+ int err;
+
+ data = g_try_new0(struct callback_data, 1);
+ if (!data) {
+ DBG("Can't allocate data structure");
+ return -ENOMEM;
+ }
+
+ msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "GetConnectionUnixUser");
+ if (!msg) {
+ DBG("Can't allocate new message");
+ err = -ENOMEM;
+ goto err;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &bus_name,
+ DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
+ DBG("Failed to execute method call");
+ err = -EINVAL;
+ goto err;
+ }
+
+ if (!call) {
+ DBG("D-Bus connection not available");
+ err = -EINVAL;
+ goto err;
+ }
+
+ data->cb = func;
+ data->user_data = user_data;
+
+ dbus_pending_call_set_notify(call, get_connection_unix_user_reply,
+ data, g_free);
+
+ dbus_message_unref(msg);
+
+ return 0;
+
+err:
+ dbus_message_unref(msg);
+ g_free(data);
+
+ return err;
+}
+
+static unsigned char *parse_context(DBusMessage *msg)
+{
+ DBusMessageIter iter, array;
+ unsigned char *ctx, *p;
+ int size = 0;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_BYTE) {
+ size++;
+
+ dbus_message_iter_next(&array);
+ }
+
+ if (size == 0)
+ return NULL;
+
+ ctx = g_try_malloc0(size + 1);
+ if (!ctx)
+ return NULL;
+
+ p = ctx;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_BYTE) {
+ dbus_message_iter_get_basic(&array, p);
+
+ p++;
+ dbus_message_iter_next(&array);
+ }
+
+ return ctx;
+}
+
+static void selinux_get_context_reply(DBusPendingCall *call, void *user_data)
+{
+ struct callback_data *data = user_data;
+ connman_dbus_get_context_cb_t cb = data->cb;
+ DBusMessage *reply;
+ unsigned char *context = NULL;
+ int err = 0;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ DBG("Failed to retrieve SELinux context");
+ err = -EIO;
+ goto done;
+ }
+
+ if (!dbus_message_has_signature(reply, "ay")) {
+ DBG("Message signature is wrong");
+ err = -EINVAL;
+ goto done;
+ }
+
+ context = parse_context(reply);
+
+done:
+ (*cb)(context, data->user_data, err);
+
+ g_free(context);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int connman_dbus_get_selinux_context(DBusConnection *connection,
+ const char *service,
+ connman_dbus_get_context_cb_t func,
+ void *user_data)
+{
+ struct callback_data *data;
+ DBusPendingCall *call;
+ DBusMessage *msg = NULL;
+ int err;
+
+ if (!func)
+ return -EINVAL;
+
+ data = g_try_new0(struct callback_data, 1);
+ if (!data) {
+ DBG("Can't allocate data structure");
+ return -ENOMEM;
+ }
+
+ msg = dbus_message_new_method_call(DBUS_SERVICE_DBUS, DBUS_PATH_DBUS,
+ DBUS_INTERFACE_DBUS,
+ "GetConnectionSELinuxSecurityContext");
+ if (!msg) {
+ DBG("Can't allocate new message");
+ err = -ENOMEM;
+ goto err;
+ }
+
+ dbus_message_append_args(msg, DBUS_TYPE_STRING, &service,
+ DBUS_TYPE_INVALID);
+
+ if (!dbus_connection_send_with_reply(connection, msg, &call, -1)) {
+ DBG("Failed to execute method call");
+ err = -EINVAL;
+ goto err;
+ }
+
+ if (!call) {
+ DBG("D-Bus connection not available");
+ err = -EINVAL;
+ goto err;
+ }
+
+ data->cb = func;
+ data->user_data = user_data;
+
+ dbus_pending_call_set_notify(call, selinux_get_context_reply,
+ data, g_free);
+
+ dbus_message_unref(msg);
+
+ return 0;
+
+err:
+ dbus_message_unref(msg);
+ g_free(data);
+
+ return err;
+}
+
+void connman_dbus_reply_pending(DBusMessage *pending,
+ int error, const char *path)
+{
+ if (pending) {
+ if (error > 0) {
+ DBusMessage *reply;
+
+ reply = __connman_error_failed(pending, error);
+ if (reply)
+ g_dbus_send_message(connection, reply);
+ } else {
+ const char *sender;
+
+ sender = dbus_message_get_interface(pending);
+ if (!path)
+ path = dbus_message_get_path(pending);
+
+ DBG("sender %s path %s", sender, path);
+
+ if (g_strcmp0(sender, CONNMAN_MANAGER_INTERFACE) == 0)
+ g_dbus_send_reply(connection, pending,
+ DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+ else
+ g_dbus_send_reply(connection, pending,
+ DBUS_TYPE_INVALID);
+ }
+
+ dbus_message_unref(pending);
+ }
+}
+
+DBusConnection *connman_dbus_get_connection(void)
+{
+ if (!connection)
+ return NULL;
+
+ return dbus_connection_ref(connection);
+}
+
+int __connman_dbus_init(DBusConnection *conn)
+{
+ DBG("");
+
+ connection = conn;
+
+ return 0;
+}
+
+void __connman_dbus_cleanup(void)
+{
+ DBG("");
+
+ connection = NULL;
+}
diff --git a/src/detect.c b/src/detect.c
new file mode 100644
index 0000000..03122b2
--- /dev/null
+++ b/src/detect.c
@@ -0,0 +1,139 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+
+#include "connman.h"
+
+static GSList *device_list = NULL;
+
+static struct connman_device *find_device(int index)
+{
+ GSList *list;
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (connman_device_get_index(device) == index)
+ return device;
+ }
+
+ return NULL;
+}
+
+static void detect_newlink(unsigned short type, int index,
+ unsigned flags, unsigned change)
+{
+ struct connman_device *device;
+ enum connman_device_type devtype;
+
+ DBG("type %d index %d", type, index);
+
+ device = find_device(index);
+ if (device)
+ return;
+
+ devtype = __connman_rtnl_get_device_type(index);
+
+ DBG("device %p (%s) devtype %d",
+ device,
+ device ? connman_device_get_ident(device) : NULL,
+ devtype);
+
+ switch (devtype) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ case CONNMAN_DEVICE_TYPE_BLUETOOTH:
+ case CONNMAN_DEVICE_TYPE_CELLULAR:
+ case CONNMAN_DEVICE_TYPE_GPS:
+ case CONNMAN_DEVICE_TYPE_LOWPAN:
+ return;
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ case CONNMAN_DEVICE_TYPE_WIFI:
+ case CONNMAN_DEVICE_TYPE_GADGET:
+ break;
+ }
+
+ device = connman_device_create_from_index(index);
+ if (!device)
+ return;
+
+ if (connman_device_register(device) < 0) {
+ connman_device_unref(device);
+ return;
+ }
+
+ device_list = g_slist_prepend(device_list, device);
+}
+
+static void detect_dellink(unsigned short type, int index,
+ unsigned flags, unsigned change)
+{
+ struct connman_device *device;
+
+ DBG("type %d index %d", type, index);
+
+ device = find_device(index);
+ if (!device)
+ return;
+
+ device_list = g_slist_remove(device_list, device);
+
+ connman_device_unregister(device);
+ connman_device_unref(device);
+}
+
+static struct connman_rtnl detect_rtnl = {
+ .name = "detect",
+ .priority = CONNMAN_RTNL_PRIORITY_LOW,
+ .newlink = detect_newlink,
+ .dellink = detect_dellink,
+};
+
+int __connman_detect_init(void)
+{
+ DBG("");
+
+ return connman_rtnl_register(&detect_rtnl);
+}
+
+void __connman_detect_cleanup(void)
+{
+ GSList *list;
+
+ DBG("");
+
+ connman_rtnl_unregister(&detect_rtnl);
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ connman_device_unregister(device);
+ connman_device_unref(device);
+ }
+
+ g_slist_free(device_list);
+ device_list = NULL;
+}
diff --git a/src/device.c b/src/device.c
new file mode 100644
index 0000000..70f8cd3
--- /dev/null
+++ b/src/device.c
@@ -0,0 +1,1503 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+
+#include "connman.h"
+
+static GSList *device_list = NULL;
+static gchar **device_filter = NULL;
+static gchar **nodevice_filter = NULL;
+
+enum connman_pending_type {
+ PENDING_NONE = 0,
+ PENDING_ENABLE = 1,
+ PENDING_DISABLE = 2,
+};
+
+struct connman_device {
+ int refcount;
+ enum connman_device_type type;
+ enum connman_pending_type powered_pending; /* Indicates a pending
+ * enable/disable
+ * request
+ */
+ bool powered;
+ bool scanning;
+ bool disconnected;
+ char *name;
+ char *node;
+ char *address;
+ char *interface;
+ char *ident;
+ char *path;
+ int index;
+ guint pending_timeout;
+
+ struct connman_device_driver *driver;
+ void *driver_data;
+
+ char *last_network;
+ struct connman_network *network;
+ GHashTable *networks;
+};
+
+static void clear_pending_trigger(struct connman_device *device)
+{
+ if (device->pending_timeout > 0) {
+ g_source_remove(device->pending_timeout);
+ device->pending_timeout = 0;
+ }
+}
+
+static const char *type2description(enum connman_device_type type)
+{
+ switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ break;
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ return "Ethernet";
+ case CONNMAN_DEVICE_TYPE_WIFI:
+ return "Wireless";
+ case CONNMAN_DEVICE_TYPE_BLUETOOTH:
+ return "Bluetooth";
+ case CONNMAN_DEVICE_TYPE_GPS:
+ return "GPS";
+ case CONNMAN_DEVICE_TYPE_CELLULAR:
+ return "Cellular";
+ case CONNMAN_DEVICE_TYPE_GADGET:
+ return "Gadget";
+ case CONNMAN_DEVICE_TYPE_LOWPAN:
+ return "Low-Power Wireless";
+
+ }
+
+ return NULL;
+}
+
+static const char *type2string(enum connman_device_type type)
+{
+ switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ break;
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ return "ethernet";
+ case CONNMAN_DEVICE_TYPE_WIFI:
+ return "wifi";
+ case CONNMAN_DEVICE_TYPE_BLUETOOTH:
+ return "bluetooth";
+ case CONNMAN_DEVICE_TYPE_GPS:
+ return "gps";
+ case CONNMAN_DEVICE_TYPE_CELLULAR:
+ return "cellular";
+ case CONNMAN_DEVICE_TYPE_GADGET:
+ return "gadget";
+ case CONNMAN_DEVICE_TYPE_LOWPAN:
+ return "lowpan";
+ }
+
+ return NULL;
+}
+
+enum connman_service_type __connman_device_get_service_type(
+ struct connman_device *device)
+{
+ enum connman_device_type type = connman_device_get_type(device);
+
+ switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ case CONNMAN_DEVICE_TYPE_GPS:
+ break;
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ return CONNMAN_SERVICE_TYPE_ETHERNET;
+ case CONNMAN_DEVICE_TYPE_WIFI:
+ return CONNMAN_SERVICE_TYPE_WIFI;
+ case CONNMAN_DEVICE_TYPE_BLUETOOTH:
+ return CONNMAN_SERVICE_TYPE_BLUETOOTH;
+ case CONNMAN_DEVICE_TYPE_CELLULAR:
+ return CONNMAN_SERVICE_TYPE_CELLULAR;
+ case CONNMAN_DEVICE_TYPE_GADGET:
+ return CONNMAN_SERVICE_TYPE_GADGET;
+ case CONNMAN_DEVICE_TYPE_LOWPAN:
+ return CONNMAN_SERVICE_TYPE_LOWPAN;
+
+ }
+
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+}
+
+static gboolean device_pending_reset(gpointer user_data)
+{
+ struct connman_device *device = user_data;
+
+ DBG("device %p", device);
+
+ /* Power request timedout, reset power pending state. */
+ device->pending_timeout = 0;
+ device->powered_pending = PENDING_NONE;
+
+ return FALSE;
+}
+
+int __connman_device_enable(struct connman_device *device)
+{
+ int err;
+
+ DBG("device %p", device);
+
+ if (!device->driver || !device->driver->enable)
+ return -EOPNOTSUPP;
+
+ /* There is an ongoing power disable request. */
+ if (device->powered_pending == PENDING_DISABLE)
+ return -EBUSY;
+
+ if (device->powered_pending == PENDING_ENABLE)
+ return -EALREADY;
+
+ if (device->powered_pending == PENDING_NONE && device->powered)
+ return -EALREADY;
+
+ if (device->index > 0) {
+ err = connman_inet_ifup(device->index);
+ if (err < 0 && err != -EALREADY)
+ return err;
+ }
+
+ device->powered_pending = PENDING_ENABLE;
+
+ err = device->driver->enable(device);
+ /*
+ * device gets enabled right away.
+ * Invoke the callback
+ */
+ if (err == 0) {
+ connman_device_set_powered(device, true);
+ goto done;
+ }
+
+ if (err == -EALREADY) {
+ /* If device is already powered, but connman is not updated */
+ connman_device_set_powered(device, true);
+ goto done;
+ }
+ /*
+ * if err == -EINPROGRESS, then the DBus call to the respective daemon
+ * was successful. We set a 4 sec timeout so if the daemon never
+ * returns a reply, we would reset the pending request.
+ */
+ if (err == -EINPROGRESS)
+ device->pending_timeout = g_timeout_add_seconds(4,
+ device_pending_reset, device);
+done:
+ return err;
+}
+
+int __connman_device_disable(struct connman_device *device)
+{
+ int err;
+
+ DBG("device %p", device);
+
+ /* Ongoing power enable request */
+ if (device->powered_pending == PENDING_ENABLE)
+ return -EBUSY;
+
+ if (device->powered_pending == PENDING_DISABLE)
+ return -EALREADY;
+
+ if (device->powered_pending == PENDING_NONE && !device->powered)
+ return -EALREADY;
+
+ device->powered_pending = PENDING_DISABLE;
+
+ if (device->network) {
+ struct connman_service *service =
+ connman_service_lookup_from_network(device->network);
+
+ if (service)
+ __connman_service_disconnect(service);
+ else
+ connman_network_set_connected(device->network, false);
+ }
+
+ if (!device->driver || !device->driver->disable)
+ return -EOPNOTSUPP;
+
+ err = device->driver->disable(device);
+ if (err == 0 || err == -EALREADY) {
+ connman_device_set_powered(device, false);
+ goto done;
+ }
+
+ if (err == -EINPROGRESS)
+ device->pending_timeout = g_timeout_add_seconds(4,
+ device_pending_reset, device);
+done:
+ return err;
+}
+
+static void probe_driver(struct connman_device_driver *driver)
+{
+ GSList *list;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (device->driver)
+ continue;
+
+ if (driver->type != device->type)
+ continue;
+
+ if (driver->probe(device) < 0)
+ continue;
+
+ device->driver = driver;
+
+ __connman_technology_add_device(device);
+ }
+}
+
+static void remove_device(struct connman_device *device)
+{
+ DBG("device %p", device);
+
+ __connman_device_disable(device);
+
+ __connman_technology_remove_device(device);
+
+ if (device->driver->remove)
+ device->driver->remove(device);
+
+ device->driver = NULL;
+}
+
+static void remove_driver(struct connman_device_driver *driver)
+{
+ GSList *list;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (device->driver == driver)
+ remove_device(device);
+ }
+}
+
+bool __connman_device_has_driver(struct connman_device *device)
+{
+ if (!device || !device->driver)
+ return false;
+
+ return true;
+}
+
+static GSList *driver_list = NULL;
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_device_driver *driver1 = a;
+ const struct connman_device_driver *driver2 = b;
+
+ return driver2->priority - driver1->priority;
+}
+
+/**
+ * connman_device_driver_register:
+ * @driver: device driver definition
+ *
+ * Register a new device driver
+ *
+ * Returns: %0 on success
+ */
+int connman_device_driver_register(struct connman_device_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+ probe_driver(driver);
+
+ return 0;
+}
+
+/**
+ * connman_device_driver_unregister:
+ * @driver: device driver definition
+ *
+ * Remove a previously registered device driver
+ */
+void connman_device_driver_unregister(struct connman_device_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_remove(driver_list, driver);
+
+ remove_driver(driver);
+}
+
+static void free_network(gpointer data)
+{
+ struct connman_network *network = data;
+
+ DBG("network %p", network);
+
+ __connman_network_set_device(network, NULL);
+
+ connman_network_unref(network);
+}
+
+static void device_destruct(struct connman_device *device)
+{
+ DBG("device %p name %s", device, device->name);
+
+ clear_pending_trigger(device);
+
+ g_free(device->ident);
+ g_free(device->node);
+ g_free(device->name);
+ g_free(device->address);
+ g_free(device->interface);
+ g_free(device->path);
+
+ g_free(device->last_network);
+
+ g_hash_table_destroy(device->networks);
+ device->networks = NULL;
+
+ g_free(device);
+}
+
+/**
+ * connman_device_create:
+ * @node: device node name (for example an address)
+ * @type: device type
+ *
+ * Allocate a new device of given #type and assign the #node name to it.
+ *
+ * Returns: a newly-allocated #connman_device structure
+ */
+struct connman_device *connman_device_create(const char *node,
+ enum connman_device_type type)
+{
+ struct connman_device *device;
+
+ DBG("node %s type %d", node, type);
+
+ device = g_try_new0(struct connman_device, 1);
+ if (!device)
+ return NULL;
+
+ DBG("device %p", device);
+
+ device->refcount = 1;
+
+ device->type = type;
+ device->name = g_strdup(type2description(device->type));
+
+ device->networks = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, free_network);
+
+ device_list = g_slist_prepend(device_list, device);
+
+ return device;
+}
+
+/**
+ * connman_device_ref:
+ * @device: device structure
+ *
+ * Increase reference counter of device
+ */
+struct connman_device *connman_device_ref_debug(struct connman_device *device,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", device, device->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&device->refcount, 1);
+
+ return device;
+}
+
+/**
+ * connman_device_unref:
+ * @device: device structure
+ *
+ * Decrease reference counter of device
+ */
+void connman_device_unref_debug(struct connman_device *device,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p unref %d by %s:%d:%s()", device, device->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&device->refcount, 1) != 1)
+ return;
+
+ if (device->driver) {
+ device->driver->remove(device);
+ device->driver = NULL;
+ }
+
+ device_list = g_slist_remove(device_list, device);
+
+ device_destruct(device);
+}
+
+const char *__connman_device_get_type(struct connman_device *device)
+{
+ return type2string(device->type);
+}
+
+/**
+ * connman_device_get_type:
+ * @device: device structure
+ *
+ * Get type of device
+ */
+enum connman_device_type connman_device_get_type(struct connman_device *device)
+{
+ return device->type;
+}
+
+/**
+ * connman_device_set_index:
+ * @device: device structure
+ * @index: index number
+ *
+ * Set index number of device
+ */
+void connman_device_set_index(struct connman_device *device, int index)
+{
+ device->index = index;
+}
+
+/**
+ * connman_device_get_index:
+ * @device: device structure
+ *
+ * Get index number of device
+ */
+int connman_device_get_index(struct connman_device *device)
+{
+ return device->index;
+}
+
+/**
+ * connman_device_set_interface:
+ * @device: device structure
+ * @interface: interface name
+ *
+ * Set interface name of device
+ */
+void connman_device_set_interface(struct connman_device *device,
+ const char *interface)
+{
+ g_free(device->interface);
+ device->interface = g_strdup(interface);
+
+ if (!device->name) {
+ const char *str = type2description(device->type);
+ if (str && device->interface)
+ device->name = g_strdup_printf("%s (%s)", str,
+ device->interface);
+ }
+}
+
+/**
+ * connman_device_set_ident:
+ * @device: device structure
+ * @ident: unique identifier
+ *
+ * Set unique identifier of device
+ */
+void connman_device_set_ident(struct connman_device *device,
+ const char *ident)
+{
+ g_free(device->ident);
+ device->ident = g_strdup(ident);
+}
+
+const char *connman_device_get_ident(struct connman_device *device)
+{
+ return device->ident;
+}
+
+/**
+ * connman_device_set_powered:
+ * @device: device structure
+ * @powered: powered state
+ *
+ * Change power state of device
+ */
+int connman_device_set_powered(struct connman_device *device,
+ bool powered)
+{
+ enum connman_service_type type;
+
+ DBG("driver %p powered %d", device, powered);
+
+ if (device->powered == powered)
+ return -EALREADY;
+
+ clear_pending_trigger(device);
+
+ device->powered_pending = PENDING_NONE;
+
+ device->powered = powered;
+
+ type = __connman_device_get_service_type(device);
+
+ if (!device->powered) {
+ __connman_technology_disabled(type);
+ return 0;
+ }
+
+ __connman_technology_enabled(type);
+
+ connman_device_set_disconnected(device, false);
+ device->scanning = false;
+
+ if (device->driver && device->driver->scan)
+ device->driver->scan(CONNMAN_SERVICE_TYPE_UNKNOWN, device,
+ NULL, 0, NULL, NULL, NULL, NULL);
+
+ return 0;
+}
+
+bool connman_device_get_powered(struct connman_device *device)
+{
+ return device->powered;
+}
+
+static int device_scan(enum connman_service_type type,
+ struct connman_device *device)
+{
+ DBG("type %d device %p device->driver %p device->driver->scan %p powered %d", type, device, device->driver, device->driver->scan, device->powered);
+ if (!device->driver || !device->driver->scan)
+ return -EOPNOTSUPP;
+
+ if (!device->powered)
+ return -ENOLINK;
+
+ connman_info("Requested scan for device %s interface %s.",
+ device->driver->name, device->interface);
+
+ DBG("type %d", type);
+ return device->driver->scan(type, device, NULL, 0,
+ NULL, NULL, NULL, NULL);
+}
+
+int __connman_device_disconnect(struct connman_device *device)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ DBG("device %p", device);
+
+ connman_device_set_disconnected(device, true);
+
+ g_hash_table_iter_init(&iter, device->networks);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_network *network = value;
+
+ if (connman_network_get_connecting(network)) {
+ /*
+ * Skip network in the process of connecting.
+ * This is a workaround for WiFi networks serviced
+ * by the supplicant plugin that hold a reference
+ * to the network. If we disconnect the network
+ * here then the referenced object will not be
+ * registered and usage (like launching DHCP client)
+ * will fail. There is nothing to be gained by
+ * removing the network here anyway.
+ */
+ connman_warn("Skipping disconnect of %s, network is connecting.",
+ connman_network_get_identifier(network));
+ continue;
+ }
+
+ __connman_network_disconnect(network, FALSE);
+ }
+
+ return 0;
+}
+
+int connman_device_reconnect_service(struct connman_device *device)
+{
+ DBG("device %p", device);
+
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+
+ return 0;
+}
+
+static void mark_network_available(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct connman_network *network = value;
+
+ connman_network_set_available(network, true);
+}
+
+static void mark_network_unavailable(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct connman_network *network = value;
+
+ if (connman_network_get_connected(network) ||
+ connman_network_get_connecting(network) || connman_network_get_connectable(network))
+ return;
+
+ connman_network_set_available(network, false);
+}
+
+static gboolean remove_unavailable_network(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct connman_network *network = value;
+
+ if (connman_network_get_connected(network))
+ return FALSE;
+
+ if (connman_network_get_available(network))
+ return FALSE;
+
+ if (connman_network_get_connectable(network))
+ return FALSE;
+
+ return TRUE;
+}
+
+void __connman_device_cleanup_networks(struct connman_device *device)
+{
+ g_hash_table_foreach_remove(device->networks,
+ remove_unavailable_network, NULL);
+}
+
+bool connman_device_get_scanning(struct connman_device *device)
+{
+ return device->scanning;
+}
+
+void connman_device_reset_scanning(struct connman_device *device)
+{
+ g_hash_table_foreach(device->networks,
+ mark_network_available, NULL);
+}
+
+/**
+ * connman_device_set_scanning:
+ * @device: device structure
+ * @scanning: scanning state
+ *
+ * Change scanning state of device
+ */
+int connman_device_set_scanning(struct connman_device *device,
+ enum connman_service_type type, bool scanning)
+{
+ DBG("device %p scanning %d", device, scanning);
+
+ if (!device->driver || !device->driver->scan)
+ return -EINVAL;
+
+ if (device->scanning == scanning)
+ return -EALREADY;
+
+ device->scanning = scanning;
+
+ if (scanning) {
+ __connman_technology_scan_started(device);
+
+ g_hash_table_foreach(device->networks,
+ mark_network_unavailable, NULL);
+
+ return 0;
+ }
+
+ __connman_device_cleanup_networks(device);
+
+ __connman_technology_scan_stopped(device, type);
+
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+
+ return 0;
+}
+
+/**
+ * connman_device_set_disconnected:
+ * @device: device structure
+ * @disconnected: disconnected state
+ *
+ * Change disconnected state of device (only for device with networks)
+ */
+int connman_device_set_disconnected(struct connman_device *device,
+ bool disconnected)
+{
+ DBG("device %p disconnected %d", device, disconnected);
+
+ if (device->disconnected == disconnected)
+ return -EALREADY;
+
+ device->disconnected = disconnected;
+
+ return 0;
+}
+
+/**
+ * connman_device_get_disconnected:
+ * @device: device structure
+ *
+ * Get device disconnected state
+ */
+bool connman_device_get_disconnected(struct connman_device *device)
+{
+ return device->disconnected;
+}
+
+/**
+ * connman_device_set_string:
+ * @device: device structure
+ * @key: unique identifier
+ * @value: string value
+ *
+ * Set string value for specific key
+ */
+int connman_device_set_string(struct connman_device *device,
+ const char *key, const char *value)
+{
+ DBG("device %p key %s value %s", device, key, value);
+
+ if (g_str_equal(key, "Address")) {
+ g_free(device->address);
+ device->address = g_strdup(value);
+ } else if (g_str_equal(key, "Name")) {
+ g_free(device->name);
+ device->name = g_strdup(value);
+ } else if (g_str_equal(key, "Node")) {
+ g_free(device->node);
+ device->node = g_strdup(value);
+ } else if (g_str_equal(key, "Path")) {
+ g_free(device->path);
+ device->path = g_strdup(value);
+ } else {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * connman_device_get_string:
+ * @device: device structure
+ * @key: unique identifier
+ *
+ * Get string value for specific key
+ */
+const char *connman_device_get_string(struct connman_device *device,
+ const char *key)
+{
+ DBG("device %p key %s", device, key);
+
+ if (g_str_equal(key, "Address"))
+ return device->address;
+ else if (g_str_equal(key, "Name"))
+ return device->name;
+ else if (g_str_equal(key, "Node"))
+ return device->node;
+ else if (g_str_equal(key, "Interface"))
+ return device->interface;
+ else if (g_str_equal(key, "Path"))
+ return device->path;
+
+ return NULL;
+}
+
+/**
+ * connman_device_add_network:
+ * @device: device structure
+ * @network: network structure
+ *
+ * Add new network to the device
+ */
+int connman_device_add_network(struct connman_device *device,
+ struct connman_network *network)
+{
+ const char *identifier = connman_network_get_identifier(network);
+
+ DBG("device %p network %p identifier %s", device, network, identifier);
+
+ if (!identifier)
+ return -EINVAL;
+
+ connman_network_ref(network);
+
+ __connman_network_set_device(network, device);
+
+ g_hash_table_replace(device->networks, g_strdup(identifier),
+ network);
+
+ return 0;
+}
+
+/**
+ * connman_device_get_network:
+ * @device: device structure
+ * @identifier: network identifier
+ *
+ * Get network for given identifier
+ */
+struct connman_network *connman_device_get_network(struct connman_device *device,
+ const char *identifier)
+{
+ DBG("device %p identifier %s", device, identifier);
+
+ return g_hash_table_lookup(device->networks, identifier);
+}
+
+/**
+ * connman_device_remove_network:
+ * @device: device structure
+ * @identifier: network identifier
+ *
+ * Remove network for given identifier
+ */
+int connman_device_remove_network(struct connman_device *device,
+ struct connman_network *network)
+{
+ const char *identifier;
+
+ DBG("device %p network %p", device, network);
+
+ if (!network)
+ return 0;
+
+ identifier = connman_network_get_identifier(network);
+ g_hash_table_remove(device->networks, identifier);
+
+ return 0;
+}
+
+void __connman_device_set_network(struct connman_device *device,
+ struct connman_network *network)
+{
+ const char *name;
+
+ if (!device)
+ return;
+
+ if (device->network == network)
+ return;
+
+ if (network) {
+ name = connman_network_get_string(network, "Name");
+ g_free(device->last_network);
+ device->last_network = g_strdup(name);
+
+ device->network = network;
+ } else {
+ g_free(device->last_network);
+ device->last_network = NULL;
+
+ device->network = NULL;
+ }
+}
+
+void connman_device_set_network(struct connman_device *device,
+ struct connman_network *network)
+{
+ __connman_device_set_network(device, network);
+}
+
+void connman_device_cleanup_networks(struct connman_device *device)
+{
+ __connman_device_cleanup_networks(device);
+}
+
+static bool match_driver(struct connman_device *device,
+ struct connman_device_driver *driver)
+{
+ if (device->type == driver->type ||
+ driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN)
+ return true;
+
+ return false;
+}
+
+/**
+ * connman_device_register:
+ * @device: device structure
+ *
+ * Register device with the system
+ */
+int connman_device_register(struct connman_device *device)
+{
+ GSList *list;
+
+ DBG("device %p name %s", device, device->name);
+
+ if (device->driver)
+ return -EALREADY;
+
+ for (list = driver_list; list; list = list->next) {
+ struct connman_device_driver *driver = list->data;
+
+ if (!match_driver(device, driver))
+ continue;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (driver->probe(device) == 0) {
+ device->driver = driver;
+ break;
+ }
+ }
+
+ if (!device->driver)
+ return 0;
+
+ return __connman_technology_add_device(device);
+}
+
+/**
+ * connman_device_unregister:
+ * @device: device structure
+ *
+ * Unregister device with the system
+ */
+void connman_device_unregister(struct connman_device *device)
+{
+ DBG("device %p name %s", device, device->name);
+
+ if (!device->driver)
+ return;
+
+ remove_device(device);
+}
+
+/**
+ * connman_device_get_data:
+ * @device: device structure
+ *
+ * Get private device data pointer
+ */
+void *connman_device_get_data(struct connman_device *device)
+{
+ return device->driver_data;
+}
+
+/**
+ * connman_device_set_data:
+ * @device: device structure
+ * @data: data pointer
+ *
+ * Set private device data pointer
+ */
+void connman_device_set_data(struct connman_device *device, void *data)
+{
+ device->driver_data = data;
+}
+
+struct connman_device *__connman_device_find_device(
+ enum connman_service_type type)
+{
+ GSList *list;
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+ enum connman_service_type service_type =
+ __connman_device_get_service_type(device);
+
+ if (service_type != type)
+ continue;
+
+ return device;
+ }
+
+ return NULL;
+}
+
+struct connman_device *connman_device_find_by_index(int index)
+{
+ GSList *list;
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+ if (device->index == index)
+ return device;
+ }
+
+ return NULL;
+}
+
+/**
+ * connman_device_set_regdom
+ * @device: device structure
+ * @alpha2: string representing regulatory domain
+ *
+ * Set regulatory domain on device basis
+ */
+int connman_device_set_regdom(struct connman_device *device,
+ const char *alpha2)
+{
+ if (!device->driver || !device->driver->set_regdom)
+ return -ENOTSUP;
+
+ if (!device->powered)
+ return -EINVAL;
+
+ return device->driver->set_regdom(device, alpha2);
+}
+
+/**
+ * connman_device_regdom_notify
+ * @device: device structure
+ * @alpha2: string representing regulatory domain
+ *
+ * Notify on setting regulatory domain on device basis
+ */
+void connman_device_regdom_notify(struct connman_device *device,
+ int result, const char *alpha2)
+{
+ __connman_technology_notify_regdom_by_device(device, result, alpha2);
+}
+
+int __connman_device_request_scan(enum connman_service_type type)
+{
+ bool success = false;
+ int last_err = -ENOSYS;
+ GSList *list;
+ int err;
+
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ return -EOPNOTSUPP;
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ break;
+ }
+
+ for (list = device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+ enum connman_service_type service_type =
+ __connman_device_get_service_type(device);
+
+ if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN) {
+ if (type == CONNMAN_SERVICE_TYPE_P2P) {
+ if (service_type != CONNMAN_SERVICE_TYPE_WIFI)
+ continue;
+ } else if (service_type != type)
+ continue;
+ }
+
+ err = device_scan(type, device);
+
+ /*
+ * The upstream maintainers desire to collapse any
+ * errors that are implicitly successes into explicit
+ * successes as:
+ *
+ * if (err == 0 || err == -EALREADY || err == -EINPROGRESS) {
+ *
+ * However, due to MEEGO-25990 <https://bugs.meego.com/
+ * show_bug.cgi?id=25990>, this doesn't actually work
+ * correctly and such collapes lead to a D-Bus pending
+ * reply being lost and a D-Bus timeout for the
+ * client. Instead, for now, simply short-circuit
+ * these implicit successes as errors back to the
+ * client (which will have to handle them gracefully).
+ */
+
+ if (err == 0) {
+ success = true;
+ } else {
+ last_err = err;
+ DBG("device %p err %d", device, err);
+ }
+ }
+
+ if (success)
+ return 0;
+
+ return last_err;
+}
+
+int __connman_device_request_hidden_scan(struct connman_device *device,
+ const char *ssid, unsigned int ssid_len,
+ const char *identity, const char *passphrase,
+ const char *security, void *user_data)
+{
+ DBG("device %p", device);
+
+ if (!device || !device->driver ||
+ !device->driver->scan)
+ return -EINVAL;
+
+ return device->driver->scan(CONNMAN_SERVICE_TYPE_UNKNOWN,
+ device, ssid, ssid_len, identity,
+ passphrase, security, user_data);
+}
+
+static char *index2ident(int index, const char *prefix)
+{
+ struct ifreq ifr;
+ struct ether_addr eth;
+ char *str;
+ int sk, err, len;
+
+ if (index < 0)
+ return NULL;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return NULL;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+
+ if (err == 0)
+ err = ioctl(sk, SIOCGIFHWADDR, &ifr);
+
+ close(sk);
+
+ if (err < 0)
+ return NULL;
+
+ len = prefix ? strlen(prefix) + 18 : 18;
+
+ str = g_malloc(len);
+ if (!str)
+ return NULL;
+
+ memcpy(ð, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
+ snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
+ prefix ? prefix : "",
+ eth.ether_addr_octet[0],
+ eth.ether_addr_octet[1],
+ eth.ether_addr_octet[2],
+ eth.ether_addr_octet[3],
+ eth.ether_addr_octet[4],
+ eth.ether_addr_octet[5]);
+
+ return str;
+}
+
+static char *index2addr(int index)
+{
+ struct ifreq ifr;
+ struct ether_addr eth;
+ char *str;
+ int sk, err;
+
+ if (index < 0)
+ return NULL;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return NULL;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+
+ if (err == 0)
+ err = ioctl(sk, SIOCGIFHWADDR, &ifr);
+
+ close(sk);
+
+ if (err < 0)
+ return NULL;
+
+ str = g_malloc(18);
+ if (!str)
+ return NULL;
+
+ memcpy(ð, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
+ snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
+ eth.ether_addr_octet[0],
+ eth.ether_addr_octet[1],
+ eth.ether_addr_octet[2],
+ eth.ether_addr_octet[3],
+ eth.ether_addr_octet[4],
+ eth.ether_addr_octet[5]);
+
+ return str;
+}
+
+struct connman_device *connman_device_create_from_index(int index)
+{
+ enum connman_device_type type;
+ struct connman_device *device;
+ char *devname, *ident = NULL;
+ char *addr = NULL, *name = NULL;
+
+ if (index < 0)
+ return NULL;
+
+ devname = connman_inet_ifname(index);
+ if (!devname)
+ return NULL;
+
+ if (__connman_device_isfiltered(devname)) {
+ connman_info("Ignoring interface %s (filtered)", devname);
+ g_free(devname);
+ return NULL;
+ }
+
+ type = __connman_rtnl_get_device_type(index);
+
+ switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ connman_info("Ignoring interface %s (type unknown)", devname);
+ g_free(devname);
+ return NULL;
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ case CONNMAN_DEVICE_TYPE_GADGET:
+ case CONNMAN_DEVICE_TYPE_WIFI:
+ case CONNMAN_DEVICE_TYPE_LOWPAN:
+ name = index2ident(index, "");
+ addr = index2addr(index);
+ break;
+ case CONNMAN_DEVICE_TYPE_BLUETOOTH:
+ case CONNMAN_DEVICE_TYPE_CELLULAR:
+ case CONNMAN_DEVICE_TYPE_GPS:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ name = g_strdup(devname);
+ break;
+ }
+
+ device = connman_device_create(name, type);
+ if (!device)
+ goto done;
+
+ switch (type) {
+ case CONNMAN_DEVICE_TYPE_UNKNOWN:
+ case CONNMAN_DEVICE_TYPE_VENDOR:
+ case CONNMAN_DEVICE_TYPE_GPS:
+ break;
+ case CONNMAN_DEVICE_TYPE_ETHERNET:
+ case CONNMAN_DEVICE_TYPE_GADGET:
+ ident = index2ident(index, NULL);
+ break;
+ case CONNMAN_DEVICE_TYPE_WIFI:
+ case CONNMAN_DEVICE_TYPE_LOWPAN:
+ ident = index2ident(index, NULL);
+ break;
+ case CONNMAN_DEVICE_TYPE_BLUETOOTH:
+ break;
+ case CONNMAN_DEVICE_TYPE_CELLULAR:
+ ident = index2ident(index, NULL);
+ break;
+ }
+
+ connman_device_set_index(device, index);
+ connman_device_set_interface(device, devname);
+
+ if (ident) {
+ connman_device_set_ident(device, ident);
+ g_free(ident);
+ }
+
+ connman_device_set_string(device, "Address", addr);
+
+done:
+ g_free(devname);
+ g_free(name);
+ g_free(addr);
+
+ return device;
+}
+
+bool __connman_device_isfiltered(const char *devname)
+{
+ char **pattern;
+ char **blacklisted_interfaces;
+ bool match;
+
+ if (!device_filter)
+ goto nodevice;
+
+ for (pattern = device_filter, match = false; *pattern; pattern++) {
+ if (g_pattern_match_simple(*pattern, devname)) {
+ match = true;
+ break;
+ }
+ }
+
+ if (!match) {
+ DBG("ignoring device %s (match)", devname);
+ return true;
+ }
+
+nodevice:
+ if (g_pattern_match_simple("dummy*", devname)) {
+ DBG("ignoring dummy networking devices");
+ return true;
+ }
+
+ if (!nodevice_filter)
+ goto list;
+
+ for (pattern = nodevice_filter; *pattern; pattern++) {
+ if (g_pattern_match_simple(*pattern, devname)) {
+ DBG("ignoring device %s (no match)", devname);
+ return true;
+ }
+ }
+
+list:
+ blacklisted_interfaces =
+ connman_setting_get_string_list("NetworkInterfaceBlacklist");
+ if (!blacklisted_interfaces)
+ return false;
+
+ for (pattern = blacklisted_interfaces; *pattern; pattern++) {
+ if (g_str_has_prefix(devname, *pattern)) {
+ DBG("ignoring device %s (blacklist)", devname);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static void cleanup_devices(void)
+{
+ /*
+ * Check what interfaces are currently up and if connman is
+ * suppose to handle the interface, then cleanup the mess
+ * related to that interface. There might be weird routes etc
+ * that are related to that interface and that might confuse
+ * connmand. So in this case we just turn the interface down
+ * so that kernel removes routes/addresses automatically and
+ * then proceed the startup.
+ *
+ * Note that this cleanup must be done before rtnl/detect code
+ * has activated interface watches.
+ */
+
+ char **interfaces;
+ int i;
+
+ interfaces = __connman_inet_get_running_interfaces();
+
+ if (!interfaces)
+ return;
+
+ for (i = 0; interfaces[i]; i++) {
+ bool filtered;
+ int index;
+ struct sockaddr_in sin_addr, sin_mask;
+
+ filtered = __connman_device_isfiltered(interfaces[i]);
+ if (filtered)
+ continue;
+
+ index = connman_inet_ifindex(interfaces[i]);
+ if (index < 0)
+ continue;
+
+ if (!__connman_inet_get_address_netmask(index, &sin_addr,
+ &sin_mask)) {
+ char *address = g_strdup(inet_ntoa(sin_addr.sin_addr));
+ char *netmask = g_strdup(inet_ntoa(sin_mask.sin_addr));
+
+ if (__connman_config_address_provisioned(address,
+ netmask)) {
+ DBG("Skip %s which is already provisioned "
+ "with %s/%s", interfaces[i], address,
+ netmask);
+ g_free(address);
+ g_free(netmask);
+ continue;
+ }
+
+ g_free(address);
+ g_free(netmask);
+ }
+
+ DBG("cleaning up %s index %d", interfaces[i], index);
+
+ connman_inet_ifdown(index);
+
+ /*
+ * ConnMan will turn the interface UP automatically so
+ * no need to do it here.
+ */
+ }
+
+ g_strfreev(interfaces);
+}
+
+int __connman_device_init(const char *device, const char *nodevice)
+{
+ DBG("");
+
+ if (device)
+ device_filter = g_strsplit(device, ",", -1);
+
+ if (nodevice)
+ nodevice_filter = g_strsplit(nodevice, ",", -1);
+
+ cleanup_devices();
+
+ return 0;
+}
+
+void __connman_device_cleanup(void)
+{
+ DBG("");
+
+ g_strfreev(nodevice_filter);
+ g_strfreev(device_filter);
+}
diff --git a/src/dhcp.c b/src/dhcp.c
new file mode 100644
index 0000000..8d95614
--- /dev/null
+++ b/src/dhcp.c
@@ -0,0 +1,743 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include <connman/ipconfig.h>
+#include <include/setting.h>
+
+#include <gdhcp/gdhcp.h>
+
+#include <glib.h>
+
+#include "connman.h"
+
+#define RATE_LIMIT_INTERVAL 60 /* delay between successive attempts */
+
+struct connman_dhcp {
+ struct connman_ipconfig *ipconfig;
+ struct connman_network *network;
+ dhcp_cb callback;
+ gpointer user_data;
+
+ char **nameservers;
+ char **timeservers;
+ char *pac;
+
+ unsigned int timeout;
+
+ GDHCPClient *ipv4ll_client;
+ GDHCPClient *dhcp_client;
+ char *ipv4ll_debug_prefix;
+ char *dhcp_debug_prefix;
+};
+
+static GHashTable *ipconfig_table;
+static bool ipv4ll_running;
+
+static void dhcp_free(struct connman_dhcp *dhcp)
+{
+ g_strfreev(dhcp->nameservers);
+ g_strfreev(dhcp->timeservers);
+ g_free(dhcp->pac);
+
+ dhcp->nameservers = NULL;
+ dhcp->timeservers = NULL;
+ dhcp->pac = NULL;
+
+ g_free(dhcp);
+}
+
+static void ipv4ll_stop_client(struct connman_dhcp *dhcp)
+{
+ if (!dhcp->ipv4ll_client)
+ return;
+
+ g_dhcp_client_stop(dhcp->ipv4ll_client);
+ g_dhcp_client_unref(dhcp->ipv4ll_client);
+ dhcp->ipv4ll_client = NULL;
+ ipv4ll_running = false;
+
+ g_free(dhcp->ipv4ll_debug_prefix);
+ dhcp->ipv4ll_debug_prefix = NULL;
+}
+
+static bool apply_dhcp_invalidate_on_network(struct connman_dhcp *dhcp)
+{
+ struct connman_service *service;
+ int i;
+
+ if (!dhcp->network)
+ return true;
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ connman_error("Can not lookup service");
+ return false;
+ }
+
+ __connman_service_set_domainname(service, NULL);
+ __connman_ipconfig_set_proxy_autoconfig(dhcp->ipconfig, NULL);
+
+ if (dhcp->timeservers) {
+ for (i = 0; dhcp->timeservers[i]; i++) {
+ __connman_service_timeserver_remove(service,
+ dhcp->timeservers[i]);
+ }
+ }
+ if (dhcp->nameservers) {
+ for (i = 0; dhcp->nameservers[i]; i++) {
+ __connman_service_nameserver_remove(service,
+ dhcp->nameservers[i], false);
+ }
+
+ /*
+ * dhcp->nameservers needs to be freed when lease is lost
+ * to ensure that next time when device gets an IP, nameservers
+ * are updated successully for DNS to work correctly.
+ */
+ g_strfreev(dhcp->nameservers);
+ dhcp->nameservers = NULL;
+ }
+
+ return true;
+}
+
+/**
+ * dhcp_invalidate: Invalidate an existing DHCP lease
+ * @dhcp: pointer to the DHCP lease to invalidate.
+ * @callback: flag indicating whether or not to invoke the client callback
+ * if present.
+ *
+ * Invalidates an existing DHCP lease, optionally invoking the client
+ * callback. The caller may wish to avoid the client callback invocation
+ * when the invocation of that callback might otherwise unnecessarily upset
+ * service state due to the IP configuration change implied by this
+ * invalidation.
+ */
+static void dhcp_invalidate(struct connman_dhcp *dhcp, bool callback)
+{
+ DBG("dhcp %p callback %u", dhcp, callback);
+
+ if (!dhcp)
+ return;
+
+ __connman_6to4_remove(dhcp->ipconfig);
+
+ if (!apply_dhcp_invalidate_on_network(dhcp))
+ return;
+
+ __connman_ipconfig_set_dhcp_address(dhcp->ipconfig,
+ __connman_ipconfig_get_local(dhcp->ipconfig));
+ DBG("last address %s",
+ __connman_ipconfig_get_dhcp_address(dhcp->ipconfig));
+
+ __connman_ipconfig_address_remove(dhcp->ipconfig);
+
+ __connman_ipconfig_set_local(dhcp->ipconfig, NULL);
+ __connman_ipconfig_set_broadcast(dhcp->ipconfig, NULL);
+ __connman_ipconfig_set_gateway(dhcp->ipconfig, NULL);
+ __connman_ipconfig_set_prefixlen(dhcp->ipconfig, 0);
+
+ if (dhcp->callback && callback)
+ dhcp->callback(dhcp->ipconfig, dhcp->network,
+ false, dhcp->user_data);
+}
+
+static void dhcp_valid(struct connman_dhcp *dhcp)
+{
+ if (dhcp->callback)
+ dhcp->callback(dhcp->ipconfig, dhcp->network,
+ true, dhcp->user_data);
+}
+
+static void dhcp_debug(const char *str, void *data)
+{
+ connman_info("%s: %s", (const char *) data, str);
+}
+
+static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data);
+static void ipv4ll_available_cb(GDHCPClient *ipv4ll_client, gpointer user_data);
+
+static int ipv4ll_start_client(struct connman_dhcp *dhcp)
+{
+ GDHCPClient *ipv4ll_client;
+ GDHCPClientError error;
+ const char *hostname;
+ int index;
+ int err;
+
+ if (dhcp->ipv4ll_client)
+ return -EALREADY;
+
+ index = __connman_ipconfig_get_index(dhcp->ipconfig);
+
+ ipv4ll_client = g_dhcp_client_new(G_DHCP_IPV4LL, index, &error);
+ if (error != G_DHCP_CLIENT_ERROR_NONE)
+ return -EINVAL;
+
+ if (getenv("CONNMAN_DHCP_DEBUG")) {
+ dhcp->ipv4ll_debug_prefix = g_strdup_printf("IPv4LL index %d",
+ index);
+ g_dhcp_client_set_debug(ipv4ll_client, dhcp_debug,
+ dhcp->ipv4ll_debug_prefix);
+ }
+
+ g_dhcp_client_set_id(ipv4ll_client);
+
+ if (dhcp->network) {
+ hostname = connman_utsname_get_hostname();
+ if (hostname)
+ g_dhcp_client_set_send(ipv4ll_client,
+ G_DHCP_HOST_NAME, hostname);
+ }
+
+ g_dhcp_client_register_event(ipv4ll_client,
+ G_DHCP_CLIENT_EVENT_IPV4LL_LOST, ipv4ll_lost_cb, dhcp);
+
+ g_dhcp_client_register_event(ipv4ll_client,
+ G_DHCP_CLIENT_EVENT_IPV4LL_AVAILABLE,
+ ipv4ll_available_cb, dhcp);
+
+ dhcp->ipv4ll_client = ipv4ll_client;
+
+ err = g_dhcp_client_start(dhcp->ipv4ll_client, NULL);
+ if (err < 0) {
+ ipv4ll_stop_client(dhcp);
+ return err;
+ }
+
+ ipv4ll_running = true;
+ return 0;
+}
+
+static gboolean dhcp_retry_cb(gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+
+ dhcp->timeout = 0;
+
+ g_dhcp_client_start(dhcp->dhcp_client,
+ __connman_ipconfig_get_dhcp_address(dhcp->ipconfig));
+
+ return FALSE;
+}
+
+static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+ int err;
+
+ DBG("No lease available ipv4ll %d client %p", ipv4ll_running,
+ dhcp->ipv4ll_client);
+
+ dhcp->timeout = g_timeout_add_seconds(RATE_LIMIT_INTERVAL,
+ dhcp_retry_cb,
+ dhcp);
+ if (ipv4ll_running)
+ return;
+
+ err = ipv4ll_start_client(dhcp);
+ if (err < 0)
+ DBG("Cannot start ipv4ll client (%d/%s)", err, strerror(-err));
+
+ /* Only notify upper layer if we have a problem */
+ dhcp_invalidate(dhcp, !ipv4ll_running);
+}
+
+static void lease_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+
+ DBG("Lease lost");
+
+ /* Upper layer will decide what to do, e.g. nothing or retry. */
+ dhcp_invalidate(dhcp, true);
+}
+
+static void ipv4ll_lost_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+
+ DBG("Lease lost");
+
+ ipv4ll_stop_client(dhcp);
+
+ /*
+ * Since we lost our IPv4LL configuration we might as notify
+ * the upper layers.
+ */
+ dhcp_invalidate(dhcp, true);
+}
+
+static void wake_event_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+ time_t valid_until;
+ bool can_sleep;
+
+ can_sleep = g_dhcp_get_next_event(dhcp_client, &valid_until);
+ DBG("can_sleep: %d until: %lld", can_sleep, (long long)valid_until);
+
+ __connman_notifier_sleep_event(dhcp,can_sleep, valid_until);
+}
+
+static bool compare_string_arrays(char **array_a, char **array_b)
+{
+ int i;
+
+ if (!array_a || !array_b)
+ return false;
+
+ if (g_strv_length(array_a) != g_strv_length(array_b))
+ return false;
+
+ for (i = 0; array_a[i] &&
+ array_b[i]; i++) {
+ if (g_strcmp0(array_a[i], array_b[i]) != 0)
+ return false;
+ }
+
+ return true;
+}
+
+static bool apply_lease_available_on_network(GDHCPClient *dhcp_client,
+ struct connman_dhcp *dhcp)
+{
+ char **nameservers, **timeservers, *pac = NULL, **ns;
+ struct connman_service *service;
+ GList *list, *option = NULL;
+ int ns_entries;
+ int i, j, len;
+
+ if (!dhcp->network)
+ return true;
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ connman_error("Can not lookup service");
+ return false;
+ }
+
+ option = g_dhcp_client_get_option(dhcp_client, 252);
+ if (option)
+ pac = g_strdup(option->data);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
+ ns_entries = g_list_length(option);
+ nameservers = g_try_new0(char *, ns_entries + 1);
+ if (nameservers) {
+ for (i = 0, list = option;list; list = list->next, i++)
+ nameservers[i] = g_strdup(list->data);
+ nameservers[ns_entries] = NULL;
+ }
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME);
+ if (option)
+ __connman_service_set_domainname(service, option->data);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_HOST_NAME);
+ if (option)
+ __connman_service_set_hostname(service, option->data);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_NTP_SERVER);
+ ns_entries = g_list_length(option);
+ timeservers = g_try_new0(char *, ns_entries + 1);
+ if (timeservers) {
+ for (i = 0, list = option; list; list = list->next, i++)
+ timeservers[i] = g_strdup(list->data);
+ timeservers[ns_entries] = NULL;
+ }
+
+ if (!compare_string_arrays(nameservers, dhcp->nameservers)) {
+ if (dhcp->nameservers) {
+ for (i = 0; dhcp->nameservers[i]; i++) {
+ __connman_service_nameserver_remove(service,
+ dhcp->nameservers[i], false);
+ }
+ g_strfreev(dhcp->nameservers);
+ }
+
+ /* Append fallback name servers to the name server list */
+ if (connman_setting_get_bool("AlwaysUseFallbackNameservers")) {
+ ns = connman_setting_get_string_list("FallbackNameservers");
+ if (ns) {
+ if (nameservers) {
+ i = g_strv_length(nameservers);
+ len = i + g_strv_length(ns);
+ nameservers = g_try_renew(char *, nameservers, len + 1);
+ } else {
+ i = 0;
+ len = g_strv_length(ns);
+ nameservers = g_try_new0(char *, len + 1);
+ }
+ for (j = 0; ns[j]; j++, i++)
+ nameservers[i] = g_strdup(ns[j]);
+ nameservers[i] = NULL;
+ }
+ }
+
+ dhcp->nameservers = nameservers;
+
+ for (i = 0; dhcp->nameservers && dhcp->nameservers[i]; i++) {
+ __connman_service_nameserver_append(service,
+ dhcp->nameservers[i], false);
+ }
+ } else {
+ g_strfreev(nameservers);
+ }
+
+ if (!compare_string_arrays(timeservers, dhcp->timeservers)) {
+ if (dhcp->timeservers) {
+ for (i = 0; dhcp->timeservers[i]; i++) {
+ __connman_service_timeserver_remove(service,
+ dhcp->timeservers[i]);
+ }
+ g_strfreev(dhcp->timeservers);
+ }
+
+ dhcp->timeservers = timeservers;
+
+ for (i = 0; dhcp->timeservers && dhcp->timeservers[i]; i++) {
+ __connman_service_timeserver_append(service,
+ dhcp->timeservers[i]);
+ }
+ } else {
+ g_strfreev(timeservers);
+ }
+
+ if (g_strcmp0(pac, dhcp->pac) != 0) {
+ g_free(dhcp->pac);
+ dhcp->pac = pac;
+
+ __connman_ipconfig_set_proxy_autoconfig(dhcp->ipconfig,
+ dhcp->pac);
+ }
+
+ if (connman_setting_get_bool("Enable6to4"))
+ __connman_6to4_probe(service);
+
+ return true;
+}
+
+static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+ GList *option = NULL;
+ char *address, *netmask = NULL, *gateway = NULL;
+ const char *c_address, *c_gateway;
+ unsigned char prefixlen, c_prefixlen;
+ bool ip_change = false;
+
+ DBG("Lease available");
+
+ if (dhcp->ipv4ll_client) {
+ ipv4ll_stop_client(dhcp);
+ dhcp_invalidate(dhcp, false);
+ }
+
+ c_address = __connman_ipconfig_get_local(dhcp->ipconfig);
+ c_gateway = __connman_ipconfig_get_gateway(dhcp->ipconfig);
+ c_prefixlen = __connman_ipconfig_get_prefixlen(dhcp->ipconfig);
+
+ address = g_dhcp_client_get_address(dhcp_client);
+
+ __connman_ipconfig_set_dhcp_address(dhcp->ipconfig, address);
+ DBG("last address %s", address);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
+ if (option)
+ netmask = g_strdup(option->data);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
+ if (option)
+ gateway = g_strdup(option->data);
+
+ prefixlen = connman_ipaddress_calc_netmask_len(netmask);
+ if (prefixlen == 255)
+ connman_warn("netmask: %s is invalid", netmask);
+
+ DBG("c_address %s", c_address);
+
+ if (g_strcmp0(address, c_address)) {
+ ip_change = true;
+ if (c_address) {
+ /* Remove old ip address */
+ __connman_ipconfig_address_remove(dhcp->ipconfig);
+ }
+ }
+ if (g_strcmp0(gateway, c_gateway)) {
+ ip_change = true;
+ if (c_gateway) {
+ /* Remove gateway ip address */
+ __connman_ipconfig_gateway_remove(dhcp->ipconfig);
+ }
+ }
+ if (prefixlen != c_prefixlen)
+ ip_change = true;
+
+ __connman_ipconfig_set_method(dhcp->ipconfig,
+ CONNMAN_IPCONFIG_METHOD_DHCP);
+ if (ip_change) {
+ __connman_ipconfig_set_local(dhcp->ipconfig, address);
+ __connman_ipconfig_set_prefixlen(dhcp->ipconfig, prefixlen);
+ __connman_ipconfig_set_gateway(dhcp->ipconfig, gateway);
+ }
+
+ if (!apply_lease_available_on_network(dhcp_client, dhcp))
+ return;
+
+ if (ip_change)
+ dhcp_valid(dhcp);
+
+ g_free(address);
+ g_free(netmask);
+ g_free(gateway);
+}
+
+static void ipv4ll_available_cb(GDHCPClient *ipv4ll_client, gpointer user_data)
+{
+ struct connman_dhcp *dhcp = user_data;
+ char *address, *netmask;
+ unsigned char prefixlen;
+
+ DBG("IPV4LL available");
+
+ address = g_dhcp_client_get_address(ipv4ll_client);
+ netmask = g_dhcp_client_get_netmask(ipv4ll_client);
+
+ prefixlen = connman_ipaddress_calc_netmask_len(netmask);
+
+ __connman_ipconfig_set_method(dhcp->ipconfig,
+ CONNMAN_IPCONFIG_METHOD_DHCP);
+ __connman_ipconfig_set_local(dhcp->ipconfig, address);
+ __connman_ipconfig_set_prefixlen(dhcp->ipconfig, prefixlen);
+ __connman_ipconfig_set_gateway(dhcp->ipconfig, NULL);
+
+ dhcp_valid(dhcp);
+
+ g_free(address);
+ g_free(netmask);
+}
+
+static int dhcp_initialize(struct connman_dhcp *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ GDHCPClientError error;
+ int index;
+
+ DBG("dhcp %p", dhcp);
+
+ index = __connman_ipconfig_get_index(dhcp->ipconfig);
+
+ dhcp_client = g_dhcp_client_new(G_DHCP_IPV4, index, &error);
+ if (error != G_DHCP_CLIENT_ERROR_NONE)
+ return -EINVAL;
+
+ if (getenv("CONNMAN_DHCP_DEBUG")) {
+ dhcp->dhcp_debug_prefix = g_strdup_printf("DHCP index %d",
+ index);
+ g_dhcp_client_set_debug(dhcp_client, dhcp_debug,
+ dhcp->dhcp_debug_prefix);
+ }
+
+ g_dhcp_client_set_id(dhcp_client);
+
+ if (dhcp->network) {
+ struct connman_service *service;
+ const char *hostname;
+
+ service = connman_service_lookup_from_network(dhcp->network);
+
+ hostname = __connman_service_get_hostname(service);
+ if (!hostname)
+ hostname = connman_utsname_get_hostname();
+
+ if (hostname)
+ g_dhcp_client_set_send(dhcp_client,
+ G_DHCP_HOST_NAME, hostname);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_HOST_NAME);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_DNS_SERVER);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_DOMAIN_NAME);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_NTP_SERVER);
+ g_dhcp_client_set_request(dhcp_client, 252);
+ }
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_SUBNET);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_ROUTER);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_LEASE_AVAILABLE,
+ lease_available_cb, dhcp);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_WAKE_EVENT,
+ wake_event_cb, dhcp);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_LEASE_LOST, lease_lost_cb, dhcp);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_NO_LEASE, no_lease_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return 0;
+}
+
+static int dhcp_release(struct connman_dhcp *dhcp)
+{
+ DBG("dhcp %p", dhcp);
+
+ if (dhcp == NULL)
+ return -EINVAL;
+
+ if (dhcp->timeout > 0) {
+ g_source_remove(dhcp->timeout);
+ dhcp->timeout = 0;
+ }
+
+ if (dhcp->dhcp_client) {
+ g_dhcp_client_stop(dhcp->dhcp_client);
+ g_dhcp_client_unref(dhcp->dhcp_client);
+ }
+
+ dhcp->dhcp_client = NULL;
+
+ g_free(dhcp->dhcp_debug_prefix);
+ dhcp->dhcp_debug_prefix = NULL;
+
+ ipv4ll_stop_client(dhcp);
+
+ return 0;
+}
+
+char *__connman_dhcp_get_server_address(struct connman_ipconfig *ipconfig)
+{
+ struct connman_dhcp *dhcp;
+
+ dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+ if (!dhcp)
+ return NULL;
+
+ return g_dhcp_client_get_server_address(dhcp->dhcp_client);
+}
+
+int __connman_dhcp_start(struct connman_ipconfig *ipconfig,
+ struct connman_network *network, dhcp_cb callback,
+ gpointer user_data)
+{
+ const char *last_addr = NULL;
+ struct connman_dhcp *dhcp;
+ int err;
+
+ DBG("");
+
+ if (network) {
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+ }
+
+ last_addr = __connman_ipconfig_get_dhcp_address(ipconfig);
+
+ dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+ if (!dhcp) {
+
+ dhcp = g_try_new0(struct connman_dhcp, 1);
+ if (!dhcp)
+ return -ENOMEM;
+
+ dhcp->ipconfig = ipconfig;
+ __connman_ipconfig_ref(ipconfig);
+
+ if (network) {
+ dhcp->network = network;
+ connman_network_ref(network);
+ }
+
+ err = dhcp_initialize(dhcp);
+
+ if (err < 0) {
+ if (network)
+ connman_network_unref(network);
+ g_free(dhcp);
+ return err;
+ }
+
+ g_hash_table_insert(ipconfig_table, ipconfig, dhcp);
+ }
+
+ dhcp->callback = callback;
+ dhcp->user_data = user_data;
+
+ return g_dhcp_client_start(dhcp->dhcp_client, last_addr);
+}
+
+void __connman_dhcp_stop(struct connman_ipconfig *ipconfig)
+{
+ struct connman_dhcp *dhcp;
+
+ DBG("ipconfig_table %p ipconfig %p", ipconfig_table, ipconfig);
+
+ if (!ipconfig_table)
+ return;
+
+ dhcp = g_hash_table_lookup(ipconfig_table, ipconfig);
+ if (dhcp) {
+ g_hash_table_remove(ipconfig_table, ipconfig);
+ __connman_ipconfig_unref(ipconfig);
+ if (dhcp->network)
+ connman_network_unref(dhcp->network);
+ dhcp_release(dhcp);
+ dhcp_invalidate(dhcp, false);
+ dhcp_free(dhcp);
+ }
+}
+
+int __connman_dhcp_init(void)
+{
+ DBG("");
+
+ ipconfig_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, NULL);
+
+ return 0;
+}
+
+void __connman_dhcp_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(ipconfig_table);
+ ipconfig_table = NULL;
+
+ dhcp_cleanup_random();
+}
diff --git a/src/dhcpv6.c b/src/dhcpv6.c
new file mode 100644
index 0000000..db9feb6
--- /dev/null
+++ b/src/dhcpv6.c
@@ -0,0 +1,2684 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+#include <stdlib.h>
+#include <net/if.h>
+
+#include <connman/ipconfig.h>
+#include <connman/storage.h>
+
+#include <gdhcp/gdhcp.h>
+
+#include <glib.h>
+
+#include "connman.h"
+
+/* Transmission params in msec, RFC 3315 chapter 5.5 */
+#define INF_MAX_DELAY (1 * 1000)
+#define INF_TIMEOUT (1 * 1000)
+#define INF_MAX_RT (120 * 1000)
+#define SOL_MAX_DELAY (1 * 1000)
+#define SOL_TIMEOUT (1 * 1000)
+#define SOL_MAX_RT (120 * 1000)
+#define REQ_TIMEOUT (1 * 1000)
+#define REQ_MAX_RT (30 * 1000)
+#define REQ_MAX_RC 10
+#define REN_TIMEOUT (10 * 1000)
+#define REN_MAX_RT (600 * 1000)
+#define REB_TIMEOUT (10 * 1000)
+#define REB_MAX_RT (600 * 1000)
+#define CNF_MAX_DELAY (1 * 1000)
+#define CNF_TIMEOUT (1 * 1000)
+#define CNF_MAX_RT (4 * 1000)
+#define CNF_MAX_RD (10 * 1000)
+#define DEC_TIMEOUT (1 * 1000)
+#define DEC_MAX_RC 5
+
+enum request_type {
+ REQ_REQUEST = 1,
+ REQ_REBIND = 2,
+ REQ_RENEW = 3,
+};
+
+struct connman_dhcpv6 {
+ struct connman_network *network;
+ dhcpv6_cb callback;
+
+ char **nameservers;
+ char **timeservers;
+
+ GDHCPClient *dhcp_client;
+
+ guint timeout; /* operation timeout in msec */
+ guint MRD; /* max operation timeout in msec */
+ guint RT; /* in msec */
+ bool use_ta; /* set to TRUE if IPv6 privacy is enabled */
+ GSList *prefixes; /* network prefixes from radvd or dhcpv6 pd */
+ int request_count; /* how many times REQUEST have been sent */
+ bool stateless; /* TRUE if stateless DHCPv6 is used */
+ bool started; /* TRUE if we have DHCPv6 started */
+};
+
+static GHashTable *network_table;
+static GHashTable *network_pd_table;
+
+static int dhcpv6_request(struct connman_dhcpv6 *dhcp, bool add_addresses);
+static int dhcpv6_pd_request(struct connman_dhcpv6 *dhcp);
+static gboolean start_solicitation(gpointer user_data);
+static int dhcpv6_renew(struct connman_dhcpv6 *dhcp);
+static int dhcpv6_rebind(struct connman_dhcpv6 *dhcp);
+
+static void clear_timer(struct connman_dhcpv6 *dhcp)
+{
+ if (dhcp->timeout > 0) {
+ g_source_remove(dhcp->timeout);
+ dhcp->timeout = 0;
+ }
+
+ if (dhcp->MRD > 0) {
+ g_source_remove(dhcp->MRD);
+ dhcp->MRD = 0;
+ }
+}
+
+static inline guint get_random(void)
+{
+ uint64_t val;
+
+ __connman_util_get_random(&val);
+
+ /* Make sure the value is always positive so strip MSB */
+ return ((uint32_t)val) >> 1;
+}
+
+static guint compute_random(guint val)
+{
+ return val - val / 10 +
+ (get_random() % (2 * 1000)) * val / 10 / 1000;
+}
+
+/* Calculate a random delay, RFC 3315 chapter 14 */
+/* RT and MRT are milliseconds */
+static guint calc_delay(guint RT, guint MRT)
+{
+ if (MRT && (RT > MRT / 2))
+ RT = compute_random(MRT);
+ else
+ RT += compute_random(RT);
+
+ return RT;
+}
+
+static guint initial_rt(guint timeout)
+{
+ return compute_random(timeout);
+}
+
+static void free_prefix(gpointer data)
+{
+ g_free(data);
+}
+
+static void dhcpv6_free(struct connman_dhcpv6 *dhcp)
+{
+ g_strfreev(dhcp->nameservers);
+ g_strfreev(dhcp->timeservers);
+
+ dhcp->nameservers = NULL;
+ dhcp->timeservers = NULL;
+ dhcp->started = false;
+
+ g_slist_free_full(dhcp->prefixes, free_prefix);
+}
+
+static bool compare_string_arrays(char **array_a, char **array_b)
+{
+ int i;
+
+ if (!array_a || !array_b)
+ return false;
+
+ if (g_strv_length(array_a) != g_strv_length(array_b))
+ return false;
+
+ for (i = 0; array_a[i] && array_b[i]; i++)
+ if (g_strcmp0(array_a[i], array_b[i]) != 0)
+ return false;
+
+ return true;
+}
+
+static void dhcpv6_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static gchar *convert_to_hex(unsigned char *buf, int len)
+{
+ gchar *ret = g_try_malloc(len * 2 + 1);
+ int i;
+
+ for (i = 0; ret && i < len; i++)
+ g_snprintf(ret + i * 2, 3, "%02x", buf[i]);
+
+ return ret;
+}
+
+/*
+ * DUID should not change over time so save it to file.
+ * See RFC 3315 chapter 9 for details.
+ */
+static int set_duid(struct connman_service *service,
+ struct connman_network *network,
+ GDHCPClient *dhcp_client, int index)
+{
+ GKeyFile *keyfile;
+ const char *ident;
+ char *hex_duid;
+ unsigned char *duid;
+ int duid_len;
+
+ ident = __connman_service_get_ident(service);
+
+ keyfile = connman_storage_load_service(ident);
+ if (!keyfile)
+ return -EINVAL;
+
+ hex_duid = g_key_file_get_string(keyfile, ident, "IPv6.DHCP.DUID",
+ NULL);
+ if (hex_duid) {
+ unsigned int i, j = 0, hex;
+ size_t hex_duid_len = strlen(hex_duid);
+
+ duid = g_try_malloc0(hex_duid_len / 2);
+ if (!duid) {
+ g_key_file_free(keyfile);
+ g_free(hex_duid);
+ return -ENOMEM;
+ }
+
+ for (i = 0; i < hex_duid_len; i += 2) {
+ sscanf(hex_duid + i, "%02x", &hex);
+ duid[j++] = hex;
+ }
+
+ duid_len = hex_duid_len / 2;
+ } else {
+ int ret;
+ int type = __connman_ipconfig_get_type_from_index(index);
+
+ ret = g_dhcpv6_create_duid(G_DHCPV6_DUID_LLT, index, type,
+ &duid, &duid_len);
+ if (ret < 0) {
+ g_key_file_free(keyfile);
+ return ret;
+ }
+
+ hex_duid = convert_to_hex(duid, duid_len);
+ if (!hex_duid) {
+ g_key_file_free(keyfile);
+ return -ENOMEM;
+ }
+
+ g_key_file_set_string(keyfile, ident, "IPv6.DHCP.DUID",
+ hex_duid);
+
+ __connman_storage_save_service(keyfile, ident);
+ }
+ g_free(hex_duid);
+
+ g_key_file_free(keyfile);
+
+ g_dhcpv6_client_set_duid(dhcp_client, duid, duid_len);
+
+ return 0;
+}
+
+static void clear_callbacks(GDHCPClient *dhcp_client)
+{
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_SOLICITATION,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_ADVERTISE,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_REQUEST,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_CONFIRM,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_RENEW,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_REBIND,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_RELEASE,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_DECLINE,
+ NULL, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_INFORMATION_REQ,
+ NULL, NULL);
+}
+
+static void info_req_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ struct connman_service *service;
+ int entries, i;
+ GList *option, *list;
+ char **nameservers, **timeservers;
+
+ DBG("dhcpv6 information-request %p", dhcp);
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ connman_error("Can not lookup service");
+ return;
+ }
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ entries = g_list_length(option);
+
+ nameservers = g_try_new0(char *, entries + 1);
+ if (nameservers) {
+ for (i = 0, list = option; list; list = list->next, i++)
+ nameservers[i] = g_strdup(list->data);
+ }
+
+ if (!compare_string_arrays(nameservers, dhcp->nameservers)) {
+ if (dhcp->nameservers) {
+ for (i = 0; dhcp->nameservers[i]; i++)
+ __connman_service_nameserver_remove(service,
+ dhcp->nameservers[i],
+ false);
+ g_strfreev(dhcp->nameservers);
+ }
+
+ dhcp->nameservers = nameservers;
+
+ for (i = 0; dhcp->nameservers &&
+ dhcp->nameservers[i]; i++)
+ __connman_service_nameserver_append(service,
+ dhcp->nameservers[i],
+ false);
+ } else
+ g_strfreev(nameservers);
+
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+ entries = g_list_length(option);
+
+ timeservers = g_try_new0(char *, entries + 1);
+ if (timeservers) {
+ for (i = 0, list = option; list; list = list->next, i++)
+ timeservers[i] = g_strdup(list->data);
+ }
+
+ if (!compare_string_arrays(timeservers, dhcp->timeservers)) {
+ if (dhcp->timeservers) {
+ for (i = 0; dhcp->timeservers[i]; i++)
+ __connman_service_timeserver_remove(service,
+ dhcp->timeservers[i]);
+ g_strfreev(dhcp->timeservers);
+ }
+
+ dhcp->timeservers = timeservers;
+
+ for (i = 0; dhcp->timeservers &&
+ dhcp->timeservers[i]; i++)
+ __connman_service_timeserver_append(service,
+ dhcp->timeservers[i]);
+ } else
+ g_strfreev(timeservers);
+
+
+ if (dhcp->callback) {
+ uint16_t status = g_dhcpv6_client_get_status(dhcp_client);
+ dhcp->callback(dhcp->network, status == 0 ?
+ CONNMAN_DHCPV6_STATUS_SUCCEED :
+ CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
+ }
+}
+
+static int dhcpv6_info_request(struct connman_dhcpv6 *dhcp)
+{
+ struct connman_service *service;
+ GDHCPClient *dhcp_client;
+ GDHCPClientError error;
+ int index, ret;
+
+ DBG("dhcp %p", dhcp);
+
+ index = connman_network_get_index(dhcp->network);
+
+ dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
+ if (error != G_DHCP_CLIENT_ERROR_NONE) {
+ clear_timer(dhcp);
+ return -EINVAL;
+ }
+
+ if (getenv("CONNMAN_DHCPV6_DEBUG"))
+ g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ clear_timer(dhcp);
+ g_dhcp_client_unref(dhcp_client);
+ return -EINVAL;
+ }
+
+ ret = set_duid(service, dhcp->network, dhcp_client, index);
+ if (ret < 0) {
+ clear_timer(dhcp);
+ g_dhcp_client_unref(dhcp_client);
+ return ret;
+ }
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_INFORMATION_REQ, info_req_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static int check_ipv6_addr_prefix(GSList *prefixes, char *address)
+{
+ struct in6_addr addr_prefix, addr;
+ GSList *list;
+ int ret = 128, len;
+
+ for (list = prefixes; list; list = list->next) {
+ char *prefix = list->data;
+ const char *slash = g_strrstr(prefix, "/");
+ const unsigned char bits[] = { 0x00, 0xFE, 0xFC, 0xF8,
+ 0xF0, 0xE0, 0xC0, 0x80 };
+ int left, count, i, plen;
+
+ if (!slash)
+ continue;
+
+ prefix = g_strndup(prefix, slash - prefix);
+ len = strtol(slash + 1, NULL, 10);
+ if (len < 3 || len > 128)
+ break;
+
+ plen = 128 - len;
+
+ count = plen / 8;
+ left = plen % 8;
+ i = 16 - count;
+
+ inet_pton(AF_INET6, prefix, &addr_prefix);
+ inet_pton(AF_INET6, address, &addr);
+
+ memset(&addr_prefix.s6_addr[i], 0, count);
+ memset(&addr.s6_addr[i], 0, count);
+
+ if (left) {
+ addr_prefix.s6_addr[i - 1] &= bits[left];
+ addr.s6_addr[i - 1] &= bits[left];
+ }
+
+ g_free(prefix);
+
+ if (memcmp(&addr_prefix, &addr, 16) == 0) {
+ ret = len;
+ break;
+ }
+ }
+
+ return ret;
+}
+
+static int set_other_addresses(GDHCPClient *dhcp_client,
+ struct connman_dhcpv6 *dhcp)
+{
+ struct connman_service *service;
+ int entries, i;
+ GList *option, *list;
+ char **nameservers, **timeservers;
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ connman_error("Can not lookup service");
+ return -EINVAL;
+ }
+
+ /*
+ * Check domains before nameservers so that the nameserver append
+ * function will update domain list in service.c
+ */
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ entries = g_list_length(option);
+ if (entries > 0) {
+ char **domains = g_try_new0(char *, entries + 1);
+ if (domains) {
+ for (i = 0, list = option; list;
+ list = list->next, i++)
+ domains[i] = g_strdup(list->data);
+ __connman_service_set_search_domains(service, domains);
+ g_strfreev(domains);
+ }
+ }
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ entries = g_list_length(option);
+
+ nameservers = g_try_new0(char *, entries + 1);
+ if (nameservers) {
+ for (i = 0, list = option; list; list = list->next, i++)
+ nameservers[i] = g_strdup(list->data);
+ }
+
+ if (!compare_string_arrays(nameservers, dhcp->nameservers)) {
+ if (dhcp->nameservers) {
+ for (i = 0; dhcp->nameservers[i]; i++)
+ __connman_service_nameserver_remove(service,
+ dhcp->nameservers[i],
+ false);
+ g_strfreev(dhcp->nameservers);
+ }
+
+ dhcp->nameservers = nameservers;
+
+ for (i = 0; dhcp->nameservers &&
+ dhcp->nameservers[i]; i++)
+ __connman_service_nameserver_append(service,
+ dhcp->nameservers[i],
+ false);
+ } else
+ g_strfreev(nameservers);
+
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+ entries = g_list_length(option);
+
+ timeservers = g_try_new0(char *, entries + 1);
+ if (timeservers) {
+ for (i = 0, list = option; list; list = list->next, i++)
+ timeservers[i] = g_strdup(list->data);
+ }
+
+ if (!compare_string_arrays(timeservers, dhcp->timeservers)) {
+ if (dhcp->timeservers) {
+ for (i = 0; dhcp->timeservers[i]; i++)
+ __connman_service_timeserver_remove(service,
+ dhcp->timeservers[i]);
+ g_strfreev(dhcp->timeservers);
+ }
+
+ dhcp->timeservers = timeservers;
+
+ for (i = 0; dhcp->timeservers &&
+ dhcp->timeservers[i]; i++)
+ __connman_service_timeserver_append(service,
+ dhcp->timeservers[i]);
+ } else
+ g_strfreev(timeservers);
+
+ return 0;
+}
+
+static GSList *copy_prefixes(GSList *prefixes)
+{
+ GSList *list, *copy = NULL;
+
+ for (list = prefixes; list; list = list->next)
+ copy = g_slist_prepend(copy, g_strdup(list->data));
+
+ return copy;
+}
+
+/*
+ * Helper struct for doing DAD (duplicate address detection).
+ * It is refcounted and freed after all reply's to neighbor
+ * discovery request are received.
+ */
+struct own_address {
+ int refcount;
+
+ int ifindex;
+ GDHCPClient *dhcp_client;
+ struct connman_ipconfig *ipconfig;
+ GSList *prefixes;
+ dhcpv6_cb callback;
+
+ GSList *dad_failed;
+ GSList *dad_succeed;
+};
+
+static void free_own_address(struct own_address *data)
+{
+ g_dhcp_client_unref(data->dhcp_client);
+ __connman_ipconfig_unref(data->ipconfig);
+ g_slist_free_full(data->prefixes, free_prefix);
+ g_slist_free_full(data->dad_failed, g_free);
+ g_slist_free_full(data->dad_succeed, g_free);
+
+ g_free(data);
+}
+
+static struct own_address *ref_own_address(struct own_address *address)
+{
+ DBG("%p ref %d", address, address->refcount + 1);
+
+ __sync_fetch_and_add(&address->refcount, 1);
+
+ return address;
+}
+
+static void unref_own_address(struct own_address *address)
+{
+ if (!address)
+ return;
+
+ DBG("%p ref %d", address, address->refcount - 1);
+
+ if (__sync_fetch_and_sub(&address->refcount, 1) != 1)
+ return;
+
+ free_own_address(address);
+}
+
+static void set_address(int ifindex, struct connman_ipconfig *ipconfig,
+ GSList *prefixes, char *address)
+{
+ const char *c_address;
+
+ c_address = __connman_ipconfig_get_local(ipconfig);
+
+ if (address && ((c_address && g_strcmp0(address, c_address) != 0) ||
+ !c_address)) {
+ int prefix_len;
+
+ /* Is this prefix part of the subnet we are suppose to use? */
+ prefix_len = check_ipv6_addr_prefix(prefixes, address);
+
+ __connman_ipconfig_address_remove(ipconfig);
+ __connman_ipconfig_set_local(ipconfig, address);
+ __connman_ipconfig_set_prefixlen(ipconfig, prefix_len);
+
+ DBG("new address %s/%d", address, prefix_len);
+
+ __connman_ipconfig_set_dhcp_address(ipconfig, address);
+ __connman_service_save(
+ __connman_service_lookup_from_index(ifindex));
+ }
+}
+
+
+/*
+ * Helper struct that is used when waiting a reply to DECLINE message.
+ */
+struct decline_cb_data {
+ GDHCPClient *dhcp_client;
+ dhcpv6_cb callback;
+ int ifindex;
+ guint timeout;
+};
+
+static void decline_reply_callback(struct decline_cb_data *data)
+{
+ struct connman_network *network;
+ struct connman_service *service;
+
+ service = __connman_service_lookup_from_index(data->ifindex);
+ network = __connman_service_get_network(service);
+
+ if (data->callback)
+ data->callback(network, CONNMAN_DHCPV6_STATUS_RESTART, NULL);
+
+ g_dhcp_client_unref(data->dhcp_client);
+}
+
+static gboolean decline_timeout(gpointer user_data)
+{
+ struct decline_cb_data *data = user_data;
+
+ DBG("ifindex %d", data->ifindex);
+
+ /*
+ * We ignore all DECLINE replies that are received after the timeout
+ */
+ g_dhcp_client_register_event(data->dhcp_client,
+ G_DHCP_CLIENT_EVENT_DECLINE,
+ NULL, NULL);
+
+ decline_reply_callback(data);
+
+ g_free(data);
+
+ return FALSE;
+}
+
+static void decline_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct decline_cb_data *data = user_data;
+
+ DBG("ifindex %d", data->ifindex);
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ if (data->timeout)
+ g_source_remove(data->timeout);
+
+ decline_reply_callback(data);
+
+ g_free(data);
+}
+
+static int dhcpv6_decline(GDHCPClient *dhcp_client, int ifindex,
+ dhcpv6_cb callback, GSList *failed)
+{
+ struct decline_cb_data *data;
+ GList *option;
+ int code;
+
+ DBG("dhcp_client %p", dhcp_client);
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcpv6_client_clear_send(dhcp_client, G_DHCPV6_ORO);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
+ if (!option) {
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
+ if (option)
+ code = G_DHCPV6_IA_TA;
+ else
+ return -EINVAL;
+ } else
+ code = G_DHCPV6_IA_NA;
+
+ g_dhcpv6_client_clear_send(dhcp_client, code);
+
+ g_dhcpv6_client_set_ias(dhcp_client, ifindex, code, NULL, NULL,
+ failed);
+
+ clear_callbacks(dhcp_client);
+
+ data = g_try_new(struct decline_cb_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ data->ifindex = ifindex;
+ data->callback = callback;
+ data->dhcp_client = g_dhcp_client_ref(dhcp_client);
+ data->timeout = g_timeout_add(DEC_TIMEOUT, decline_timeout, data);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_DECLINE,
+ decline_cb, data);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static void dad_reply(struct nd_neighbor_advert *reply,
+ unsigned int length, struct in6_addr *addr, void *user_data)
+{
+ struct own_address *data = user_data;
+ GSList *list;
+ char address[INET6_ADDRSTRLEN];
+ enum __connman_dhcpv6_status status = CONNMAN_DHCPV6_STATUS_FAIL;
+
+ inet_ntop(AF_INET6, addr, address, INET6_ADDRSTRLEN);
+
+ DBG("user %p reply %p len %d address %s index %d data %p", user_data,
+ reply, length, address, data->ifindex, data);
+
+ if (!reply) {
+ if (length == 0)
+ DBG("DAD succeed for %s", address);
+ else
+ DBG("DAD cannot be done for %s", address);
+
+ data->dad_succeed = g_slist_prepend(data->dad_succeed,
+ g_strdup(address));
+
+ } else {
+ DBG("DAD failed for %s", address);
+
+ data->dad_failed = g_slist_prepend(data->dad_failed,
+ g_strdup(address));
+ }
+
+ /*
+ * If refcount == 1 then we got the final reply and can continue.
+ */
+ if (data->refcount > 1)
+ return;
+
+ for (list = data->dad_succeed; list; list = list->next)
+ set_address(data->ifindex, data->ipconfig, data->prefixes,
+ list->data);
+
+ if (data->dad_failed) {
+ dhcpv6_decline(data->dhcp_client, data->ifindex,
+ data->callback, data->dad_failed);
+ } else {
+ if (data->dad_succeed)
+ status = CONNMAN_DHCPV6_STATUS_SUCCEED;
+
+ if (data->callback) {
+ struct connman_network *network;
+ struct connman_service *service;
+
+ service = __connman_service_lookup_from_index(
+ data->ifindex);
+ network = __connman_service_get_network(service);
+ if (network)
+ data->callback(network, status, NULL);
+ }
+ }
+
+ unref_own_address(data);
+}
+
+/*
+ * Is the kernel configured to do DAD? If 0, then do not do DAD.
+ * See also RFC 4862 chapter 5.4 about DupAddrDetectTransmits
+ */
+static int dad_transmits(int ifindex)
+{
+ char name[IF_NAMESIZE];
+ gchar *path;
+ int value = 1;
+ FILE *f;
+
+ if (!if_indextoname(ifindex, name))
+ return value;
+
+ path = g_strdup_printf("/proc/sys/net/ipv6/conf/%s/dad_transmits",
+ name);
+
+ if (!path)
+ return value;
+
+ f = fopen(path, "r");
+
+ g_free(path);
+
+ if (f) {
+ if (fscanf(f, "%d", &value) < 0)
+ value = 1;
+
+ fclose(f);
+ }
+
+ return value;
+}
+
+static void do_dad(GDHCPClient *dhcp_client, struct connman_dhcpv6 *dhcp)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+ int ifindex;
+ GList *option, *list;
+ struct own_address *user_data;
+
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_NA);
+ if (!option)
+ option = g_dhcp_client_get_option(dhcp_client, G_DHCPV6_IA_TA);
+
+ /*
+ * Even if we didn't had any addresses, just try to set
+ * the other options.
+ */
+ set_other_addresses(dhcp_client, dhcp);
+
+ if (!option) {
+ DBG("Skip DAD as no addresses found in reply");
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, NULL);
+
+ return;
+ }
+
+ ifindex = connman_network_get_index(dhcp->network);
+
+ DBG("index %d", ifindex);
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ connman_error("Can not lookup service for index %d", ifindex);
+ goto error;
+ }
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (!ipconfig) {
+ connman_error("Could not lookup ip6config for index %d",
+ ifindex);
+ goto error;
+ }
+
+ if (!dad_transmits(ifindex)) {
+ DBG("Skip DAD because of kernel configuration");
+
+ for (list = option; list; list = list->next)
+ set_address(ifindex, ipconfig, dhcp->prefixes,
+ option->data);
+
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, NULL);
+
+ return;
+ }
+
+ if (g_list_length(option) == 0) {
+ DBG("No addresses when doing DAD");
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, NULL);
+
+ return;
+ }
+
+ user_data = g_try_new0(struct own_address, 1);
+ if (!user_data)
+ goto error;
+
+ user_data->refcount = 0;
+ user_data->ifindex = ifindex;
+ user_data->dhcp_client = g_dhcp_client_ref(dhcp_client);
+ user_data->ipconfig = __connman_ipconfig_ref(ipconfig);
+ user_data->prefixes = copy_prefixes(dhcp->prefixes);
+ user_data->callback = dhcp->callback;
+
+ /*
+ * We send one neighbor discovery request / address
+ * and after all checks are done, then report the status
+ * via dhcp callback.
+ */
+
+ for (list = option; list; list = list->next) {
+ char *address = option->data;
+ struct in6_addr addr;
+ int ret;
+
+ ref_own_address(user_data);
+
+ if (inet_pton(AF_INET6, address, &addr) < 0) {
+ DBG("Invalid IPv6 address %s %d/%s", address,
+ -errno, strerror(errno));
+ goto fail;
+ }
+
+ DBG("user %p address %s client %p ipconfig %p prefixes %p",
+ user_data, address,
+ user_data->dhcp_client, user_data->ipconfig,
+ user_data->prefixes);
+
+ ret = __connman_inet_ipv6_do_dad(ifindex, 1000,
+ &addr,
+ dad_reply,
+ user_data);
+ if (ret < 0) {
+ DBG("Could not send neighbor solicitation for %s",
+ address);
+ dad_reply(NULL, -1, &addr, user_data);
+ } else {
+ DBG("Sent neighbor solicitation %d bytes", ret);
+ }
+ }
+
+ return;
+
+fail:
+ unref_own_address(user_data);
+
+error:
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network, CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
+}
+
+static gboolean timeout_request_resend(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return FALSE;
+ }
+
+ dhcp->request_count++;
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request resend RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request_resend, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean request_resend(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request resend RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request_resend, dhcp);
+
+ dhcpv6_request(dhcp, true);
+
+ return FALSE;
+}
+
+static void do_resend_request(struct connman_dhcpv6 *dhcp)
+{
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+
+ dhcp->request_count++;
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("resending request after %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, request_resend, dhcp);
+}
+
+static void re_cb(enum request_type req_type, GDHCPClient *dhcp_client,
+ gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ uint16_t status;
+
+ clear_timer(dhcp);
+
+ status = g_dhcpv6_client_get_status(dhcp_client);
+
+ DBG("dhcpv6 cb msg %p status %d", dhcp, status);
+
+ /*
+ * RFC 3315, 18.1.8 handle the resend if error
+ */
+ if (status == G_DHCPV6_ERROR_BINDING) {
+ dhcpv6_request(dhcp, false);
+ } else if (status == G_DHCPV6_ERROR_MCAST) {
+ switch (req_type) {
+ case REQ_REQUEST:
+ dhcpv6_request(dhcp, true);
+ break;
+ case REQ_REBIND:
+ dhcpv6_rebind(dhcp);
+ break;
+ case REQ_RENEW:
+ dhcpv6_renew(dhcp);
+ break;
+ }
+ } else if (status == G_DHCPV6_ERROR_LINK) {
+ if (req_type == REQ_REQUEST) {
+ g_dhcp_client_unref(dhcp->dhcp_client);
+ start_solicitation(dhcp);
+ } else {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ }
+ } else if (status == G_DHCPV6_ERROR_FAILURE) {
+ if (req_type == REQ_REQUEST) {
+ /* Rate limit the resend of request message */
+ do_resend_request(dhcp);
+ } else {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ }
+ } else {
+
+ /*
+ * If we did not got any addresses, then re-send
+ * a request.
+ */
+ GList *option;
+
+ option = g_dhcp_client_get_option(dhcp->dhcp_client,
+ G_DHCPV6_IA_NA);
+ if (!option) {
+ option = g_dhcp_client_get_option(dhcp->dhcp_client,
+ G_DHCPV6_IA_TA);
+ if (!option) {
+ switch (req_type) {
+ case REQ_REQUEST:
+ do_resend_request(dhcp);
+ break;
+ case REQ_REBIND:
+ dhcpv6_rebind(dhcp);
+ break;
+ case REQ_RENEW:
+ dhcpv6_renew(dhcp);
+ break;
+ }
+ return;
+ }
+ }
+
+ if (status == G_DHCPV6_ERROR_SUCCESS)
+ do_dad(dhcp_client, dhcp);
+ else if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ }
+}
+
+static void rebind_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_reset_request(dhcp_client);
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_cb(REQ_REBIND, dhcp_client, user_data);
+}
+
+static int dhcpv6_rebind(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_ia(dhcp_client,
+ connman_network_get_index(dhcp->network),
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ NULL, NULL, TRUE, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REBIND,
+ rebind_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean dhcpv6_restart(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network, CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
+
+ return FALSE;
+}
+
+/*
+ * Check if we need to restart the solicitation procedure. This
+ * is done if all the addresses have expired. RFC 3315, 18.1.4
+ */
+static int check_restart(struct connman_dhcpv6 *dhcp)
+{
+ time_t current, expired;
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, NULL,
+ NULL, &expired);
+ current = time(NULL);
+
+ if (current >= expired) {
+ DBG("expired by %d secs", (int)(current - expired));
+
+ g_timeout_add(0, dhcpv6_restart, dhcp);
+
+ return -ETIMEDOUT;
+ }
+
+ return 0;
+}
+
+static gboolean timeout_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = calc_delay(dhcp->RT, REB_MAX_RT);
+
+ DBG("rebind RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = initial_rt(REB_TIMEOUT);
+
+ DBG("rebind initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_rebind, dhcp);
+
+ dhcpv6_rebind(dhcp);
+
+ return FALSE;
+}
+
+static void request_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_reset_request(dhcp_client);
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_cb(REQ_REQUEST, dhcp_client, user_data);
+}
+
+static int dhcpv6_request(struct connman_dhcpv6 *dhcp,
+ bool add_addresses)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p add %d", dhcp, add_addresses);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_ia(dhcp_client,
+ connman_network_get_index(dhcp->network),
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ &T1, &T2, add_addresses, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
+ request_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean timeout_request(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return FALSE;
+ }
+
+ dhcp->request_count++;
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static void renew_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_reset_request(dhcp_client);
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_cb(REQ_RENEW, dhcp_client, user_data);
+}
+
+static int dhcpv6_renew(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_ia(dhcp_client,
+ connman_network_get_index(dhcp->network),
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ &T1, &T2, TRUE, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_RENEW,
+ renew_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean timeout_renew(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ time_t last_rebind, current;
+ uint32_t T2;
+
+ if (check_restart(dhcp) < 0)
+ return FALSE;
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, &T2,
+ &last_rebind, NULL);
+ current = time(NULL);
+ if ((unsigned)current >= (unsigned)last_rebind + T2) {
+ /*
+ * Do rebind instead if past T2
+ */
+ start_rebind(dhcp);
+ return FALSE;
+ }
+
+ dhcp->RT = calc_delay(dhcp->RT, REN_MAX_RT);
+
+ DBG("renew RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_renew, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_renew(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = initial_rt(REN_TIMEOUT);
+
+ DBG("renew initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_renew, dhcp);
+
+ dhcpv6_renew(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start_renew(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ uint32_t T1, T2, delta;
+ time_t started, current, expired;
+
+ dhcp = g_hash_table_lookup(network_table, network);
+ if (!dhcp)
+ return -ENOENT;
+
+ DBG("network %p dhcp %p", network, dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, &T1, &T2,
+ &started, &expired);
+
+ current = time(NULL);
+
+ DBG("T1 %u T2 %u expires %lu current %lu started %lu", T1, T2,
+ (unsigned long)expired, current, started);
+
+ if (T1 == 0xffffffff)
+ /* RFC 3315, 22.4 */
+ return 0;
+
+ if (T1 == 0) {
+ /* RFC 3315, 22.4
+ * Client can choose the timeout.
+ */
+ T1 = (expired - started) / 2;
+ T2 = (expired - started) / 10 * 8;
+ }
+
+ dhcp->callback = callback;
+
+ /* RFC 3315, 18.1.4, start solicit if expired */
+ if (check_restart(dhcp) < 0)
+ return 0;
+
+ if (T2 != 0xffffffff && T2 > 0) {
+ if ((unsigned)current >= (unsigned)started + T2) {
+ /* RFC 3315, chapter 18.1.3, start rebind */
+ DBG("start rebind immediately");
+
+ dhcp->timeout = g_timeout_add_seconds(0, start_rebind,
+ dhcp);
+
+ } else if ((unsigned)current < (unsigned)started + T1) {
+ delta = started + T1 - current;
+ DBG("renew after %d secs", delta);
+
+ dhcp->timeout = g_timeout_add_seconds(delta,
+ start_renew, dhcp);
+ } else {
+ delta = started + T2 - current;
+ DBG("rebind after %d secs", delta);
+
+ dhcp->timeout = g_timeout_add_seconds(delta,
+ start_rebind, dhcp);
+ }
+ }
+
+ return 0;
+}
+
+static void release_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+}
+
+int __connman_dhcpv6_start_release(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ GDHCPClient *dhcp_client;
+
+ if (!network_table)
+ return 0; /* we are already released */
+
+ dhcp = g_hash_table_lookup(network_table, network);
+ if (!dhcp)
+ return -ENOENT;
+
+ DBG("network %p dhcp %p client %p stateless %d", network, dhcp,
+ dhcp->dhcp_client, dhcp->stateless);
+
+ if (dhcp->stateless)
+ return -EINVAL;
+
+ clear_timer(dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+ if (!dhcp_client) {
+ /*
+ * We had started the DHCPv6 handshaking i.e., we have called
+ * __connman_dhcpv6_start() but it has not yet sent
+ * a solicitation message to server. This means that we do not
+ * have DHCPv6 configured yet so we can just quit here.
+ */
+ DBG("DHCPv6 was not started");
+ return 0;
+ }
+
+ g_dhcp_client_clear_requests(dhcp_client);
+ g_dhcp_client_clear_values(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+
+ g_dhcpv6_client_set_ia(dhcp_client,
+ connman_network_get_index(dhcp->network),
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ NULL, NULL, TRUE, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ /*
+ * Although we register a callback here we are really not interested in
+ * the answer because it might take too long time and network code
+ * might be in the middle of the disconnect.
+ * So we just inform the server that we are done with the addresses
+ * but ignore the reply from server. This is allowed by RFC 3315
+ * chapter 18.1.6.
+ */
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_RELEASE,
+ release_cb, NULL);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static int dhcpv6_release(struct connman_dhcpv6 *dhcp)
+{
+ DBG("dhcp %p", dhcp);
+
+ clear_timer(dhcp);
+
+ dhcpv6_free(dhcp);
+
+ if (!dhcp->dhcp_client)
+ return 0;
+
+ g_dhcp_client_stop(dhcp->dhcp_client);
+ g_dhcp_client_unref(dhcp->dhcp_client);
+
+ dhcp->dhcp_client = NULL;
+
+ return 0;
+}
+
+static void remove_network(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcpv6_release(dhcp);
+
+ g_free(dhcp);
+}
+
+static gboolean timeout_info_req(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = calc_delay(dhcp->RT, INF_MAX_RT);
+
+ DBG("info RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_info_req(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ /* Set the retransmission timeout, RFC 3315 chapter 14 */
+ dhcp->RT = initial_rt(INF_TIMEOUT);
+
+ DBG("info initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_info_req, dhcp);
+
+ dhcpv6_info_request(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start_info(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ int delay;
+ uint64_t rand;
+
+ DBG("");
+
+ if (network_table) {
+ dhcp = g_hash_table_lookup(network_table, network);
+ if (dhcp && dhcp->started)
+ return -EBUSY;
+ }
+
+ dhcp = g_try_new0(struct connman_dhcpv6, 1);
+ if (!dhcp)
+ return -ENOMEM;
+
+ dhcp->network = network;
+ dhcp->callback = callback;
+ dhcp->stateless = true;
+ dhcp->started = true;
+
+ connman_network_ref(network);
+
+ DBG("replace network %p dhcp %p", network, dhcp);
+
+ g_hash_table_replace(network_table, network, dhcp);
+
+ /* Initial timeout, RFC 3315, 18.1.5 */
+ __connman_util_get_random(&rand);
+ delay = rand % 1000;
+
+ dhcp->timeout = g_timeout_add(delay, start_info_req, dhcp);
+
+ return 0;
+}
+
+static void advertise_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ DBG("dhcpv6 advertise msg %p", dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+
+ dhcp->RT = initial_rt(REQ_TIMEOUT);
+ DBG("request initial RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_request, dhcp);
+
+ dhcp->request_count = 1;
+
+ dhcpv6_request(dhcp, true);
+}
+
+static void solicitation_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ /* We get here if server supports rapid commit */
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ DBG("dhcpv6 solicitation msg %p", dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+
+ do_dad(dhcp_client, dhcp);
+}
+
+static gboolean timeout_solicitation(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = calc_delay(dhcp->RT, SOL_MAX_RT);
+
+ DBG("solicit RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static int dhcpv6_solicitation(struct connman_dhcpv6 *dhcp)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig_ipv6;
+ GDHCPClient *dhcp_client;
+ GDHCPClientError error;
+ int index, ret;
+
+ DBG("dhcp %p", dhcp);
+
+ index = connman_network_get_index(dhcp->network);
+
+ dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
+ if (error != G_DHCP_CLIENT_ERROR_NONE) {
+ clear_timer(dhcp);
+ return -EINVAL;
+ }
+
+ if (getenv("CONNMAN_DHCPV6_DEBUG"))
+ g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6");
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ clear_timer(dhcp);
+ g_dhcp_client_unref(dhcp_client);
+ return -EINVAL;
+ }
+
+ ret = set_duid(service, dhcp->network, dhcp_client, index);
+ if (ret < 0) {
+ clear_timer(dhcp);
+ g_dhcp_client_unref(dhcp_client);
+ return ret;
+ }
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_RAPID_COMMIT);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DOMAIN_LIST);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_set_oro(dhcp_client, 3, G_DHCPV6_DNS_SERVERS,
+ G_DHCPV6_DOMAIN_LIST, G_DHCPV6_SNTP_SERVERS);
+
+ ipconfig_ipv6 = __connman_service_get_ip6config(service);
+ dhcp->use_ta = __connman_ipconfig_ipv6_privacy_enabled(ipconfig_ipv6);
+
+ g_dhcpv6_client_set_ia(dhcp_client, index,
+ dhcp->use_ta ? G_DHCPV6_IA_TA : G_DHCPV6_IA_NA,
+ NULL, NULL, FALSE, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_SOLICITATION,
+ solicitation_cb, dhcp);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_ADVERTISE,
+ advertise_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean start_solicitation(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ /* Set the retransmission timeout, RFC 3315 chapter 14 */
+ dhcp->RT = initial_rt(SOL_TIMEOUT);
+
+ DBG("solicit initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
+
+ dhcpv6_solicitation(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start(struct connman_network *network,
+ GSList *prefixes, dhcpv6_cb callback)
+{
+ struct connman_service *service;
+ struct connman_dhcpv6 *dhcp;
+ int delay;
+ uint64_t rand;
+
+ DBG("");
+
+ if (network_table) {
+ dhcp = g_hash_table_lookup(network_table, network);
+ if (dhcp && dhcp->started)
+ return -EBUSY;
+ }
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+
+ dhcp = g_try_new0(struct connman_dhcpv6, 1);
+ if (!dhcp)
+ return -ENOMEM;
+
+ dhcp->network = network;
+ dhcp->callback = callback;
+ dhcp->prefixes = prefixes;
+ dhcp->started = true;
+
+ connman_network_ref(network);
+
+ DBG("replace network %p dhcp %p", network, dhcp);
+
+ g_hash_table_replace(network_table, network, dhcp);
+
+ /* Initial timeout, RFC 3315, 17.1.2 */
+ __connman_util_get_random(&rand);
+ delay = rand % 1000;
+
+ /*
+ * Start from scratch.
+ * RFC 3315, chapter 17.1.2 Solicitation message
+ *
+ * Note that we do not send CONFIRM message here as it does
+ * not make much sense because we do not save expiration time
+ * so we cannot really know how long the saved address is valid
+ * anyway. The reply to CONFIRM message does not send
+ * expiration times back to us. Because of this we need to
+ * start using SOLICITATION anyway.
+ */
+ dhcp->timeout = g_timeout_add(delay, start_solicitation, dhcp);
+
+ return 0;
+}
+
+void __connman_dhcpv6_stop(struct connman_network *network)
+{
+ DBG("");
+
+ if (!network_table)
+ return;
+
+ if (g_hash_table_remove(network_table, network))
+ connman_network_unref(network);
+}
+
+static int save_prefixes(struct connman_ipconfig *ipconfig,
+ GSList *prefixes)
+{
+ GSList *list;
+ int i = 0, count = g_slist_length(prefixes);
+ char **array;
+
+ if (count == 0)
+ return 0;
+
+ array = g_try_new0(char *, count + 1);
+ if (!array)
+ return -ENOMEM;
+
+ for (list = prefixes; list; list = list->next) {
+ char *elem, addr_str[INET6_ADDRSTRLEN];
+ GDHCPIAPrefix *prefix = list->data;
+
+ elem = g_strdup_printf("%s/%d", inet_ntop(AF_INET6,
+ &prefix->prefix, addr_str, INET6_ADDRSTRLEN),
+ prefix->prefixlen);
+ if (!elem) {
+ g_strfreev(array);
+ return -ENOMEM;
+ }
+
+ array[i++] = elem;
+ }
+
+ __connman_ipconfig_set_dhcpv6_prefixes(ipconfig, array);
+ return 0;
+}
+
+static GSList *load_prefixes(struct connman_ipconfig *ipconfig)
+{
+ int i;
+ GSList *list = NULL;
+ char **array = __connman_ipconfig_get_dhcpv6_prefixes(ipconfig);
+
+ if (!array)
+ return NULL;
+
+ for (i = 0; array[i]; i++) {
+ GDHCPIAPrefix *prefix;
+ long int value;
+ char *ptr, **elems = g_strsplit(array[i], "/", 0);
+
+ if (!elems)
+ return list;
+
+ value = strtol(elems[1], &ptr, 10);
+ if (ptr != elems[1] && *ptr == '\0' && value <= 128) {
+ struct in6_addr addr;
+
+ if (inet_pton(AF_INET6, elems[0], &addr) == 1) {
+ prefix = g_try_new0(GDHCPIAPrefix, 1);
+ if (!prefix) {
+ g_strfreev(elems);
+ return list;
+ }
+ memcpy(&prefix->prefix, &addr,
+ sizeof(struct in6_addr));
+ prefix->prefixlen = value;
+
+ list = g_slist_prepend(list, prefix);
+ }
+ }
+
+ g_strfreev(elems);
+ }
+
+ return list;
+}
+
+static GDHCPIAPrefix *copy_prefix(gpointer data)
+{
+ GDHCPIAPrefix *copy, *prefix = data;
+
+ copy = g_try_new(GDHCPIAPrefix, 1);
+ if (!copy)
+ return NULL;
+
+ memcpy(copy, prefix, sizeof(GDHCPIAPrefix));
+
+ return copy;
+}
+
+static GSList *copy_and_convert_prefixes(GList *prefixes)
+{
+ GSList *copy = NULL;
+ GList *list;
+
+ for (list = prefixes; list; list = list->next)
+ copy = g_slist_prepend(copy, copy_prefix(list->data));
+
+ return copy;
+}
+
+static int set_prefixes(GDHCPClient *dhcp_client, struct connman_dhcpv6 *dhcp)
+{
+ if (dhcp->prefixes)
+ g_slist_free_full(dhcp->prefixes, free_prefix);
+
+ dhcp->prefixes =
+ copy_and_convert_prefixes(g_dhcp_client_get_option(dhcp_client,
+ G_DHCPV6_IA_PD));
+
+ DBG("Got %d prefix", g_slist_length(dhcp->prefixes));
+
+ if (dhcp->callback) {
+ uint16_t status = g_dhcpv6_client_get_status(dhcp_client);
+ if (status == G_DHCPV6_ERROR_NO_PREFIX)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ else {
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+ int ifindex = connman_network_get_index(dhcp->network);
+
+ service = __connman_service_lookup_from_index(ifindex);
+ if (service) {
+ ipconfig = __connman_service_get_ip6config(
+ service);
+ save_prefixes(ipconfig, dhcp->prefixes);
+ __connman_service_save(service);
+ }
+
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_SUCCEED, dhcp->prefixes);
+ }
+ } else {
+ g_slist_free_full(dhcp->prefixes, free_prefix);
+ dhcp->prefixes = NULL;
+ }
+
+ return 0;
+}
+
+static void re_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ uint16_t status;
+ int ret;
+
+ status = g_dhcpv6_client_get_status(dhcp_client);
+
+ DBG("dhcpv6 cb msg %p status %d", dhcp, status);
+
+ if (status == G_DHCPV6_ERROR_BINDING) {
+ /* RFC 3315, 18.1.8 */
+ dhcpv6_pd_request(dhcp);
+ } else {
+ ret = set_prefixes(dhcp_client, dhcp);
+ if (ret < 0) {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+ }
+}
+
+static void rebind_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_pd_cb(dhcp_client, user_data);
+}
+
+static GDHCPClient *create_pd_client(struct connman_dhcpv6 *dhcp, int *err)
+{
+ GDHCPClient *dhcp_client;
+ GDHCPClientError error;
+ struct connman_service *service;
+ int index, ret;
+ uint32_t iaid;
+
+ index = connman_network_get_index(dhcp->network);
+
+ dhcp_client = g_dhcp_client_new(G_DHCP_IPV6, index, &error);
+ if (error != G_DHCP_CLIENT_ERROR_NONE) {
+ *err = -EINVAL;
+ return NULL;
+ }
+
+ if (getenv("CONNMAN_DHCPV6_DEBUG"))
+ g_dhcp_client_set_debug(dhcp_client, dhcpv6_debug, "DHCPv6:PD");
+
+ service = connman_service_lookup_from_network(dhcp->network);
+ if (!service) {
+ g_dhcp_client_unref(dhcp_client);
+ *err = -EINVAL;
+ return NULL;
+ }
+
+ ret = set_duid(service, dhcp->network, dhcp_client, index);
+ if (ret < 0) {
+ g_dhcp_client_unref(dhcp_client);
+ *err = ret;
+ return NULL;
+ }
+
+ g_dhcpv6_client_create_iaid(dhcp_client, index, (unsigned char *)&iaid);
+ g_dhcpv6_client_set_iaid(dhcp_client, iaid);
+
+ return dhcp_client;
+}
+
+static int dhcpv6_pd_rebind(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p", dhcp);
+
+ if (!dhcp->dhcp_client) {
+ /*
+ * We skipped the solicitation phase
+ */
+ int err;
+
+ dhcp->dhcp_client = create_pd_client(dhcp, &err);
+ if (!dhcp->dhcp_client) {
+ clear_timer(dhcp);
+ return err;
+ }
+ }
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REBIND,
+ rebind_pd_cb, dhcp);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static void renew_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ re_pd_cb(dhcp_client, user_data);
+}
+
+static int dhcpv6_pd_renew(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_RENEW,
+ renew_pd_cb, dhcp);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+/*
+ * Check if we need to restart the solicitation procedure. This
+ * is done if all the prefixes have expired.
+ */
+static int check_pd_restart(struct connman_dhcpv6 *dhcp)
+{
+ time_t current, expired;
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, NULL, NULL,
+ NULL, &expired);
+ current = time(NULL);
+
+ if (current > expired) {
+ DBG("expired by %d secs", (int)(current - expired));
+
+ g_timeout_add(0, dhcpv6_restart, dhcp);
+
+ return -ETIMEDOUT;
+ }
+
+ return 0;
+}
+
+static gboolean timeout_pd_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_pd_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = calc_delay(dhcp->RT, REB_MAX_RT);
+
+ DBG("rebind RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_rebind, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_pd_rebind(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_pd_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = initial_rt(REB_TIMEOUT);
+
+ DBG("rebind initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_rebind, dhcp);
+
+ dhcpv6_pd_rebind(dhcp);
+
+ return FALSE;
+}
+
+static gboolean timeout_pd_rebind_confirm(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = calc_delay(dhcp->RT, CNF_MAX_RT);
+
+ DBG("rebind with confirm RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT,
+ timeout_pd_rebind_confirm, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean timeout_pd_max_confirm(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->MRD = 0;
+
+ clear_timer(dhcp);
+
+ DBG("rebind with confirm max retransmit duration timeout");
+
+ g_dhcpv6_client_clear_retransmit(dhcp->dhcp_client);
+
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_pd_rebind_with_confirm(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = initial_rt(CNF_TIMEOUT);
+
+ DBG("rebind with confirm initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT,
+ timeout_pd_rebind_confirm, dhcp);
+ dhcp->MRD = g_timeout_add(CNF_MAX_RD, timeout_pd_max_confirm, dhcp);
+
+ dhcpv6_pd_rebind(dhcp);
+
+ return FALSE;
+}
+
+static gboolean timeout_pd_renew(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (check_pd_restart(dhcp) < 0)
+ return FALSE;
+
+ dhcp->RT = calc_delay(dhcp->RT, REN_MAX_RT);
+
+ DBG("renew RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_renew, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static gboolean start_pd_renew(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ dhcp->RT = initial_rt(REN_TIMEOUT);
+
+ DBG("renew initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_renew, dhcp);
+
+ dhcpv6_pd_renew(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start_pd_renew(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ uint32_t T1, T2;
+ time_t started, current, expired;
+
+ dhcp = g_hash_table_lookup(network_pd_table, network);
+ if (!dhcp)
+ return -ENOENT;
+
+ DBG("network %p dhcp %p", network, dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_get_timeouts(dhcp->dhcp_client, &T1, &T2,
+ &started, &expired);
+
+ current = time(NULL);
+
+ DBG("T1 %u T2 %u expires %lu current %lu started %lu", T1, T2,
+ expired, current, started);
+
+ if (T1 == 0xffffffff)
+ /* RFC 3633, ch 9 */
+ return 0;
+
+ if (T1 == 0)
+ /* RFC 3633, ch 9
+ * Client can choose the timeout.
+ */
+ T1 = 120;
+
+ dhcp->callback = callback;
+
+ /* RFC 3315, 18.1.4, start solicit if expired */
+ if (check_pd_restart(dhcp) < 0)
+ return 0;
+
+ if (T2 != 0xffffffff && T2 > 0) {
+ if ((unsigned)current >= (unsigned)started + T2) {
+ /* RFC 3315, chapter 18.1.3, start rebind */
+ DBG("rebind after %d secs", T2);
+
+ dhcp->timeout = g_timeout_add_seconds(T2,
+ start_pd_rebind,
+ dhcp);
+
+ } else if ((unsigned)current < (unsigned)started + T1) {
+ DBG("renew after %d secs", T1);
+
+ dhcp->timeout = g_timeout_add_seconds(T1,
+ start_pd_renew,
+ dhcp);
+ } else {
+ DBG("rebind after %d secs", T2 - T1);
+
+ dhcp->timeout = g_timeout_add_seconds(T2 - T1,
+ start_pd_rebind,
+ dhcp);
+ }
+ }
+
+ return 0;
+}
+
+static void release_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ DBG("");
+}
+
+int __connman_dhcpv6_start_pd_release(struct connman_network *network,
+ dhcpv6_cb callback)
+{
+ struct connman_dhcpv6 *dhcp;
+ GDHCPClient *dhcp_client;
+ uint32_t T1, T2;
+
+ if (!network_table)
+ return 0; /* we are already released */
+
+ dhcp = g_hash_table_lookup(network_pd_table, network);
+ if (!dhcp)
+ return -ENOENT;
+
+ DBG("network %p dhcp %p client %p", network, dhcp, dhcp->dhcp_client);
+
+ clear_timer(dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+ if (!dhcp_client) {
+ DBG("DHCPv6 PD was not started");
+ return 0;
+ }
+
+ g_dhcp_client_clear_requests(dhcp_client);
+ g_dhcp_client_clear_values(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_RELEASE,
+ release_pd_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean timeout_pd_request(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ if (dhcp->request_count >= REQ_MAX_RC) {
+ DBG("max request retry attempts %d", dhcp->request_count);
+ dhcp->request_count = 0;
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return FALSE;
+ }
+
+ dhcp->request_count++;
+
+ dhcp->RT = calc_delay(dhcp->RT, REQ_MAX_RT);
+ DBG("request RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_request, dhcp);
+
+ g_dhcpv6_client_set_retransmit(dhcp->dhcp_client);
+
+ g_dhcp_client_start(dhcp->dhcp_client, NULL);
+
+ return FALSE;
+}
+
+static void request_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+ uint16_t status;
+
+ DBG("");
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ status = g_dhcpv6_client_get_status(dhcp_client);
+
+ DBG("dhcpv6 pd cb msg %p status %d", dhcp, status);
+
+ if (status == G_DHCPV6_ERROR_BINDING) {
+ /* RFC 3315, 18.1.8 */
+ dhcpv6_pd_request(dhcp);
+ } else {
+ set_prefixes(dhcp_client, dhcp);
+ }
+}
+
+static int dhcpv6_pd_request(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ uint32_t T1 = 0, T2 = 0;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = dhcp->dhcp_client;
+
+ g_dhcp_client_clear_requests(dhcp_client);
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SERVERID);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_DNS_SERVERS);
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_SNTP_SERVERS);
+
+ g_dhcpv6_client_get_timeouts(dhcp_client, &T1, &T2, NULL, NULL);
+ g_dhcpv6_client_set_pd(dhcp_client, &T1, &T2, dhcp->prefixes);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client, G_DHCP_CLIENT_EVENT_REQUEST,
+ request_pd_cb, dhcp);
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static void advertise_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ DBG("dhcpv6 advertise pd msg %p", dhcp);
+
+ clear_timer(dhcp);
+
+ g_dhcpv6_client_clear_retransmit(dhcp_client);
+
+ if (g_dhcpv6_client_get_status(dhcp_client) != 0) {
+ if (dhcp->callback)
+ dhcp->callback(dhcp->network,
+ CONNMAN_DHCPV6_STATUS_FAIL, NULL);
+ return;
+ }
+
+ dhcp->RT = initial_rt(REQ_TIMEOUT);
+ DBG("request initial RT timeout %d msec", dhcp->RT);
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_pd_request, dhcp);
+
+ dhcp->request_count = 1;
+
+ dhcpv6_pd_request(dhcp);
+}
+
+static void solicitation_pd_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ /*
+ * This callback is here so that g_dhcp_client_start()
+ * will enter the proper L3 mode.
+ */
+ DBG("DHCPv6 %p solicitation msg received, ignoring it", user_data);
+}
+
+static int dhcpv6_pd_solicitation(struct connman_dhcpv6 *dhcp)
+{
+ GDHCPClient *dhcp_client;
+ int ret;
+
+ DBG("dhcp %p", dhcp);
+
+ dhcp_client = create_pd_client(dhcp, &ret);
+ if (!dhcp_client) {
+ clear_timer(dhcp);
+ return ret;
+ }
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCPV6_CLIENTID);
+
+ g_dhcpv6_client_set_pd(dhcp_client, NULL, NULL, NULL);
+
+ clear_callbacks(dhcp_client);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_ADVERTISE,
+ advertise_pd_cb, dhcp);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_SOLICITATION,
+ solicitation_pd_cb, dhcp);
+
+ dhcp->dhcp_client = dhcp_client;
+
+ return g_dhcp_client_start(dhcp_client, NULL);
+}
+
+static gboolean start_pd_solicitation(gpointer user_data)
+{
+ struct connman_dhcpv6 *dhcp = user_data;
+
+ /* Set the retransmission timeout, RFC 3315 chapter 14 */
+ dhcp->RT = initial_rt(SOL_TIMEOUT);
+
+ DBG("solicit initial RT timeout %d msec", dhcp->RT);
+
+ dhcp->timeout = g_timeout_add(dhcp->RT, timeout_solicitation, dhcp);
+
+ dhcpv6_pd_solicitation(dhcp);
+
+ return FALSE;
+}
+
+int __connman_dhcpv6_start_pd(int index, GSList *prefixes, dhcpv6_cb callback)
+{
+ struct connman_service *service;
+ struct connman_network *network;
+ struct connman_dhcpv6 *dhcp;
+
+ if (index < 0)
+ return 0;
+
+ DBG("index %d", index);
+
+ service = __connman_service_lookup_from_index(index);
+ if (!service)
+ return -EINVAL;
+
+ network = __connman_service_get_network(service);
+ if (!network)
+ return -EINVAL;
+
+ if (network_pd_table) {
+ dhcp = g_hash_table_lookup(network_pd_table, network);
+ if (dhcp && dhcp->started)
+ return -EBUSY;
+ }
+
+ dhcp = g_try_new0(struct connman_dhcpv6, 1);
+ if (!dhcp)
+ return -ENOMEM;
+
+ dhcp->network = network;
+ dhcp->callback = callback;
+ dhcp->started = true;
+
+ if (!prefixes) {
+ /*
+ * Try to load the earlier prefixes if caller did not supply
+ * any that we could use.
+ */
+ struct connman_ipconfig *ipconfig;
+ ipconfig = __connman_service_get_ip6config(service);
+
+ dhcp->prefixes = load_prefixes(ipconfig);
+ } else
+ dhcp->prefixes = prefixes;
+
+ connman_network_ref(network);
+
+ DBG("replace network %p dhcp %p", network, dhcp);
+
+ g_hash_table_replace(network_pd_table, network, dhcp);
+
+ if (!dhcp->prefixes) {
+ /*
+ * Refresh start, try to get prefixes.
+ */
+ start_pd_solicitation(dhcp);
+ } else {
+ /*
+ * We used to have prefixes, try to use them again.
+ * We need to use timeouts from confirm msg, RFC 3633, ch 12.1
+ */
+ start_pd_rebind_with_confirm(dhcp);
+ }
+
+ return 0;
+}
+
+void __connman_dhcpv6_stop_pd(int index)
+{
+ struct connman_service *service;
+ struct connman_network *network;
+
+ if (index < 0)
+ return;
+
+ DBG("index %d", index);
+
+ if (!network_pd_table)
+ return;
+
+ service = __connman_service_lookup_from_index(index);
+ if (!service)
+ return;
+
+ network = __connman_service_get_network(service);
+ if (!network)
+ return;
+
+ __connman_dhcpv6_start_pd_release(network, NULL);
+
+ if (g_hash_table_remove(network_pd_table, network))
+ connman_network_unref(network);
+}
+
+int __connman_dhcpv6_init(void)
+{
+ DBG("");
+
+ network_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, remove_network);
+
+ network_pd_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, remove_network);
+
+ return 0;
+}
+
+void __connman_dhcpv6_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(network_table);
+ network_table = NULL;
+
+ g_hash_table_destroy(network_pd_table);
+ network_pd_table = NULL;
+}
diff --git a/src/dnsproxy.c b/src/dnsproxy.c
new file mode 100644
index 0000000..0c41937
--- /dev/null
+++ b/src/dnsproxy.c
@@ -0,0 +1,3895 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <fcntl.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <gweb/gresolv.h>
+
+#include <glib.h>
+
+#include "connman.h"
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+struct domain_hdr {
+ uint16_t id;
+ uint8_t rd:1;
+ uint8_t tc:1;
+ uint8_t aa:1;
+ uint8_t opcode:4;
+ uint8_t qr:1;
+ uint8_t rcode:4;
+ uint8_t z:3;
+ uint8_t ra:1;
+ uint16_t qdcount;
+ uint16_t ancount;
+ uint16_t nscount;
+ uint16_t arcount;
+} __attribute__ ((packed));
+#elif __BYTE_ORDER == __BIG_ENDIAN
+struct domain_hdr {
+ uint16_t id;
+ uint8_t qr:1;
+ uint8_t opcode:4;
+ uint8_t aa:1;
+ uint8_t tc:1;
+ uint8_t rd:1;
+ uint8_t ra:1;
+ uint8_t z:3;
+ uint8_t rcode:4;
+ uint16_t qdcount;
+ uint16_t ancount;
+ uint16_t nscount;
+ uint16_t arcount;
+} __attribute__ ((packed));
+#else
+#error "Unknown byte order"
+#endif
+
+struct partial_reply {
+ uint16_t len;
+ uint16_t received;
+ unsigned char buf[];
+};
+
+struct server_data {
+ int index;
+ GList *domains;
+ char *server;
+ struct sockaddr *server_addr;
+ socklen_t server_addr_len;
+ int protocol;
+ GIOChannel *channel;
+ guint watch;
+ guint timeout;
+ bool enabled;
+ bool connected;
+ struct partial_reply *incoming_reply;
+};
+
+struct request_data {
+ union {
+ struct sockaddr_in6 __sin6; /* Only for the length */
+ struct sockaddr sa;
+ };
+ socklen_t sa_len;
+ int client_sk;
+ int protocol;
+ int family;
+ guint16 srcid;
+ guint16 dstid;
+ guint16 altid;
+ guint timeout;
+ guint watch;
+ guint numserv;
+ guint numresp;
+ gpointer request;
+ gsize request_len;
+ gpointer name;
+ gpointer resp;
+ gsize resplen;
+ struct listener_data *ifdata;
+ bool append_domain;
+};
+
+struct listener_data {
+ int index;
+
+ GIOChannel *udp4_listener_channel;
+ GIOChannel *tcp4_listener_channel;
+ guint udp4_listener_watch;
+ guint tcp4_listener_watch;
+
+ GIOChannel *udp6_listener_channel;
+ GIOChannel *tcp6_listener_channel;
+ guint udp6_listener_watch;
+ guint tcp6_listener_watch;
+};
+
+/*
+ * The TCP client requires some extra handling as we need to
+ * be prepared to receive also partial DNS requests.
+ */
+struct tcp_partial_client_data {
+ int family;
+ struct listener_data *ifdata;
+ GIOChannel *channel;
+ guint watch;
+ unsigned char *buf;
+ unsigned int buf_end;
+ guint timeout;
+};
+
+struct cache_data {
+ time_t inserted;
+ time_t valid_until;
+ time_t cache_until;
+ int timeout;
+ uint16_t type;
+ uint16_t answers;
+ unsigned int data_len;
+ unsigned char *data; /* contains DNS header + body */
+};
+
+struct cache_entry {
+ char *key;
+ bool want_refresh;
+ int hits;
+ struct cache_data *ipv4;
+ struct cache_data *ipv6;
+};
+
+struct domain_question {
+ uint16_t type;
+ uint16_t class;
+} __attribute__ ((packed));
+
+struct domain_rr {
+ uint16_t type;
+ uint16_t class;
+ uint32_t ttl;
+ uint16_t rdlen;
+} __attribute__ ((packed));
+
+/*
+ * Max length of the DNS TCP packet.
+ */
+#define TCP_MAX_BUF_LEN 4096
+
+/*
+ * We limit how long the cached DNS entry stays in the cache.
+ * By default the TTL (time-to-live) of the DNS response is used
+ * when setting the cache entry life time. The value is in seconds.
+ */
+#define MAX_CACHE_TTL (60 * 30)
+/*
+ * Also limit the other end, cache at least for 30 seconds.
+ */
+#define MIN_CACHE_TTL (30)
+
+/*
+ * We limit the cache size to some sane value so that cached data does
+ * not occupy too much memory. Each cached entry occupies on average
+ * about 100 bytes memory (depending on DNS name length).
+ * Example: caching www.connman.net uses 97 bytes memory.
+ * The value is the max amount of cached DNS responses (count).
+ */
+#define MAX_CACHE_SIZE 256
+
+static int cache_size;
+static GHashTable *cache;
+static int cache_refcount;
+static GSList *server_list = NULL;
+static GSList *request_list = NULL;
+static GHashTable *listener_table = NULL;
+static time_t next_refresh;
+static GHashTable *partial_tcp_req_table;
+static guint cache_timer = 0;
+
+static guint16 get_id(void)
+{
+ uint64_t rand;
+
+ __connman_util_get_random(&rand);
+
+ return rand;
+}
+
+static int protocol_offset(int protocol)
+{
+ switch (protocol) {
+ case IPPROTO_UDP:
+ return 0;
+
+ case IPPROTO_TCP:
+ return 2;
+
+ default:
+ return -EINVAL;
+ }
+
+}
+
+/*
+ * There is a power and efficiency benefit to have entries
+ * in our cache expire at the same time. To this extend,
+ * we round down the cache valid time to common boundaries.
+ */
+static time_t round_down_ttl(time_t end_time, int ttl)
+{
+ if (ttl < 15)
+ return end_time;
+
+ /* Less than 5 minutes, round to 10 second boundary */
+ if (ttl < 300) {
+ end_time = end_time / 10;
+ end_time = end_time * 10;
+ } else { /* 5 or more minutes, round to 30 seconds */
+ end_time = end_time / 30;
+ end_time = end_time * 30;
+ }
+ return end_time;
+}
+
+static struct request_data *find_request(guint16 id)
+{
+ GSList *list;
+
+ for (list = request_list; list; list = list->next) {
+ struct request_data *req = list->data;
+
+ if (req->dstid == id || req->altid == id)
+ return req;
+ }
+
+ return NULL;
+}
+
+static struct server_data *find_server(int index,
+ const char *server,
+ int protocol)
+{
+ GSList *list;
+
+ DBG("index %d server %s proto %d", index, server, protocol);
+
+ for (list = server_list; list; list = list->next) {
+ struct server_data *data = list->data;
+
+ if (index < 0 && data->index < 0 &&
+ g_str_equal(data->server, server) &&
+ data->protocol == protocol)
+ return data;
+
+ if (index < 0 ||
+ data->index < 0 || !data->server)
+ continue;
+
+ if (data->index == index &&
+ g_str_equal(data->server, server) &&
+ data->protocol == protocol)
+ return data;
+ }
+
+ return NULL;
+}
+
+/* we can keep using the same resolve's */
+static GResolv *ipv4_resolve;
+static GResolv *ipv6_resolve;
+
+static void dummy_resolve_func(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+}
+
+/*
+ * Refresh a DNS entry, but also age the hit count a bit */
+static void refresh_dns_entry(struct cache_entry *entry, char *name)
+{
+ int age = 1;
+
+ if (!ipv4_resolve) {
+ ipv4_resolve = g_resolv_new(0);
+ g_resolv_set_address_family(ipv4_resolve, AF_INET);
+ g_resolv_add_nameserver(ipv4_resolve, "127.0.0.1", 53, 0);
+ }
+
+ if (!ipv6_resolve) {
+ ipv6_resolve = g_resolv_new(0);
+ g_resolv_set_address_family(ipv6_resolve, AF_INET6);
+ g_resolv_add_nameserver(ipv6_resolve, "::1", 53, 0);
+ }
+
+ if (!entry->ipv4) {
+ DBG("Refresing A record for %s", name);
+ g_resolv_lookup_hostname(ipv4_resolve, name,
+ dummy_resolve_func, NULL);
+ age = 4;
+ }
+
+ if (!entry->ipv6) {
+ DBG("Refresing AAAA record for %s", name);
+ g_resolv_lookup_hostname(ipv6_resolve, name,
+ dummy_resolve_func, NULL);
+ age = 4;
+ }
+
+ entry->hits -= age;
+ if (entry->hits < 0)
+ entry->hits = 0;
+}
+
+static int dns_name_length(unsigned char *buf)
+{
+ if ((buf[0] & NS_CMPRSFLGS) == NS_CMPRSFLGS) /* compressed name */
+ return 2;
+ return strlen((char *)buf);
+}
+
+static void update_cached_ttl(unsigned char *buf, int len, int new_ttl)
+{
+ unsigned char *c;
+ uint16_t w;
+ int l;
+
+ /* skip the header */
+ c = buf + 12;
+ len -= 12;
+
+ /* skip the query, which is a name and 2 16 bit words */
+ l = dns_name_length(c);
+ c += l;
+ len -= l;
+ c += 4;
+ len -= 4;
+
+ /* now we get the answer records */
+
+ while (len > 0) {
+ /* first a name */
+ l = dns_name_length(c);
+ c += l;
+ len -= l;
+ if (len < 0)
+ break;
+ /* then type + class, 2 bytes each */
+ c += 4;
+ len -= 4;
+ if (len < 0)
+ break;
+
+ /* now the 4 byte TTL field */
+ c[0] = new_ttl >> 24 & 0xff;
+ c[1] = new_ttl >> 16 & 0xff;
+ c[2] = new_ttl >> 8 & 0xff;
+ c[3] = new_ttl & 0xff;
+ c += 4;
+ len -= 4;
+ if (len < 0)
+ break;
+
+ /* now the 2 byte rdlen field */
+ w = c[0] << 8 | c[1];
+ c += w + 2;
+ len -= w + 2;
+ }
+}
+
+static void send_cached_response(int sk, unsigned char *buf, int len,
+ const struct sockaddr *to, socklen_t tolen,
+ int protocol, int id, uint16_t answers, int ttl)
+{
+ struct domain_hdr *hdr;
+ unsigned char *ptr = buf;
+ int err, offset, dns_len, adj_len = len - 2;
+
+ /*
+ * The cached packet contains always the TCP offset (two bytes)
+ * so skip them for UDP.
+ */
+ switch (protocol) {
+ case IPPROTO_UDP:
+ ptr += 2;
+ len -= 2;
+ dns_len = len;
+ offset = 0;
+ break;
+ case IPPROTO_TCP:
+ offset = 2;
+ dns_len = ptr[0] * 256 + ptr[1];
+ break;
+ default:
+ return;
+ }
+
+ if (len < 12)
+ return;
+
+ hdr = (void *) (ptr + offset);
+
+ hdr->id = id;
+ hdr->qr = 1;
+ hdr->rcode = ns_r_noerror;
+ hdr->ancount = htons(answers);
+ hdr->nscount = 0;
+ hdr->arcount = 0;
+
+ /* if this is a negative reply, we are authorative */
+ if (answers == 0)
+ hdr->aa = 1;
+ else
+ update_cached_ttl((unsigned char *)hdr, adj_len, ttl);
+
+ DBG("sk %d id 0x%04x answers %d ptr %p length %d dns %d",
+ sk, hdr->id, answers, ptr, len, dns_len);
+
+ err = sendto(sk, ptr, len, MSG_NOSIGNAL, to, tolen);
+ if (err < 0) {
+ connman_error("Cannot send cached DNS response: %s",
+ strerror(errno));
+ return;
+ }
+
+ if (err != len || (dns_len != (len - 2) && protocol == IPPROTO_TCP) ||
+ (dns_len != len && protocol == IPPROTO_UDP))
+ DBG("Packet length mismatch, sent %d wanted %d dns %d",
+ err, len, dns_len);
+}
+
+static void send_response(int sk, unsigned char *buf, int len,
+ const struct sockaddr *to, socklen_t tolen,
+ int protocol)
+{
+ struct domain_hdr *hdr;
+ int err, offset = protocol_offset(protocol);
+
+ DBG("sk %d", sk);
+
+ if (offset < 0)
+ return;
+
+ if (len < 12)
+ return;
+
+ hdr = (void *) (buf + offset);
+
+ DBG("id 0x%04x qr %d opcode %d", hdr->id, hdr->qr, hdr->opcode);
+
+ hdr->qr = 1;
+ hdr->rcode = ns_r_servfail;
+
+ hdr->ancount = 0;
+ hdr->nscount = 0;
+ hdr->arcount = 0;
+
+ err = sendto(sk, buf, len, MSG_NOSIGNAL, to, tolen);
+ if (err < 0) {
+ connman_error("Failed to send DNS response to %d: %s",
+ sk, strerror(errno));
+ return;
+ }
+}
+
+static int get_req_udp_socket(struct request_data *req)
+{
+ GIOChannel *channel;
+
+ if (req->family == AF_INET)
+ channel = req->ifdata->udp4_listener_channel;
+ else
+ channel = req->ifdata->udp6_listener_channel;
+
+ if (!channel)
+ return -1;
+
+ return g_io_channel_unix_get_fd(channel);
+}
+
+static void destroy_request_data(struct request_data *req)
+{
+ if (req->timeout > 0)
+ g_source_remove(req->timeout);
+
+ g_free(req->resp);
+ g_free(req->request);
+ g_free(req->name);
+ g_free(req);
+}
+
+static gboolean request_timeout(gpointer user_data)
+{
+ struct request_data *req = user_data;
+ struct sockaddr *sa;
+ int sk;
+
+ if (!req)
+ return FALSE;
+
+ DBG("id 0x%04x", req->srcid);
+
+ request_list = g_slist_remove(request_list, req);
+
+ if (req->protocol == IPPROTO_UDP) {
+ sk = get_req_udp_socket(req);
+ sa = &req->sa;
+ } else if (req->protocol == IPPROTO_TCP) {
+ sk = req->client_sk;
+ sa = NULL;
+ } else
+ goto out;
+
+ if (req->resplen > 0 && req->resp) {
+ /*
+ * Here we have received at least one reply (probably telling
+ * "not found" result), so send that back to client instead
+ * of more fatal server failed error.
+ */
+ connman_error("DNS response received but name was not resolved");
+ if (sk >= 0)
+ sendto(sk, req->resp, req->resplen, MSG_NOSIGNAL,
+ sa, req->sa_len);
+
+ } else if (req->request) {
+ /*
+ * There was not reply from server at all.
+ */
+ struct domain_hdr *hdr;
+
+ connman_error("DNS query timeout %d", req->timeout);
+ hdr = (void *)(req->request + protocol_offset(req->protocol));
+ hdr->id = req->srcid;
+
+ if (sk >= 0)
+ send_response(sk, req->request, req->request_len,
+ sa, req->sa_len, req->protocol);
+ }
+
+ /*
+ * We cannot leave TCP client hanging so just kick it out
+ * if we get a request timeout from server.
+ */
+ if (req->protocol == IPPROTO_TCP) {
+ DBG("client %d removed", req->client_sk);
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(req->client_sk));
+ }
+
+out:
+ req->timeout = 0;
+ destroy_request_data(req);
+
+ return FALSE;
+}
+
+static int append_query(unsigned char *buf, unsigned int size,
+ const char *query, const char *domain)
+{
+ unsigned char *ptr = buf;
+ int len;
+
+ DBG("query %s domain %s", query, domain);
+
+ while (query) {
+ const char *tmp;
+
+ tmp = strchr(query, '.');
+ if (!tmp) {
+ len = strlen(query);
+ if (len == 0)
+ break;
+ *ptr = len;
+ memcpy(ptr + 1, query, len);
+ ptr += len + 1;
+ break;
+ }
+
+ *ptr = tmp - query;
+ memcpy(ptr + 1, query, tmp - query);
+ ptr += tmp - query + 1;
+
+ query = tmp + 1;
+ }
+
+ while (domain) {
+ const char *tmp;
+
+ tmp = strchr(domain, '.');
+ if (!tmp) {
+ len = strlen(domain);
+ if (len == 0)
+ break;
+ *ptr = len;
+ memcpy(ptr + 1, domain, len);
+ ptr += len + 1;
+ break;
+ }
+
+ *ptr = tmp - domain;
+ memcpy(ptr + 1, domain, tmp - domain);
+ ptr += tmp - domain + 1;
+
+ domain = tmp + 1;
+ }
+
+ *ptr++ = 0x00;
+
+ return ptr - buf;
+}
+
+static bool cache_check_is_valid(struct cache_data *data,
+ time_t current_time)
+{
+ if (!data)
+ return false;
+
+ if (data->cache_until < current_time)
+ return false;
+
+ return true;
+}
+
+/*
+ * remove stale cached entries so that they can be refreshed
+ */
+static void cache_enforce_validity(struct cache_entry *entry)
+{
+ time_t current_time = time(NULL);
+
+ if (!cache_check_is_valid(entry->ipv4, current_time)
+ && entry->ipv4) {
+ DBG("cache timeout \"%s\" type A", entry->key);
+ g_free(entry->ipv4->data);
+ g_free(entry->ipv4);
+ entry->ipv4 = NULL;
+
+ }
+
+ if (!cache_check_is_valid(entry->ipv6, current_time)
+ && entry->ipv6) {
+ DBG("cache timeout \"%s\" type AAAA", entry->key);
+ g_free(entry->ipv6->data);
+ g_free(entry->ipv6);
+ entry->ipv6 = NULL;
+ }
+}
+
+static uint16_t cache_check_validity(char *question, uint16_t type,
+ struct cache_entry *entry)
+{
+ time_t current_time = time(NULL);
+ bool want_refresh = false;
+
+ /*
+ * if we have a popular entry, we want a refresh instead of
+ * total destruction of the entry.
+ */
+ if (entry->hits > 2)
+ want_refresh = true;
+
+ cache_enforce_validity(entry);
+
+ switch (type) {
+ case 1: /* IPv4 */
+ if (!cache_check_is_valid(entry->ipv4, current_time)) {
+ DBG("cache %s \"%s\" type A", entry->ipv4 ?
+ "timeout" : "entry missing", question);
+
+ if (want_refresh)
+ entry->want_refresh = true;
+
+ /*
+ * We do not remove cache entry if there is still
+ * valid IPv6 entry found in the cache.
+ */
+ if (!cache_check_is_valid(entry->ipv6, current_time) && !want_refresh) {
+ g_hash_table_remove(cache, question);
+ type = 0;
+ }
+ }
+ break;
+
+ case 28: /* IPv6 */
+ if (!cache_check_is_valid(entry->ipv6, current_time)) {
+ DBG("cache %s \"%s\" type AAAA", entry->ipv6 ?
+ "timeout" : "entry missing", question);
+
+ if (want_refresh)
+ entry->want_refresh = true;
+
+ if (!cache_check_is_valid(entry->ipv4, current_time) && !want_refresh) {
+ g_hash_table_remove(cache, question);
+ type = 0;
+ }
+ }
+ break;
+ }
+
+ return type;
+}
+
+static void cache_element_destroy(gpointer value)
+{
+ struct cache_entry *entry = value;
+
+ if (!entry)
+ return;
+
+ if (entry->ipv4) {
+ g_free(entry->ipv4->data);
+ g_free(entry->ipv4);
+ }
+
+ if (entry->ipv6) {
+ g_free(entry->ipv6->data);
+ g_free(entry->ipv6);
+ }
+
+ g_free(entry->key);
+ g_free(entry);
+
+ if (--cache_size < 0)
+ cache_size = 0;
+}
+
+static gboolean try_remove_cache(gpointer user_data)
+{
+ cache_timer = 0;
+
+ if (__sync_fetch_and_sub(&cache_refcount, 1) == 1) {
+ DBG("No cache users, removing it.");
+
+ g_hash_table_destroy(cache);
+ cache = NULL;
+ }
+
+ return FALSE;
+}
+
+static void create_cache(void)
+{
+ if (__sync_fetch_and_add(&cache_refcount, 1) == 0)
+ cache = g_hash_table_new_full(g_str_hash,
+ g_str_equal,
+ NULL,
+ cache_element_destroy);
+}
+
+static struct cache_entry *cache_check(gpointer request, int *qtype, int proto)
+{
+ char *question;
+ struct cache_entry *entry;
+ struct domain_question *q;
+ uint16_t type;
+ int offset, proto_offset;
+
+ if (!request)
+ return NULL;
+
+ proto_offset = protocol_offset(proto);
+ if (proto_offset < 0)
+ return NULL;
+
+ question = request + proto_offset + 12;
+
+ offset = strlen(question) + 1;
+ q = (void *) (question + offset);
+ type = ntohs(q->type);
+
+ /* We only cache either A (1) or AAAA (28) requests */
+ if (type != 1 && type != 28)
+ return NULL;
+
+ if (!cache) {
+ create_cache();
+ return NULL;
+ }
+
+ entry = g_hash_table_lookup(cache, question);
+ if (!entry)
+ return NULL;
+
+ type = cache_check_validity(question, type, entry);
+ if (type == 0)
+ return NULL;
+
+ *qtype = type;
+ return entry;
+}
+
+/*
+ * Get a label/name from DNS resource record. The function decompresses the
+ * label if necessary. The function does not convert the name to presentation
+ * form. This means that the result string will contain label lengths instead
+ * of dots between labels. We intentionally do not want to convert to dotted
+ * format so that we can cache the wire format string directly.
+ */
+static int get_name(int counter,
+ unsigned char *pkt, unsigned char *start, unsigned char *max,
+ unsigned char *output, int output_max, int *output_len,
+ unsigned char **end, char *name, int *name_len)
+{
+ unsigned char *p;
+
+ /* Limit recursion to 10 (this means up to 10 labels in domain name) */
+ if (counter > 10)
+ return -EINVAL;
+
+ p = start;
+ while (*p) {
+ if ((*p & NS_CMPRSFLGS) == NS_CMPRSFLGS) {
+ uint16_t offset = (*p & 0x3F) * 256 + *(p + 1);
+
+ if (offset >= max - pkt)
+ return -ENOBUFS;
+
+ if (!*end)
+ *end = p + 2;
+
+ return get_name(counter + 1, pkt, pkt + offset, max,
+ output, output_max, output_len, end,
+ name, name_len);
+ } else {
+ unsigned label_len = *p;
+
+ if (pkt + label_len > max)
+ return -ENOBUFS;
+
+ if (*output_len > output_max)
+ return -ENOBUFS;
+
+ /*
+ * We need the original name in order to check
+ * if this answer is the correct one.
+ */
+ name[(*name_len)++] = label_len;
+ memcpy(name + *name_len, p + 1, label_len + 1);
+ *name_len += label_len;
+
+ /* We compress the result */
+ output[0] = NS_CMPRSFLGS;
+ output[1] = 0x0C;
+ *output_len = 2;
+
+ p += label_len + 1;
+
+ if (!*end)
+ *end = p;
+
+ if (p >= max)
+ return -ENOBUFS;
+ }
+ }
+
+ return 0;
+}
+
+static int parse_rr(unsigned char *buf, unsigned char *start,
+ unsigned char *max,
+ unsigned char *response, unsigned int *response_size,
+ uint16_t *type, uint16_t *class, int *ttl, int *rdlen,
+ unsigned char **end,
+ char *name)
+{
+ struct domain_rr *rr;
+ int err, offset;
+ int name_len = 0, output_len = 0, max_rsp = *response_size;
+
+ err = get_name(0, buf, start, max, response, max_rsp,
+ &output_len, end, name, &name_len);
+ if (err < 0)
+ return err;
+
+ offset = output_len;
+
+ if ((unsigned int) offset > *response_size)
+ return -ENOBUFS;
+
+ rr = (void *) (*end);
+
+ if (!rr)
+ return -EINVAL;
+
+ *type = ntohs(rr->type);
+ *class = ntohs(rr->class);
+ *ttl = ntohl(rr->ttl);
+ *rdlen = ntohs(rr->rdlen);
+
+ if (*ttl < 0)
+ return -EINVAL;
+
+ memcpy(response + offset, *end, sizeof(struct domain_rr));
+
+ offset += sizeof(struct domain_rr);
+ *end += sizeof(struct domain_rr);
+
+ if ((unsigned int) (offset + *rdlen) > *response_size)
+ return -ENOBUFS;
+
+ memcpy(response + offset, *end, *rdlen);
+
+ *end += *rdlen;
+
+ *response_size = offset + *rdlen;
+
+ return 0;
+}
+
+static bool check_alias(GSList *aliases, char *name)
+{
+ GSList *list;
+
+ if (aliases) {
+ for (list = aliases; list; list = list->next) {
+ int len = strlen((char *)list->data);
+ if (strncmp((char *)list->data, name, len) == 0)
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static int parse_response(unsigned char *buf, int buflen,
+ char *question, int qlen,
+ uint16_t *type, uint16_t *class, int *ttl,
+ unsigned char *response, unsigned int *response_len,
+ uint16_t *answers)
+{
+ struct domain_hdr *hdr = (void *) buf;
+ struct domain_question *q;
+ unsigned char *ptr;
+ uint16_t qdcount = ntohs(hdr->qdcount);
+ uint16_t ancount = ntohs(hdr->ancount);
+ int err, i;
+ uint16_t qtype, qclass;
+ unsigned char *next = NULL;
+ unsigned int maxlen = *response_len;
+ GSList *aliases = NULL, *list;
+ char name[NS_MAXDNAME + 1];
+
+ if (buflen < 12)
+ return -EINVAL;
+
+ DBG("qr %d qdcount %d", hdr->qr, qdcount);
+
+ /* We currently only cache responses where question count is 1 */
+ if (hdr->qr != 1 || qdcount != 1)
+ return -EINVAL;
+
+ ptr = buf + sizeof(struct domain_hdr);
+
+ strncpy(question, (char *) ptr, qlen);
+ qlen = strlen(question);
+ ptr += qlen + 1; /* skip \0 */
+
+ q = (void *) ptr;
+ qtype = ntohs(q->type);
+
+ /* We cache only A and AAAA records */
+ if (qtype != 1 && qtype != 28)
+ return -ENOMSG;
+
+ qclass = ntohs(q->class);
+
+ ptr += 2 + 2; /* ptr points now to answers */
+
+ err = -ENOMSG;
+ *response_len = 0;
+ *answers = 0;
+
+ memset(name, 0, sizeof(name));
+
+ /*
+ * We have a bunch of answers (like A, AAAA, CNAME etc) to
+ * A or AAAA question. We traverse the answers and parse the
+ * resource records. Only A and AAAA records are cached, all
+ * the other records in answers are skipped.
+ */
+ for (i = 0; i < ancount; i++) {
+ /*
+ * Get one address at a time to this buffer.
+ * The max size of the answer is
+ * 2 (pointer) + 2 (type) + 2 (class) +
+ * 4 (ttl) + 2 (rdlen) + addr (16 or 4) = 28
+ * for A or AAAA record.
+ * For CNAME the size can be bigger.
+ */
+ unsigned char rsp[NS_MAXCDNAME];
+ unsigned int rsp_len = sizeof(rsp) - 1;
+ int ret, rdlen;
+
+ memset(rsp, 0, sizeof(rsp));
+
+ ret = parse_rr(buf, ptr, buf + buflen, rsp, &rsp_len,
+ type, class, ttl, &rdlen, &next, name);
+ if (ret != 0) {
+ err = ret;
+ goto out;
+ }
+
+ /*
+ * Now rsp contains compressed or uncompressed resource
+ * record. Next we check if this record answers the question.
+ * The name var contains the uncompressed label.
+ * One tricky bit is the CNAME records as they alias
+ * the name we might be interested in.
+ */
+
+ /*
+ * Go to next answer if the class is not the one we are
+ * looking for.
+ */
+ if (*class != qclass) {
+ ptr = next;
+ next = NULL;
+ continue;
+ }
+
+ /*
+ * Try to resolve aliases also, type is CNAME(5).
+ * This is important as otherwise the aliased names would not
+ * be cached at all as the cache would not contain the aliased
+ * question.
+ *
+ * If any CNAME is found in DNS packet, then we cache the alias
+ * IP address instead of the question (as the server
+ * said that question has only an alias).
+ * This means in practice that if e.g., ipv6.google.com is
+ * queried, DNS server returns CNAME of that name which is
+ * ipv6.l.google.com. We then cache the address of the CNAME
+ * but return the question name to client. So the alias
+ * status of the name is not saved in cache and thus not
+ * returned to the client. We do not return DNS packets from
+ * cache to client saying that ipv6.google.com is an alias to
+ * ipv6.l.google.com but we return instead a DNS packet that
+ * says ipv6.google.com has address xxx which is in fact the
+ * address of ipv6.l.google.com. For caching purposes this
+ * should not cause any issues.
+ */
+ if (*type == 5 && strncmp(question, name, qlen) == 0) {
+ /*
+ * So now the alias answered the question. This is
+ * not very useful from caching point of view as
+ * the following A or AAAA records will not match the
+ * question. We need to find the real A/AAAA record
+ * of the alias and cache that.
+ */
+ unsigned char *end = NULL;
+ int name_len = 0, output_len = 0;
+
+ memset(rsp, 0, sizeof(rsp));
+ rsp_len = sizeof(rsp) - 1;
+
+ /*
+ * Alias is in rdata part of the message,
+ * and next-rdlen points to it. So we need to get
+ * the real name of the alias.
+ */
+ ret = get_name(0, buf, next - rdlen, buf + buflen,
+ rsp, rsp_len, &output_len, &end,
+ name, &name_len);
+ if (ret != 0) {
+ /* just ignore the error at this point */
+ ptr = next;
+ next = NULL;
+ continue;
+ }
+
+ /*
+ * We should now have the alias of the entry we might
+ * want to cache. Just remember it for a while.
+ * We check the alias list when we have parsed the
+ * A or AAAA record.
+ */
+ aliases = g_slist_prepend(aliases, g_strdup(name));
+
+ ptr = next;
+ next = NULL;
+ continue;
+ }
+
+ if (*type == qtype) {
+ /*
+ * We found correct type (A or AAAA)
+ */
+ if (check_alias(aliases, name) ||
+ (!aliases && strncmp(question, name,
+ qlen) == 0)) {
+ /*
+ * We found an alias or the name of the rr
+ * matches the question. If so, we append
+ * the compressed label to the cache.
+ * The end result is a response buffer that
+ * will contain one or more cached and
+ * compressed resource records.
+ */
+ if (*response_len + rsp_len > maxlen) {
+ err = -ENOBUFS;
+ goto out;
+ }
+ memcpy(response + *response_len, rsp, rsp_len);
+ *response_len += rsp_len;
+ (*answers)++;
+ err = 0;
+ }
+ }
+
+ ptr = next;
+ next = NULL;
+ }
+
+out:
+ for (list = aliases; list; list = list->next)
+ g_free(list->data);
+ g_slist_free(aliases);
+
+ return err;
+}
+
+struct cache_timeout {
+ time_t current_time;
+ int max_timeout;
+ int try_harder;
+};
+
+static gboolean cache_check_entry(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct cache_timeout *data = user_data;
+ struct cache_entry *entry = value;
+ int max_timeout;
+
+ /* Scale the number of hits by half as part of cache aging */
+
+ entry->hits /= 2;
+
+ /*
+ * If either IPv4 or IPv6 cached entry has expired, we
+ * remove both from the cache.
+ */
+
+ if (entry->ipv4 && entry->ipv4->timeout > 0) {
+ max_timeout = entry->ipv4->cache_until;
+ if (max_timeout > data->max_timeout)
+ data->max_timeout = max_timeout;
+
+ if (entry->ipv4->cache_until < data->current_time)
+ return TRUE;
+ }
+
+ if (entry->ipv6 && entry->ipv6->timeout > 0) {
+ max_timeout = entry->ipv6->cache_until;
+ if (max_timeout > data->max_timeout)
+ data->max_timeout = max_timeout;
+
+ if (entry->ipv6->cache_until < data->current_time)
+ return TRUE;
+ }
+
+ /*
+ * if we're asked to try harder, also remove entries that have
+ * few hits
+ */
+ if (data->try_harder && entry->hits < 4)
+ return TRUE;
+
+ return FALSE;
+}
+
+static void cache_cleanup(void)
+{
+ static int max_timeout;
+ struct cache_timeout data;
+ int count = 0;
+
+ data.current_time = time(NULL);
+ data.max_timeout = 0;
+ data.try_harder = 0;
+
+ /*
+ * In the first pass, we only remove entries that have timed out.
+ * We use a cache of the first time to expire to do this only
+ * when it makes sense.
+ */
+ if (max_timeout <= data.current_time) {
+ count = g_hash_table_foreach_remove(cache, cache_check_entry,
+ &data);
+ }
+ DBG("removed %d in the first pass", count);
+
+ /*
+ * In the second pass, if the first pass turned up blank,
+ * we also expire entries with a low hit count,
+ * while aging the hit count at the same time.
+ */
+ data.try_harder = 1;
+ if (count == 0)
+ count = g_hash_table_foreach_remove(cache, cache_check_entry,
+ &data);
+
+ if (count == 0)
+ /*
+ * If we could not remove anything, then remember
+ * what is the max timeout and do nothing if we
+ * have not yet reached it. This will prevent
+ * constant traversal of the cache if it is full.
+ */
+ max_timeout = data.max_timeout;
+ else
+ max_timeout = 0;
+}
+
+static gboolean cache_invalidate_entry(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct cache_entry *entry = value;
+
+ /* first, delete any expired elements */
+ cache_enforce_validity(entry);
+
+ /* if anything is not expired, mark the entry for refresh */
+ if (entry->hits > 0 && (entry->ipv4 || entry->ipv6))
+ entry->want_refresh = true;
+
+ /* delete the cached data */
+ if (entry->ipv4) {
+ g_free(entry->ipv4->data);
+ g_free(entry->ipv4);
+ entry->ipv4 = NULL;
+ }
+
+ if (entry->ipv6) {
+ g_free(entry->ipv6->data);
+ g_free(entry->ipv6);
+ entry->ipv6 = NULL;
+ }
+
+ /* keep the entry if we want it refreshed, delete it otherwise */
+ if (entry->want_refresh)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+/*
+ * cache_invalidate is called from places where the DNS landscape
+ * has changed, say because connections are added or we entered a VPN.
+ * The logic is to wipe all cache data, but mark all non-expired
+ * parts of the cache for refresh rather than deleting the whole cache.
+ */
+static void cache_invalidate(void)
+{
+ DBG("Invalidating the DNS cache %p", cache);
+
+ if (!cache)
+ return;
+
+ g_hash_table_foreach_remove(cache, cache_invalidate_entry, NULL);
+}
+
+static void cache_refresh_entry(struct cache_entry *entry)
+{
+
+ cache_enforce_validity(entry);
+
+ if (entry->hits > 2 && !entry->ipv4)
+ entry->want_refresh = true;
+ if (entry->hits > 2 && !entry->ipv6)
+ entry->want_refresh = true;
+
+ if (entry->want_refresh) {
+ char *c;
+ char dns_name[NS_MAXDNAME + 1];
+ entry->want_refresh = false;
+
+ /* turn a DNS name into a hostname with dots */
+ strncpy(dns_name, entry->key, NS_MAXDNAME);
+ c = dns_name;
+ while (c && *c) {
+ int jump;
+ jump = *c;
+ *c = '.';
+ c += jump + 1;
+ }
+ DBG("Refreshing %s\n", dns_name);
+ /* then refresh the hostname */
+ refresh_dns_entry(entry, &dns_name[1]);
+ }
+}
+
+static void cache_refresh_iterator(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct cache_entry *entry = value;
+
+ cache_refresh_entry(entry);
+}
+
+static void cache_refresh(void)
+{
+ if (!cache)
+ return;
+
+ g_hash_table_foreach(cache, cache_refresh_iterator, NULL);
+}
+
+static int reply_query_type(unsigned char *msg, int len)
+{
+ unsigned char *c;
+ int l;
+ int type;
+
+ /* skip the header */
+ c = msg + sizeof(struct domain_hdr);
+ len -= sizeof(struct domain_hdr);
+
+ if (len < 0)
+ return 0;
+
+ /* now the query, which is a name and 2 16 bit words */
+ l = dns_name_length(c) + 1;
+ c += l;
+ type = c[0] << 8 | c[1];
+
+ return type;
+}
+
+static int cache_update(struct server_data *srv, unsigned char *msg,
+ unsigned int msg_len)
+{
+ int offset = protocol_offset(srv->protocol);
+ int err, qlen, ttl = 0;
+ uint16_t answers = 0, type = 0, class = 0;
+ struct domain_hdr *hdr = (void *)(msg + offset);
+ struct domain_question *q;
+ struct cache_entry *entry;
+ struct cache_data *data;
+ char question[NS_MAXDNAME + 1];
+ unsigned char response[NS_MAXDNAME + 1];
+ unsigned char *ptr;
+ unsigned int rsplen;
+ bool new_entry = true;
+ time_t current_time;
+
+ if (cache_size >= MAX_CACHE_SIZE) {
+ cache_cleanup();
+ if (cache_size >= MAX_CACHE_SIZE)
+ return 0;
+ }
+
+ current_time = time(NULL);
+
+ /* don't do a cache refresh more than twice a minute */
+ if (next_refresh < current_time) {
+ cache_refresh();
+ next_refresh = current_time + 30;
+ }
+
+ if (offset < 0)
+ return 0;
+
+ DBG("offset %d hdr %p msg %p rcode %d", offset, hdr, msg, hdr->rcode);
+
+ /* Continue only if response code is 0 (=ok) */
+ if (hdr->rcode != ns_r_noerror)
+ return 0;
+
+ if (!cache)
+ create_cache();
+
+ rsplen = sizeof(response) - 1;
+ question[sizeof(question) - 1] = '\0';
+
+ err = parse_response(msg + offset, msg_len - offset,
+ question, sizeof(question) - 1,
+ &type, &class, &ttl,
+ response, &rsplen, &answers);
+
+ /*
+ * special case: if we do a ipv6 lookup and get no result
+ * for a record that's already in our ipv4 cache.. we want
+ * to cache the negative response.
+ */
+ if ((err == -ENOMSG || err == -ENOBUFS) &&
+ reply_query_type(msg + offset,
+ msg_len - offset) == 28) {
+ entry = g_hash_table_lookup(cache, question);
+ if (entry && entry->ipv4 && !entry->ipv6) {
+ int cache_offset = 0;
+
+ data = g_try_new(struct cache_data, 1);
+ if (!data)
+ return -ENOMEM;
+ data->inserted = entry->ipv4->inserted;
+ data->type = type;
+ data->answers = ntohs(hdr->ancount);
+ data->timeout = entry->ipv4->timeout;
+ if (srv->protocol == IPPROTO_UDP)
+ cache_offset = 2;
+ data->data_len = msg_len + cache_offset;
+ data->data = ptr = g_malloc(data->data_len);
+ ptr[0] = (data->data_len - 2) / 256;
+ ptr[1] = (data->data_len - 2) - ptr[0] * 256;
+ if (srv->protocol == IPPROTO_UDP)
+ ptr += 2;
+ data->valid_until = entry->ipv4->valid_until;
+ data->cache_until = entry->ipv4->cache_until;
+ memcpy(ptr, msg, msg_len);
+ entry->ipv6 = data;
+ /*
+ * we will get a "hit" when we serve the response
+ * out of the cache
+ */
+ entry->hits--;
+ if (entry->hits < 0)
+ entry->hits = 0;
+ return 0;
+ }
+ }
+
+ if (err < 0 || ttl == 0)
+ return 0;
+
+ qlen = strlen(question);
+
+ /*
+ * If the cache contains already data, check if the
+ * type of the cached data is the same and do not add
+ * to cache if data is already there.
+ * This is needed so that we can cache both A and AAAA
+ * records for the same name.
+ */
+ entry = g_hash_table_lookup(cache, question);
+ if (!entry) {
+ entry = g_try_new(struct cache_entry, 1);
+ if (!entry)
+ return -ENOMEM;
+
+ data = g_try_new(struct cache_data, 1);
+ if (!data) {
+ g_free(entry);
+ return -ENOMEM;
+ }
+
+ entry->key = g_strdup(question);
+ entry->ipv4 = entry->ipv6 = NULL;
+ entry->want_refresh = false;
+ entry->hits = 0;
+
+ if (type == 1)
+ entry->ipv4 = data;
+ else
+ entry->ipv6 = data;
+ } else {
+ if (type == 1 && entry->ipv4)
+ return 0;
+
+ if (type == 28 && entry->ipv6)
+ return 0;
+
+ data = g_try_new(struct cache_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ if (type == 1)
+ entry->ipv4 = data;
+ else
+ entry->ipv6 = data;
+
+ /*
+ * compensate for the hit we'll get for serving
+ * the response out of the cache
+ */
+ entry->hits--;
+ if (entry->hits < 0)
+ entry->hits = 0;
+
+ new_entry = false;
+ }
+
+ if (ttl < MIN_CACHE_TTL)
+ ttl = MIN_CACHE_TTL;
+
+ data->inserted = current_time;
+ data->type = type;
+ data->answers = answers;
+ data->timeout = ttl;
+ /*
+ * The "2" in start of the length is the TCP offset. We allocate it
+ * here even for UDP packet because it simplifies the sending
+ * of cached packet.
+ */
+ data->data_len = 2 + 12 + qlen + 1 + 2 + 2 + rsplen;
+ data->data = ptr = g_malloc(data->data_len);
+ data->valid_until = current_time + ttl;
+
+ /*
+ * Restrict the cached DNS record TTL to some sane value
+ * in order to prevent data staying in the cache too long.
+ */
+ if (ttl > MAX_CACHE_TTL)
+ ttl = MAX_CACHE_TTL;
+
+ data->cache_until = round_down_ttl(current_time + ttl, ttl);
+
+ if (!data->data) {
+ g_free(entry->key);
+ g_free(data);
+ g_free(entry);
+ return -ENOMEM;
+ }
+
+ /*
+ * We cache the two extra bytes at the start of the message
+ * in a TCP packet. When sending UDP packet, we skip the first
+ * two bytes. This way we do not need to know the format
+ * (UDP/TCP) of the cached message.
+ */
+ if (srv->protocol == IPPROTO_UDP)
+ memcpy(ptr + 2, msg, offset + 12);
+ else
+ memcpy(ptr, msg, offset + 12);
+
+ ptr[0] = (data->data_len - 2) / 256;
+ ptr[1] = (data->data_len - 2) - ptr[0] * 256;
+ if (srv->protocol == IPPROTO_UDP)
+ ptr += 2;
+
+ memcpy(ptr + offset + 12, question, qlen + 1); /* copy also the \0 */
+
+ q = (void *) (ptr + offset + 12 + qlen + 1);
+ q->type = htons(type);
+ q->class = htons(class);
+ memcpy(ptr + offset + 12 + qlen + 1 + sizeof(struct domain_question),
+ response, rsplen);
+
+ if (new_entry) {
+ g_hash_table_replace(cache, entry->key, entry);
+ cache_size++;
+ }
+
+ DBG("cache %d %squestion \"%s\" type %d ttl %d size %zd packet %u "
+ "dns len %u",
+ cache_size, new_entry ? "new " : "old ",
+ question, type, ttl,
+ sizeof(*entry) + sizeof(*data) + data->data_len + qlen,
+ data->data_len,
+ srv->protocol == IPPROTO_TCP ?
+ (unsigned int)(data->data[0] * 256 + data->data[1]) :
+ data->data_len);
+
+ return 0;
+}
+
+static int ns_resolv(struct server_data *server, struct request_data *req,
+ gpointer request, gpointer name)
+{
+ GList *list;
+ int sk, err, type = 0;
+ char *dot, *lookup = (char *) name;
+ struct cache_entry *entry;
+
+ entry = cache_check(request, &type, req->protocol);
+ if (entry) {
+ int ttl_left = 0;
+ struct cache_data *data;
+
+ DBG("cache hit %s type %s", lookup, type == 1 ? "A" : "AAAA");
+ if (type == 1)
+ data = entry->ipv4;
+ else
+ data = entry->ipv6;
+
+ if (data) {
+ ttl_left = data->valid_until - time(NULL);
+ entry->hits++;
+ }
+
+ if (data && req->protocol == IPPROTO_TCP) {
+ send_cached_response(req->client_sk, data->data,
+ data->data_len, NULL, 0, IPPROTO_TCP,
+ req->srcid, data->answers, ttl_left);
+ return 1;
+ }
+
+ if (data && req->protocol == IPPROTO_UDP) {
+ int udp_sk = get_req_udp_socket(req);
+
+ if (udp_sk < 0)
+ return -EIO;
+
+ send_cached_response(udp_sk, data->data,
+ data->data_len, &req->sa, req->sa_len,
+ IPPROTO_UDP, req->srcid, data->answers,
+ ttl_left);
+ return 1;
+ }
+ }
+
+ sk = g_io_channel_unix_get_fd(server->channel);
+
+ err = sendto(sk, request, req->request_len, MSG_NOSIGNAL,
+ server->server_addr, server->server_addr_len);
+ if (err < 0) {
+ DBG("Cannot send message to server %s sock %d "
+ "protocol %d (%s/%d)",
+ server->server, sk, server->protocol,
+ strerror(errno), errno);
+ return -EIO;
+ }
+
+ req->numserv++;
+
+ /* If we have more than one dot, we don't add domains */
+ dot = strchr(lookup, '.');
+ if (dot && dot != lookup + strlen(lookup) - 1)
+ return 0;
+
+ if (server->domains && server->domains->data)
+ req->append_domain = true;
+
+ for (list = server->domains; list; list = list->next) {
+ char *domain;
+ unsigned char alt[1024];
+ struct domain_hdr *hdr = (void *) &alt;
+ int altlen, domlen, offset;
+
+ domain = list->data;
+
+ if (!domain)
+ continue;
+
+ offset = protocol_offset(server->protocol);
+ if (offset < 0)
+ return offset;
+
+ domlen = strlen(domain) + 1;
+ if (domlen < 5)
+ return -EINVAL;
+
+ alt[offset] = req->altid & 0xff;
+ alt[offset + 1] = req->altid >> 8;
+
+ memcpy(alt + offset + 2, request + offset + 2, 10);
+ hdr->qdcount = htons(1);
+
+ altlen = append_query(alt + offset + 12, sizeof(alt) - 12,
+ name, domain);
+ if (altlen < 0)
+ return -EINVAL;
+
+ altlen += 12;
+
+ memcpy(alt + offset + altlen,
+ request + offset + altlen - domlen,
+ req->request_len - altlen - offset + domlen);
+
+ if (server->protocol == IPPROTO_TCP) {
+ int req_len = req->request_len + domlen - 2;
+
+ alt[0] = (req_len >> 8) & 0xff;
+ alt[1] = req_len & 0xff;
+ }
+
+ DBG("req %p dstid 0x%04x altid 0x%04x", req, req->dstid,
+ req->altid);
+
+ err = send(sk, alt, req->request_len + domlen, MSG_NOSIGNAL);
+ if (err < 0)
+ return -EIO;
+
+ req->numserv++;
+ }
+
+ return 0;
+}
+
+static char *convert_label(char *start, char *end, char *ptr, char *uptr,
+ int remaining_len, int *used_comp, int *used_uncomp)
+{
+ int pos, comp_pos;
+ char name[NS_MAXLABEL];
+
+ pos = dn_expand((u_char *)start, (u_char *)end, (u_char *)ptr,
+ name, NS_MAXLABEL);
+ if (pos < 0) {
+ DBG("uncompress error [%d/%s]", errno, strerror(errno));
+ goto out;
+ }
+
+ /*
+ * We need to compress back the name so that we get back to internal
+ * label presentation.
+ */
+ comp_pos = dn_comp(name, (u_char *)uptr, remaining_len, NULL, NULL);
+ if (comp_pos < 0) {
+ DBG("compress error [%d/%s]", errno, strerror(errno));
+ goto out;
+ }
+
+ *used_comp = pos;
+ *used_uncomp = comp_pos;
+
+ return ptr;
+
+out:
+ return NULL;
+}
+
+static char *uncompress(int16_t field_count, char *start, char *end,
+ char *ptr, char *uncompressed, int uncomp_len,
+ char **uncompressed_ptr)
+{
+ char *uptr = *uncompressed_ptr; /* position in result buffer */
+
+ DBG("count %d ptr %p end %p uptr %p", field_count, ptr, end, uptr);
+
+ while (field_count-- > 0 && ptr < end) {
+ int dlen; /* data field length */
+ int ulen; /* uncompress length */
+ int pos; /* position in compressed string */
+ char name[NS_MAXLABEL]; /* tmp label */
+ uint16_t dns_type, dns_class;
+ int comp_pos;
+
+ if (!convert_label(start, end, ptr, name, NS_MAXLABEL,
+ &pos, &comp_pos))
+ goto out;
+
+ /*
+ * Copy the uncompressed resource record, type, class and \0 to
+ * tmp buffer.
+ */
+
+ ulen = strlen(name);
+ strncpy(uptr, name, uncomp_len - (uptr - uncompressed));
+
+ DBG("pos %d ulen %d left %d name %s", pos, ulen,
+ (int)(uncomp_len - (uptr - uncompressed)), uptr);
+
+ uptr += ulen;
+ *uptr++ = '\0';
+
+ ptr += pos;
+
+ /*
+ * We copy also the fixed portion of the result (type, class,
+ * ttl, address length and the address)
+ */
+ memcpy(uptr, ptr, NS_RRFIXEDSZ);
+
+ dns_type = uptr[0] << 8 | uptr[1];
+ dns_class = uptr[2] << 8 | uptr[3];
+
+ if (dns_class != ns_c_in)
+ goto out;
+
+ ptr += NS_RRFIXEDSZ;
+ uptr += NS_RRFIXEDSZ;
+
+ /*
+ * Then the variable portion of the result (data length).
+ * Typically this portion is also compressed
+ * so we need to uncompress it also when necessary.
+ */
+ if (dns_type == ns_t_cname) {
+ if (!convert_label(start, end, ptr, uptr,
+ uncomp_len - (uptr - uncompressed),
+ &pos, &comp_pos))
+ goto out;
+
+ uptr[-2] = comp_pos << 8;
+ uptr[-1] = comp_pos & 0xff;
+
+ uptr += comp_pos;
+ ptr += pos;
+
+ } else if (dns_type == ns_t_a || dns_type == ns_t_aaaa) {
+ dlen = uptr[-2] << 8 | uptr[-1];
+
+ if (ptr + dlen > end) {
+ DBG("data len %d too long", dlen);
+ goto out;
+ }
+
+ memcpy(uptr, ptr, dlen);
+ uptr += dlen;
+ ptr += dlen;
+
+ } else if (dns_type == ns_t_soa) {
+ int total_len = 0;
+ char *len_ptr;
+
+ /* Primary name server expansion */
+ if (!convert_label(start, end, ptr, uptr,
+ uncomp_len - (uptr - uncompressed),
+ &pos, &comp_pos))
+ goto out;
+
+ total_len += comp_pos;
+ len_ptr = &uptr[-2];
+ ptr += pos;
+ uptr += comp_pos;
+
+ /* Responsible authority's mailbox */
+ if (!convert_label(start, end, ptr, uptr,
+ uncomp_len - (uptr - uncompressed),
+ &pos, &comp_pos))
+ goto out;
+
+ total_len += comp_pos;
+ ptr += pos;
+ uptr += comp_pos;
+
+ /*
+ * Copy rest of the soa fields (serial number,
+ * refresh interval, retry interval, expiration
+ * limit and minimum ttl). They are 20 bytes long.
+ */
+ memcpy(uptr, ptr, 20);
+ uptr += 20;
+ ptr += 20;
+ total_len += 20;
+
+ /*
+ * Finally fix the length of the data part
+ */
+ len_ptr[0] = total_len << 8;
+ len_ptr[1] = total_len & 0xff;
+ }
+
+ *uncompressed_ptr = uptr;
+ }
+
+ return ptr;
+
+out:
+ return NULL;
+}
+
+static int strip_domains(char *name, char *answers, int maxlen)
+{
+ uint16_t data_len;
+ int name_len = strlen(name);
+ char *ptr, *start = answers, *end = answers + maxlen;
+
+ while (maxlen > 0) {
+ ptr = strstr(answers, name);
+ if (ptr) {
+ char *domain = ptr + name_len;
+
+ if (*domain) {
+ int domain_len = strlen(domain);
+
+ memmove(answers + name_len,
+ domain + domain_len,
+ end - (domain + domain_len));
+
+ end -= domain_len;
+ maxlen -= domain_len;
+ }
+ }
+
+ answers += strlen(answers) + 1;
+ answers += 2 + 2 + 4; /* skip type, class and ttl fields */
+
+ data_len = answers[0] << 8 | answers[1];
+ answers += 2; /* skip the length field */
+
+ if (answers + data_len > end)
+ return -EINVAL;
+
+ answers += data_len;
+ maxlen -= answers - ptr;
+ }
+
+ return end - start;
+}
+
+static int forward_dns_reply(unsigned char *reply, int reply_len, int protocol,
+ struct server_data *data)
+{
+ struct domain_hdr *hdr;
+ struct request_data *req;
+ int dns_id, sk, err, offset = protocol_offset(protocol);
+
+ if (offset < 0)
+ return offset;
+
+ hdr = (void *)(reply + offset);
+ dns_id = reply[offset] | reply[offset + 1] << 8;
+
+ DBG("Received %d bytes (id 0x%04x)", reply_len, dns_id);
+
+ req = find_request(dns_id);
+ if (!req)
+ return -EINVAL;
+
+ DBG("req %p dstid 0x%04x altid 0x%04x rcode %d",
+ req, req->dstid, req->altid, hdr->rcode);
+
+ reply[offset] = req->srcid & 0xff;
+ reply[offset + 1] = req->srcid >> 8;
+
+ req->numresp++;
+
+ if (hdr->rcode == ns_r_noerror || !req->resp) {
+ unsigned char *new_reply = NULL;
+
+ /*
+ * If the domain name was append
+ * remove it before forwarding the reply.
+ * If there were more than one question, then this
+ * domain name ripping can be hairy so avoid that
+ * and bail out in that that case.
+ *
+ * The reason we are doing this magic is that if the
+ * user's DNS client tries to resolv hostname without
+ * domain part, it also expects to get the result without
+ * a domain name part.
+ */
+ if (req->append_domain && ntohs(hdr->qdcount) == 1) {
+ uint16_t domain_len = 0;
+ uint16_t header_len;
+ uint16_t dns_type, dns_class;
+ uint8_t host_len, dns_type_pos;
+ char uncompressed[NS_MAXDNAME], *uptr;
+ char *ptr, *eom = (char *)reply + reply_len;
+
+ /*
+ * ptr points to the first char of the hostname.
+ * ->hostname.domain.net
+ */
+ header_len = offset + sizeof(struct domain_hdr);
+ ptr = (char *)reply + header_len;
+
+ host_len = *ptr;
+ if (host_len > 0)
+ domain_len = strnlen(ptr + 1 + host_len,
+ reply_len - header_len);
+
+ /*
+ * If the query type is anything other than A or AAAA,
+ * then bail out and pass the message as is.
+ * We only want to deal with IPv4 or IPv6 addresses.
+ */
+ dns_type_pos = host_len + 1 + domain_len + 1;
+
+ dns_type = ptr[dns_type_pos] << 8 |
+ ptr[dns_type_pos + 1];
+ dns_class = ptr[dns_type_pos + 2] << 8 |
+ ptr[dns_type_pos + 3];
+ if (dns_type != ns_t_a && dns_type != ns_t_aaaa &&
+ dns_class != ns_c_in) {
+ DBG("Pass msg dns type %d class %d",
+ dns_type, dns_class);
+ goto pass;
+ }
+
+ /*
+ * Remove the domain name and replace it by the end
+ * of reply. Check if the domain is really there
+ * before trying to copy the data. We also need to
+ * uncompress the answers if necessary.
+ * The domain_len can be 0 because if the original
+ * query did not contain a domain name, then we are
+ * sending two packets, first without the domain name
+ * and the second packet with domain name.
+ * The append_domain is set to true even if we sent
+ * the first packet without domain name. In this
+ * case we end up in this branch.
+ */
+ if (domain_len > 0) {
+ int len = host_len + 1;
+ int new_len, fixed_len;
+ char *answers;
+
+ /*
+ * First copy host (without domain name) into
+ * tmp buffer.
+ */
+ uptr = &uncompressed[0];
+ memcpy(uptr, ptr, len);
+
+ uptr[len] = '\0'; /* host termination */
+ uptr += len + 1;
+
+ /*
+ * Copy type and class fields of the question.
+ */
+ ptr += len + domain_len + 1;
+ memcpy(uptr, ptr, NS_QFIXEDSZ);
+
+ /*
+ * ptr points to answers after this
+ */
+ ptr += NS_QFIXEDSZ;
+ uptr += NS_QFIXEDSZ;
+ answers = uptr;
+ fixed_len = answers - uncompressed;
+
+ /*
+ * We then uncompress the result to buffer
+ * so that we can rip off the domain name
+ * part from the question. First answers,
+ * then name server (authority) information,
+ * and finally additional record info.
+ */
+
+ ptr = uncompress(ntohs(hdr->ancount),
+ (char *)reply + offset, eom,
+ ptr, uncompressed, NS_MAXDNAME,
+ &uptr);
+ if (ptr == NULL)
+ goto out;
+
+ ptr = uncompress(ntohs(hdr->nscount),
+ (char *)reply + offset, eom,
+ ptr, uncompressed, NS_MAXDNAME,
+ &uptr);
+ if (ptr == NULL)
+ goto out;
+
+ ptr = uncompress(ntohs(hdr->arcount),
+ (char *)reply + offset, eom,
+ ptr, uncompressed, NS_MAXDNAME,
+ &uptr);
+ if (ptr == NULL)
+ goto out;
+
+ /*
+ * The uncompressed buffer now contains almost
+ * valid response. Final step is to get rid of
+ * the domain name because at least glibc
+ * gethostbyname() implementation does extra
+ * checks and expects to find an answer without
+ * domain name if we asked a query without
+ * domain part. Note that glibc getaddrinfo()
+ * works differently and accepts FQDN in answer
+ */
+ new_len = strip_domains(uncompressed, answers,
+ uptr - answers);
+ if (new_len < 0) {
+ DBG("Corrupted packet");
+ return -EINVAL;
+ }
+
+ /*
+ * Because we have now uncompressed the answers
+ * we might have to create a bigger buffer to
+ * hold all that data.
+ */
+
+ reply_len = header_len + new_len + fixed_len;
+
+ new_reply = g_try_malloc(reply_len);
+ if (!new_reply)
+ return -ENOMEM;
+
+ memcpy(new_reply, reply, header_len);
+ memcpy(new_reply + header_len, uncompressed,
+ new_len + fixed_len);
+
+ reply = new_reply;
+ }
+ }
+
+ pass:
+ g_free(req->resp);
+ req->resplen = 0;
+
+ req->resp = g_try_malloc(reply_len);
+ if (!req->resp)
+ return -ENOMEM;
+
+ memcpy(req->resp, reply, reply_len);
+ req->resplen = reply_len;
+
+ cache_update(data, reply, reply_len);
+
+ g_free(new_reply);
+ }
+
+out:
+ if (req->numresp < req->numserv) {
+ if (hdr->rcode > ns_r_noerror) {
+ return -EINVAL;
+ } else if (hdr->ancount == 0 && req->append_domain) {
+ return -EINVAL;
+ }
+ }
+
+ request_list = g_slist_remove(request_list, req);
+
+ if (protocol == IPPROTO_UDP) {
+ sk = get_req_udp_socket(req);
+ if (sk < 0) {
+ errno = -EIO;
+ err = -EIO;
+ } else
+ err = sendto(sk, req->resp, req->resplen, 0,
+ &req->sa, req->sa_len);
+ } else {
+ sk = req->client_sk;
+ err = send(sk, req->resp, req->resplen, MSG_NOSIGNAL);
+ }
+
+ if (err < 0)
+ DBG("Cannot send msg, sk %d proto %d errno %d/%s", sk,
+ protocol, errno, strerror(errno));
+ else
+ DBG("proto %d sent %d bytes to %d", protocol, err, sk);
+
+ destroy_request_data(req);
+
+ return err;
+}
+
+static void server_destroy_socket(struct server_data *data)
+{
+ DBG("index %d server %s proto %d", data->index,
+ data->server, data->protocol);
+
+ if (data->watch > 0) {
+ g_source_remove(data->watch);
+ data->watch = 0;
+ }
+
+ if (data->timeout > 0) {
+ g_source_remove(data->timeout);
+ data->timeout = 0;
+ }
+
+ if (data->channel) {
+ g_io_channel_shutdown(data->channel, TRUE, NULL);
+ g_io_channel_unref(data->channel);
+ data->channel = NULL;
+ }
+
+ g_free(data->incoming_reply);
+ data->incoming_reply = NULL;
+}
+
+static void destroy_server(struct server_data *server)
+{
+ DBG("index %d server %s sock %d", server->index, server->server,
+ server->channel ?
+ g_io_channel_unix_get_fd(server->channel): -1);
+
+ server_list = g_slist_remove(server_list, server);
+ server_destroy_socket(server);
+
+ if (server->protocol == IPPROTO_UDP && server->enabled)
+ DBG("Removing DNS server %s", server->server);
+
+ g_free(server->server);
+ g_list_free_full(server->domains, g_free);
+ g_free(server->server_addr);
+
+ /*
+ * We do not remove cache right away but delay it few seconds.
+ * The idea is that when IPv6 DNS server is added via RDNSS, it has a
+ * lifetime. When the lifetime expires we decrease the refcount so it
+ * is possible that the cache is then removed. Because a new DNS server
+ * is usually created almost immediately we would then loose the cache
+ * without any good reason. The small delay allows the new RDNSS to
+ * create a new DNS server instance and the refcount does not go to 0.
+ */
+ if (cache && !cache_timer)
+ cache_timer = g_timeout_add_seconds(3, try_remove_cache, NULL);
+
+ g_free(server);
+}
+
+static gboolean udp_server_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ unsigned char buf[4096];
+ int sk, err, len;
+ struct server_data *data = user_data;
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ connman_error("Error with UDP server %s", data->server);
+ server_destroy_socket(data);
+ return FALSE;
+ }
+
+ sk = g_io_channel_unix_get_fd(channel);
+
+ len = recv(sk, buf, sizeof(buf), 0);
+ if (len < 12)
+ return TRUE;
+
+ err = forward_dns_reply(buf, len, IPPROTO_UDP, data);
+ if (err < 0)
+ return TRUE;
+
+ return TRUE;
+}
+
+static gboolean tcp_server_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ int sk;
+ struct server_data *server = user_data;
+
+ sk = g_io_channel_unix_get_fd(channel);
+ if (sk == 0)
+ return FALSE;
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ GSList *list;
+hangup:
+ DBG("TCP server channel closed, sk %d", sk);
+
+ /*
+ * Discard any partial response which is buffered; better
+ * to get a proper response from a working server.
+ */
+ g_free(server->incoming_reply);
+ server->incoming_reply = NULL;
+
+ for (list = request_list; list; list = list->next) {
+ struct request_data *req = list->data;
+ struct domain_hdr *hdr;
+
+ if (req->protocol == IPPROTO_UDP)
+ continue;
+
+ if (!req->request)
+ continue;
+
+ /*
+ * If we're not waiting for any further response
+ * from another name server, then we send an error
+ * response to the client.
+ */
+ if (req->numserv && --(req->numserv))
+ continue;
+
+ hdr = (void *) (req->request + 2);
+ hdr->id = req->srcid;
+ send_response(req->client_sk, req->request,
+ req->request_len, NULL, 0, IPPROTO_TCP);
+
+ request_list = g_slist_remove(request_list, req);
+ }
+
+ destroy_server(server);
+
+ return FALSE;
+ }
+
+ if ((condition & G_IO_OUT) && !server->connected) {
+ GSList *list;
+ GList *domains;
+ bool no_request_sent = true;
+ struct server_data *udp_server;
+
+ udp_server = find_server(server->index, server->server,
+ IPPROTO_UDP);
+ if (udp_server) {
+ for (domains = udp_server->domains; domains;
+ domains = domains->next) {
+ char *dom = domains->data;
+
+ DBG("Adding domain %s to %s",
+ dom, server->server);
+
+ server->domains = g_list_append(server->domains,
+ g_strdup(dom));
+ }
+ }
+
+ server->connected = true;
+ server_list = g_slist_append(server_list, server);
+
+ if (server->timeout > 0) {
+ g_source_remove(server->timeout);
+ server->timeout = 0;
+ }
+
+ for (list = request_list; list; ) {
+ struct request_data *req = list->data;
+ int status;
+
+ if (req->protocol == IPPROTO_UDP) {
+ list = list->next;
+ continue;
+ }
+
+ DBG("Sending req %s over TCP", (char *)req->name);
+
+ status = ns_resolv(server, req,
+ req->request, req->name);
+ if (status > 0) {
+ /*
+ * A cached result was sent,
+ * so the request can be released
+ */
+ list = list->next;
+ request_list = g_slist_remove(request_list, req);
+ destroy_request_data(req);
+ continue;
+ }
+
+ if (status < 0) {
+ list = list->next;
+ continue;
+ }
+
+ no_request_sent = false;
+
+ if (req->timeout > 0)
+ g_source_remove(req->timeout);
+
+ req->timeout = g_timeout_add_seconds(30,
+ request_timeout, req);
+ list = list->next;
+ }
+
+ if (no_request_sent) {
+ destroy_server(server);
+ return FALSE;
+ }
+
+ } else if (condition & G_IO_IN) {
+ struct partial_reply *reply = server->incoming_reply;
+ int bytes_recv;
+
+ if (!reply) {
+ unsigned char reply_len_buf[2];
+ uint16_t reply_len;
+
+ bytes_recv = recv(sk, reply_len_buf, 2, MSG_PEEK);
+ if (!bytes_recv) {
+ goto hangup;
+ } else if (bytes_recv < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK)
+ return TRUE;
+
+ connman_error("DNS proxy error %s",
+ strerror(errno));
+ goto hangup;
+ } else if (bytes_recv < 2)
+ return TRUE;
+
+ reply_len = reply_len_buf[1] | reply_len_buf[0] << 8;
+ reply_len += 2;
+
+ DBG("TCP reply %d bytes from %d", reply_len, sk);
+
+ reply = g_try_malloc(sizeof(*reply) + reply_len + 2);
+ if (!reply)
+ return TRUE;
+
+ reply->len = reply_len;
+ reply->received = 0;
+
+ server->incoming_reply = reply;
+ }
+
+ while (reply->received < reply->len) {
+ bytes_recv = recv(sk, reply->buf + reply->received,
+ reply->len - reply->received, 0);
+ if (!bytes_recv) {
+ connman_error("DNS proxy TCP disconnect");
+ break;
+ } else if (bytes_recv < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK)
+ return TRUE;
+
+ connman_error("DNS proxy error %s",
+ strerror(errno));
+ break;
+ }
+ reply->received += bytes_recv;
+ }
+
+ forward_dns_reply(reply->buf, reply->received, IPPROTO_TCP,
+ server);
+
+ g_free(reply);
+ server->incoming_reply = NULL;
+
+ destroy_server(server);
+
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static gboolean tcp_idle_timeout(gpointer user_data)
+{
+ struct server_data *server = user_data;
+
+ DBG("");
+
+ if (!server)
+ return FALSE;
+
+ destroy_server(server);
+
+ return FALSE;
+}
+
+static int server_create_socket(struct server_data *data)
+{
+ int sk, err;
+ char *interface;
+
+ DBG("index %d server %s proto %d", data->index,
+ data->server, data->protocol);
+
+ sk = socket(data->server_addr->sa_family,
+ data->protocol == IPPROTO_TCP ? SOCK_STREAM : SOCK_DGRAM,
+ data->protocol);
+ if (sk < 0) {
+ err = errno;
+ connman_error("Failed to create server %s socket",
+ data->server);
+ server_destroy_socket(data);
+ return -err;
+ }
+
+ DBG("sk %d", sk);
+
+ interface = connman_inet_ifname(data->index);
+ if (interface) {
+ if (setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
+ interface,
+ strlen(interface) + 1) < 0) {
+ err = errno;
+ connman_error("Failed to bind server %s "
+ "to interface %s",
+ data->server, interface);
+ close(sk);
+ server_destroy_socket(data);
+ g_free(interface);
+ return -err;
+ }
+ g_free(interface);
+ }
+
+ data->channel = g_io_channel_unix_new(sk);
+ if (!data->channel) {
+ connman_error("Failed to create server %s channel",
+ data->server);
+ close(sk);
+ server_destroy_socket(data);
+ return -ENOMEM;
+ }
+
+ g_io_channel_set_close_on_unref(data->channel, TRUE);
+
+ if (data->protocol == IPPROTO_TCP) {
+ g_io_channel_set_flags(data->channel, G_IO_FLAG_NONBLOCK, NULL);
+ data->watch = g_io_add_watch(data->channel,
+ G_IO_OUT | G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
+ tcp_server_event, data);
+ data->timeout = g_timeout_add_seconds(30, tcp_idle_timeout,
+ data);
+ } else
+ data->watch = g_io_add_watch(data->channel,
+ G_IO_IN | G_IO_NVAL | G_IO_ERR | G_IO_HUP,
+ udp_server_event, data);
+
+ if (connect(sk, data->server_addr, data->server_addr_len) < 0) {
+ err = errno;
+
+ if ((data->protocol == IPPROTO_TCP && errno != EINPROGRESS) ||
+ data->protocol == IPPROTO_UDP) {
+
+ connman_error("Failed to connect to server %s",
+ data->server);
+ server_destroy_socket(data);
+ return -err;
+ }
+ }
+
+ create_cache();
+
+ return 0;
+}
+
+static struct server_data *create_server(int index,
+ const char *domain, const char *server,
+ int protocol)
+{
+ struct server_data *data;
+ struct addrinfo hints, *rp;
+ int ret;
+
+ DBG("index %d server %s", index, server);
+
+ data = g_try_new0(struct server_data, 1);
+ if (!data) {
+ connman_error("Failed to allocate server %s data", server);
+ return NULL;
+ }
+
+ data->index = index;
+ if (domain)
+ data->domains = g_list_append(data->domains, g_strdup(domain));
+ data->server = g_strdup(server);
+ data->protocol = protocol;
+
+ memset(&hints, 0, sizeof(hints));
+
+ switch (protocol) {
+ case IPPROTO_UDP:
+ hints.ai_socktype = SOCK_DGRAM;
+ break;
+
+ case IPPROTO_TCP:
+ hints.ai_socktype = SOCK_STREAM;
+ break;
+
+ default:
+ destroy_server(data);
+ return NULL;
+ }
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_flags = AI_NUMERICSERV | AI_NUMERICHOST;
+
+ ret = getaddrinfo(data->server, "53", &hints, &rp);
+ if (ret) {
+ connman_error("Failed to parse server %s address: %s\n",
+ data->server, gai_strerror(ret));
+ destroy_server(data);
+ return NULL;
+ }
+
+ /* Do not blindly copy this code elsewhere; it doesn't loop over the
+ results using ->ai_next as it should. That's OK in *this* case
+ because it was a numeric lookup; we *know* there's only one. */
+
+ data->server_addr_len = rp->ai_addrlen;
+
+ switch (rp->ai_family) {
+ case AF_INET:
+ data->server_addr = (struct sockaddr *)
+ g_try_new0(struct sockaddr_in, 1);
+ break;
+ case AF_INET6:
+ data->server_addr = (struct sockaddr *)
+ g_try_new0(struct sockaddr_in6, 1);
+ break;
+ default:
+ connman_error("Wrong address family %d", rp->ai_family);
+ break;
+ }
+ if (!data->server_addr) {
+ freeaddrinfo(rp);
+ destroy_server(data);
+ return NULL;
+ }
+ memcpy(data->server_addr, rp->ai_addr, rp->ai_addrlen);
+ freeaddrinfo(rp);
+
+ if (server_create_socket(data) != 0) {
+ destroy_server(data);
+ return NULL;
+ }
+
+ if (protocol == IPPROTO_UDP) {
+ if (__connman_service_index_is_default(data->index) ||
+ __connman_service_index_is_split_routing(
+ data->index)) {
+ data->enabled = true;
+ DBG("Adding DNS server %s", data->server);
+ }
+
+ server_list = g_slist_append(server_list, data);
+ }
+
+ return data;
+}
+
+static bool resolv(struct request_data *req,
+ gpointer request, gpointer name)
+{
+ GSList *list;
+
+ for (list = server_list; list; list = list->next) {
+ struct server_data *data = list->data;
+
+ if (data->protocol == IPPROTO_TCP) {
+ DBG("server %s ignored proto TCP", data->server);
+ continue;
+ }
+
+ DBG("server %s enabled %d", data->server, data->enabled);
+
+ if (!data->enabled)
+ continue;
+
+ if (!data->channel && data->protocol == IPPROTO_UDP) {
+ if (server_create_socket(data) < 0) {
+ DBG("socket creation failed while resolving");
+ continue;
+ }
+ }
+
+ if (ns_resolv(data, req, request, name) > 0)
+ return true;
+ }
+
+ return false;
+}
+
+static void append_domain(int index, const char *domain)
+{
+ GSList *list;
+
+ DBG("index %d domain %s", index, domain);
+
+ if (!domain)
+ return;
+
+ for (list = server_list; list; list = list->next) {
+ struct server_data *data = list->data;
+ GList *dom_list;
+ char *dom;
+ bool dom_found = false;
+
+ if (data->index < 0)
+ continue;
+
+ if (data->index != index)
+ continue;
+
+ for (dom_list = data->domains; dom_list;
+ dom_list = dom_list->next) {
+ dom = dom_list->data;
+
+ if (g_str_equal(dom, domain)) {
+ dom_found = true;
+ break;
+ }
+ }
+
+ if (!dom_found) {
+ data->domains =
+ g_list_append(data->domains, g_strdup(domain));
+ }
+ }
+}
+
+static void flush_requests(struct server_data *server)
+{
+ GSList *list;
+
+ list = request_list;
+ while (list) {
+ struct request_data *req = list->data;
+
+ list = list->next;
+
+ if (ns_resolv(server, req, req->request, req->name)) {
+ /*
+ * A cached result was sent,
+ * so the request can be released
+ */
+ request_list =
+ g_slist_remove(request_list, req);
+ destroy_request_data(req);
+ continue;
+ }
+
+ if (req->timeout > 0)
+ g_source_remove(req->timeout);
+
+ req->timeout = g_timeout_add_seconds(5, request_timeout, req);
+ }
+}
+
+int __connman_dnsproxy_append(int index, const char *domain,
+ const char *server)
+{
+ struct server_data *data;
+
+ DBG("index %d server %s", index, server);
+
+ if (!server && !domain)
+ return -EINVAL;
+
+ if (!server) {
+ append_domain(index, domain);
+
+ return 0;
+ }
+
+ if (g_str_equal(server, "127.0.0.1"))
+ return -ENODEV;
+
+ if (g_str_equal(server, "::1"))
+ return -ENODEV;
+
+ data = find_server(index, server, IPPROTO_UDP);
+ if (data) {
+ append_domain(index, domain);
+ return 0;
+ }
+
+ data = create_server(index, domain, server, IPPROTO_UDP);
+ if (!data)
+ return -EIO;
+
+ flush_requests(data);
+
+ return 0;
+}
+
+static void remove_server(int index, const char *domain,
+ const char *server, int protocol)
+{
+ struct server_data *data;
+
+ data = find_server(index, server, protocol);
+ if (!data)
+ return;
+
+ destroy_server(data);
+}
+
+int __connman_dnsproxy_remove(int index, const char *domain,
+ const char *server)
+{
+ DBG("index %d server %s", index, server);
+
+ if (!server)
+ return -EINVAL;
+
+ if (g_str_equal(server, "127.0.0.1"))
+ return -ENODEV;
+
+ if (g_str_equal(server, "::1"))
+ return -ENODEV;
+
+ remove_server(index, domain, server, IPPROTO_UDP);
+ remove_server(index, domain, server, IPPROTO_TCP);
+
+ return 0;
+}
+
+static void dnsproxy_offline_mode(bool enabled)
+{
+ GSList *list;
+
+ DBG("enabled %d", enabled);
+
+ for (list = server_list; list; list = list->next) {
+ struct server_data *data = list->data;
+
+ if (!enabled) {
+ DBG("Enabling DNS server %s", data->server);
+ data->enabled = true;
+ cache_invalidate();
+ cache_refresh();
+ } else {
+ DBG("Disabling DNS server %s", data->server);
+ data->enabled = false;
+ if (data->channel) {
+ server_destroy_socket(data);
+ }
+ cache_invalidate();
+ }
+ }
+}
+
+static void dnsproxy_default_changed(struct connman_service *service)
+{
+ GSList *list;
+ int index;
+
+ DBG("service %p", service);
+
+ /* DNS has changed, invalidate the cache */
+ cache_invalidate();
+
+ if (!service) {
+ /* When no services are active, then disable DNS proxying */
+ dnsproxy_offline_mode(true);
+ return;
+ }
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return;
+
+ for (list = server_list; list; list = list->next) {
+ struct server_data *data = list->data;
+
+ if (data->index == index) {
+ DBG("Enabling DNS server %s", data->server);
+ data->enabled = true;
+ } else {
+ DBG("Disabling DNS server %s", data->server);
+ data->enabled = false;
+ if (data->channel) {
+ server_destroy_socket(data);
+ }
+ }
+ }
+
+ cache_refresh();
+}
+
+static struct connman_notifier dnsproxy_notifier = {
+ .name = "dnsproxy",
+ .default_changed = dnsproxy_default_changed,
+ .offline_mode = dnsproxy_offline_mode,
+};
+
+static unsigned char opt_edns0_type[2] = { 0x00, 0x29 };
+
+static int parse_request(unsigned char *buf, int len,
+ char *name, unsigned int size)
+{
+ struct domain_hdr *hdr = (void *) buf;
+ uint16_t qdcount = ntohs(hdr->qdcount);
+ uint16_t arcount = ntohs(hdr->arcount);
+ unsigned char *ptr;
+ char *last_label = NULL;
+ unsigned int remain, used = 0;
+
+ if (len < 12)
+ return -EINVAL;
+
+ DBG("id 0x%04x qr %d opcode %d qdcount %d arcount %d",
+ hdr->id, hdr->qr, hdr->opcode,
+ qdcount, arcount);
+
+ if (hdr->qr != 0 || qdcount != 1)
+ return -EINVAL;
+
+ name[0] = '\0';
+
+ ptr = buf + sizeof(struct domain_hdr);
+ remain = len - sizeof(struct domain_hdr);
+
+ while (remain > 0) {
+ uint8_t label_len = *ptr;
+
+ if (label_len == 0x00) {
+ last_label = (char *) (ptr + 1);
+ break;
+ }
+
+ if (used + label_len + 1 > size)
+ return -ENOBUFS;
+
+ strncat(name, (char *) (ptr + 1), label_len);
+ strcat(name, ".");
+
+ used += label_len + 1;
+
+ ptr += label_len + 1;
+ remain -= label_len + 1;
+ }
+
+ if (last_label && arcount && remain >= 9 && last_label[4] == 0 &&
+ !memcmp(last_label + 5, opt_edns0_type, 2)) {
+ uint16_t edns0_bufsize;
+
+ edns0_bufsize = last_label[7] << 8 | last_label[8];
+
+ DBG("EDNS0 buffer size %u", edns0_bufsize);
+
+ /* This is an evil hack until full TCP support has been
+ * implemented.
+ *
+ * Somtimes the EDNS0 request gets send with a too-small
+ * buffer size. Since glibc doesn't seem to crash when it
+ * gets a response biffer then it requested, just bump
+ * the buffer size up to 4KiB.
+ */
+ if (edns0_bufsize < 0x1000) {
+ last_label[7] = 0x10;
+ last_label[8] = 0x00;
+ }
+ }
+
+ DBG("query %s", name);
+
+ return 0;
+}
+
+static void client_reset(struct tcp_partial_client_data *client)
+{
+ if (!client)
+ return;
+
+ if (client->channel) {
+ DBG("client %d closing",
+ g_io_channel_unix_get_fd(client->channel));
+
+ g_io_channel_unref(client->channel);
+ client->channel = NULL;
+ }
+
+ if (client->watch > 0) {
+ g_source_remove(client->watch);
+ client->watch = 0;
+ }
+
+ if (client->timeout > 0) {
+ g_source_remove(client->timeout);
+ client->timeout = 0;
+ }
+
+ g_free(client->buf);
+ client->buf = NULL;
+
+ client->buf_end = 0;
+}
+
+static unsigned int get_msg_len(unsigned char *buf)
+{
+ return buf[0]<<8 | buf[1];
+}
+
+static bool read_tcp_data(struct tcp_partial_client_data *client,
+ void *client_addr, socklen_t client_addr_len,
+ int read_len)
+{
+ char query[TCP_MAX_BUF_LEN];
+ struct request_data *req;
+ int client_sk, err;
+ unsigned int msg_len;
+ GSList *list;
+ bool waiting_for_connect = false;
+ int qtype = 0;
+ struct cache_entry *entry;
+
+ client_sk = g_io_channel_unix_get_fd(client->channel);
+
+ if (read_len == 0) {
+ DBG("client %d closed, pending %d bytes",
+ client_sk, client->buf_end);
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ return false;
+ }
+
+ DBG("client %d received %d bytes", client_sk, read_len);
+
+ client->buf_end += read_len;
+
+ if (client->buf_end < 2)
+ return true;
+
+ msg_len = get_msg_len(client->buf);
+ if (msg_len > TCP_MAX_BUF_LEN) {
+ DBG("client %d sent too much data %d", client_sk, msg_len);
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ return false;
+ }
+
+read_another:
+ DBG("client %d msg len %d end %d past end %d", client_sk, msg_len,
+ client->buf_end, client->buf_end - (msg_len + 2));
+
+ if (client->buf_end < (msg_len + 2)) {
+ DBG("client %d still missing %d bytes",
+ client_sk,
+ msg_len + 2 - client->buf_end);
+ return true;
+ }
+
+ DBG("client %d all data %d received", client_sk, msg_len);
+
+ err = parse_request(client->buf + 2, msg_len,
+ query, sizeof(query));
+ if (err < 0 || (g_slist_length(server_list) == 0)) {
+ send_response(client_sk, client->buf, msg_len + 2,
+ NULL, 0, IPPROTO_TCP);
+ return true;
+ }
+
+ req = g_try_new0(struct request_data, 1);
+ if (!req)
+ return true;
+
+ memcpy(&req->sa, client_addr, client_addr_len);
+ req->sa_len = client_addr_len;
+ req->client_sk = client_sk;
+ req->protocol = IPPROTO_TCP;
+ req->family = client->family;
+
+ req->srcid = client->buf[2] | (client->buf[3] << 8);
+ req->dstid = get_id();
+ req->altid = get_id();
+ req->request_len = msg_len + 2;
+
+ client->buf[2] = req->dstid & 0xff;
+ client->buf[3] = req->dstid >> 8;
+
+ req->numserv = 0;
+ req->ifdata = client->ifdata;
+ req->append_domain = false;
+
+ /*
+ * Check if the answer is found in the cache before
+ * creating sockets to the server.
+ */
+ entry = cache_check(client->buf, &qtype, IPPROTO_TCP);
+ if (entry) {
+ int ttl_left = 0;
+ struct cache_data *data;
+
+ DBG("cache hit %s type %s", query, qtype == 1 ? "A" : "AAAA");
+ if (qtype == 1)
+ data = entry->ipv4;
+ else
+ data = entry->ipv6;
+
+ if (data) {
+ ttl_left = data->valid_until - time(NULL);
+ entry->hits++;
+
+ send_cached_response(client_sk, data->data,
+ data->data_len, NULL, 0, IPPROTO_TCP,
+ req->srcid, data->answers, ttl_left);
+
+ g_free(req);
+ goto out;
+ } else
+ DBG("data missing, ignoring cache for this query");
+ }
+
+ for (list = server_list; list; list = list->next) {
+ struct server_data *data = list->data;
+
+ if (data->protocol != IPPROTO_UDP || !data->enabled)
+ continue;
+
+ if (!create_server(data->index, NULL, data->server,
+ IPPROTO_TCP))
+ continue;
+
+ waiting_for_connect = true;
+ }
+
+ if (!waiting_for_connect) {
+ /* No server is waiting for connect */
+ send_response(client_sk, client->buf,
+ req->request_len, NULL, 0, IPPROTO_TCP);
+ g_free(req);
+ return true;
+ }
+
+ /*
+ * The server is not connected yet.
+ * Copy the relevant buffers.
+ * The request will actually be sent once we're
+ * properly connected over TCP to the nameserver.
+ */
+ req->request = g_try_malloc0(req->request_len);
+ if (!req->request) {
+ send_response(client_sk, client->buf,
+ req->request_len, NULL, 0, IPPROTO_TCP);
+ g_free(req);
+ goto out;
+ }
+ memcpy(req->request, client->buf, req->request_len);
+
+ req->name = g_try_malloc0(sizeof(query));
+ if (!req->name) {
+ send_response(client_sk, client->buf,
+ req->request_len, NULL, 0, IPPROTO_TCP);
+ g_free(req->request);
+ g_free(req);
+ goto out;
+ }
+ memcpy(req->name, query, sizeof(query));
+
+ req->timeout = g_timeout_add_seconds(30, request_timeout, req);
+
+ request_list = g_slist_append(request_list, req);
+
+out:
+ if (client->buf_end > (msg_len + 2)) {
+ DBG("client %d buf %p -> %p end %d len %d new %d",
+ client_sk,
+ client->buf + msg_len + 2,
+ client->buf, client->buf_end,
+ TCP_MAX_BUF_LEN - client->buf_end,
+ client->buf_end - (msg_len + 2));
+ memmove(client->buf, client->buf + msg_len + 2,
+ TCP_MAX_BUF_LEN - client->buf_end);
+ client->buf_end = client->buf_end - (msg_len + 2);
+
+ /*
+ * If we have a full message waiting, just read it
+ * immediately.
+ */
+ msg_len = get_msg_len(client->buf);
+ if ((msg_len + 2) == client->buf_end) {
+ DBG("client %d reading another %d bytes", client_sk,
+ msg_len + 2);
+ goto read_another;
+ }
+ } else {
+ DBG("client %d clearing reading buffer", client_sk);
+
+ client->buf_end = 0;
+ memset(client->buf, 0, TCP_MAX_BUF_LEN);
+
+ /*
+ * We received all the packets from client so we must also
+ * remove the timeout handler here otherwise we might get
+ * timeout while waiting the results from server.
+ */
+ g_source_remove(client->timeout);
+ client->timeout = 0;
+ }
+
+ return true;
+}
+
+static gboolean tcp_client_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ struct tcp_partial_client_data *client = user_data;
+ struct sockaddr_in6 client_addr6;
+ socklen_t client_addr6_len = sizeof(client_addr6);
+ struct sockaddr_in client_addr4;
+ socklen_t client_addr4_len = sizeof(client_addr4);
+ void *client_addr;
+ socklen_t *client_addr_len;
+ int len, client_sk;
+
+ client_sk = g_io_channel_unix_get_fd(channel);
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+
+ connman_error("Error with TCP client %d channel", client_sk);
+ return FALSE;
+ }
+
+ switch (client->family) {
+ case AF_INET:
+ client_addr = &client_addr4;
+ client_addr_len = &client_addr4_len;
+ break;
+ case AF_INET6:
+ client_addr = &client_addr6;
+ client_addr_len = &client_addr6_len;
+ break;
+ default:
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ connman_error("client %p corrupted", client);
+ return FALSE;
+ }
+
+ len = recvfrom(client_sk, client->buf + client->buf_end,
+ TCP_MAX_BUF_LEN - client->buf_end, 0,
+ client_addr, client_addr_len);
+ if (len < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK)
+ return TRUE;
+
+ DBG("client %d cannot read errno %d/%s", client_sk, -errno,
+ strerror(errno));
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ return FALSE;
+ }
+
+ return read_tcp_data(client, client_addr, *client_addr_len, len);
+}
+
+static gboolean client_timeout(gpointer user_data)
+{
+ struct tcp_partial_client_data *client = user_data;
+ int sock;
+
+ sock = g_io_channel_unix_get_fd(client->channel);
+
+ DBG("client %d timeout pending %d bytes", sock, client->buf_end);
+
+ g_hash_table_remove(partial_tcp_req_table, GINT_TO_POINTER(sock));
+
+ return FALSE;
+}
+
+static bool tcp_listener_event(GIOChannel *channel, GIOCondition condition,
+ struct listener_data *ifdata, int family,
+ guint *listener_watch)
+{
+ int sk, client_sk, len;
+ unsigned int msg_len;
+ struct tcp_partial_client_data *client;
+ struct sockaddr_in6 client_addr6;
+ socklen_t client_addr6_len = sizeof(client_addr6);
+ struct sockaddr_in client_addr4;
+ socklen_t client_addr4_len = sizeof(client_addr4);
+ void *client_addr;
+ socklen_t *client_addr_len;
+ struct timeval tv;
+ fd_set readfds;
+
+ DBG("condition 0x%02x channel %p ifdata %p family %d",
+ condition, channel, ifdata, family);
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ if (*listener_watch > 0)
+ g_source_remove(*listener_watch);
+ *listener_watch = 0;
+
+ connman_error("Error with TCP listener channel");
+
+ return false;
+ }
+
+ sk = g_io_channel_unix_get_fd(channel);
+
+ if (family == AF_INET) {
+ client_addr = &client_addr4;
+ client_addr_len = &client_addr4_len;
+ } else {
+ client_addr = &client_addr6;
+ client_addr_len = &client_addr6_len;
+ }
+
+ tv.tv_sec = tv.tv_usec = 0;
+ FD_ZERO(&readfds);
+ FD_SET(sk, &readfds);
+
+ select(sk + 1, &readfds, NULL, NULL, &tv);
+ if (FD_ISSET(sk, &readfds)) {
+ client_sk = accept(sk, client_addr, client_addr_len);
+ DBG("client %d accepted", client_sk);
+ } else {
+ DBG("No data to read from master %d, waiting.", sk);
+ return true;
+ }
+
+ if (client_sk < 0) {
+ connman_error("Accept failure on TCP listener");
+ *listener_watch = 0;
+ return false;
+ }
+
+ fcntl(client_sk, F_SETFL, O_NONBLOCK);
+
+ client = g_hash_table_lookup(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ if (!client) {
+ client = g_try_new0(struct tcp_partial_client_data, 1);
+ if (!client) {
+ close(client_sk);
+ return false;
+ }
+
+ g_hash_table_insert(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk),
+ client);
+
+ client->channel = g_io_channel_unix_new(client_sk);
+ g_io_channel_set_close_on_unref(client->channel, TRUE);
+
+ client->watch = g_io_add_watch(client->channel,
+ G_IO_IN, tcp_client_event,
+ (gpointer)client);
+
+ client->ifdata = ifdata;
+
+ DBG("client %d created %p", client_sk, client);
+ } else {
+ DBG("client %d already exists %p", client_sk, client);
+ }
+
+ if (!client->buf) {
+ client->buf = g_try_malloc(TCP_MAX_BUF_LEN);
+ if (!client->buf)
+ return false;
+ }
+ memset(client->buf, 0, TCP_MAX_BUF_LEN);
+ client->buf_end = 0;
+ client->family = family;
+
+ if (client->timeout == 0)
+ client->timeout = g_timeout_add_seconds(2, client_timeout,
+ client);
+
+ /*
+ * Check how much data there is. If all is there, then we can
+ * proceed normally, otherwise read the bits until everything
+ * is received or timeout occurs.
+ */
+ len = recv(client_sk, client->buf, TCP_MAX_BUF_LEN, 0);
+ if (len < 0) {
+ if (errno == EAGAIN || errno == EWOULDBLOCK) {
+ DBG("client %d no data to read, waiting", client_sk);
+ return true;
+ }
+
+ DBG("client %d cannot read errno %d/%s", client_sk, -errno,
+ strerror(errno));
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ return true;
+ }
+
+ if (len < 2) {
+ DBG("client %d not enough data to read, waiting", client_sk);
+ client->buf_end += len;
+ return true;
+ }
+
+ msg_len = get_msg_len(client->buf);
+ if (msg_len > TCP_MAX_BUF_LEN) {
+ DBG("client %d invalid message length %u ignoring packet",
+ client_sk, msg_len);
+ g_hash_table_remove(partial_tcp_req_table,
+ GINT_TO_POINTER(client_sk));
+ return true;
+ }
+
+ /*
+ * The packet length bytes do not contain the total message length,
+ * that is the reason to -2 below.
+ */
+ if (msg_len != (unsigned int)(len - 2)) {
+ DBG("client %d sent %d bytes but expecting %u pending %d",
+ client_sk, len, msg_len + 2, msg_len + 2 - len);
+
+ client->buf_end += len;
+ return true;
+ }
+
+ return read_tcp_data(client, client_addr, *client_addr_len, len);
+}
+
+static gboolean tcp4_listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ struct listener_data *ifdata = user_data;
+
+ return tcp_listener_event(channel, condition, ifdata, AF_INET,
+ &ifdata->tcp4_listener_watch);
+}
+
+static gboolean tcp6_listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ struct listener_data *ifdata = user_data;
+
+ return tcp_listener_event(channel, condition, user_data, AF_INET6,
+ &ifdata->tcp6_listener_watch);
+}
+
+static bool udp_listener_event(GIOChannel *channel, GIOCondition condition,
+ struct listener_data *ifdata, int family,
+ guint *listener_watch)
+{
+ unsigned char buf[768];
+ char query[512];
+ struct request_data *req;
+ struct sockaddr_in6 client_addr6;
+ socklen_t client_addr6_len = sizeof(client_addr6);
+ struct sockaddr_in client_addr4;
+ socklen_t client_addr4_len = sizeof(client_addr4);
+ void *client_addr;
+ socklen_t *client_addr_len;
+ int sk, err, len;
+
+ if (condition & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ connman_error("Error with UDP listener channel");
+ *listener_watch = 0;
+ return false;
+ }
+
+ sk = g_io_channel_unix_get_fd(channel);
+
+ if (family == AF_INET) {
+ client_addr = &client_addr4;
+ client_addr_len = &client_addr4_len;
+ } else {
+ client_addr = &client_addr6;
+ client_addr_len = &client_addr6_len;
+ }
+
+ memset(client_addr, 0, *client_addr_len);
+ len = recvfrom(sk, buf, sizeof(buf), 0, client_addr, client_addr_len);
+ if (len < 2)
+ return true;
+
+ DBG("Received %d bytes (id 0x%04x)", len, buf[0] | buf[1] << 8);
+
+ err = parse_request(buf, len, query, sizeof(query));
+ if (err < 0 || (g_slist_length(server_list) == 0)) {
+ send_response(sk, buf, len, client_addr,
+ *client_addr_len, IPPROTO_UDP);
+ return true;
+ }
+
+ req = g_try_new0(struct request_data, 1);
+ if (!req)
+ return true;
+
+ memcpy(&req->sa, client_addr, *client_addr_len);
+ req->sa_len = *client_addr_len;
+ req->client_sk = 0;
+ req->protocol = IPPROTO_UDP;
+ req->family = family;
+
+ req->srcid = buf[0] | (buf[1] << 8);
+ req->dstid = get_id();
+ req->altid = get_id();
+ req->request_len = len;
+
+ buf[0] = req->dstid & 0xff;
+ buf[1] = req->dstid >> 8;
+
+ req->numserv = 0;
+ req->ifdata = ifdata;
+ req->append_domain = false;
+
+ if (resolv(req, buf, query)) {
+ /* a cached result was sent, so the request can be released */
+ g_free(req);
+ return true;
+ }
+
+ req->name = g_strdup(query);
+ req->request = g_malloc(len);
+ memcpy(req->request, buf, len);
+ req->timeout = g_timeout_add_seconds(5, request_timeout, req);
+ request_list = g_slist_append(request_list, req);
+
+ return true;
+}
+
+static gboolean udp4_listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ struct listener_data *ifdata = user_data;
+
+ return udp_listener_event(channel, condition, ifdata, AF_INET,
+ &ifdata->udp4_listener_watch);
+}
+
+static gboolean udp6_listener_event(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ struct listener_data *ifdata = user_data;
+
+ return udp_listener_event(channel, condition, user_data, AF_INET6,
+ &ifdata->udp6_listener_watch);
+}
+
+static GIOChannel *get_listener(int family, int protocol, int index)
+{
+ GIOChannel *channel;
+ const char *proto;
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in6 sin6;
+ struct sockaddr_in sin;
+ } s;
+ socklen_t slen;
+ int sk, type;
+ char *interface;
+
+ DBG("family %d protocol %d index %d", family, protocol, index);
+
+ switch (protocol) {
+ case IPPROTO_UDP:
+ proto = "UDP";
+ type = SOCK_DGRAM | SOCK_CLOEXEC;
+ break;
+
+ case IPPROTO_TCP:
+ proto = "TCP";
+ type = SOCK_STREAM | SOCK_CLOEXEC;
+ break;
+
+ default:
+ return NULL;
+ }
+
+ sk = socket(family, type, protocol);
+ if (sk < 0 && family == AF_INET6 && errno == EAFNOSUPPORT) {
+ connman_error("No IPv6 support");
+ return NULL;
+ }
+
+ if (sk < 0) {
+ connman_error("Failed to create %s listener socket", proto);
+ return NULL;
+ }
+
+ interface = connman_inet_ifname(index);
+ if (!interface || setsockopt(sk, SOL_SOCKET, SO_BINDTODEVICE,
+ interface,
+ strlen(interface) + 1) < 0) {
+ connman_error("Failed to bind %s listener interface "
+ "for %s (%d/%s)",
+ proto, family == AF_INET ? "IPv4" : "IPv6",
+ -errno, strerror(errno));
+ close(sk);
+ g_free(interface);
+ return NULL;
+ }
+ g_free(interface);
+
+ if (family == AF_INET6) {
+ memset(&s.sin6, 0, sizeof(s.sin6));
+ s.sin6.sin6_family = AF_INET6;
+ s.sin6.sin6_port = htons(53);
+ slen = sizeof(s.sin6);
+
+ if (__connman_inet_get_interface_address(index,
+ AF_INET6,
+ &s.sin6.sin6_addr) < 0) {
+ /* So we could not find suitable IPv6 address for
+ * the interface. This could happen if we have
+ * disabled IPv6 for the interface.
+ */
+ close(sk);
+ return NULL;
+ }
+
+ } else if (family == AF_INET) {
+ memset(&s.sin, 0, sizeof(s.sin));
+ s.sin.sin_family = AF_INET;
+ s.sin.sin_port = htons(53);
+ slen = sizeof(s.sin);
+
+ if (__connman_inet_get_interface_address(index,
+ AF_INET,
+ &s.sin.sin_addr) < 0) {
+ close(sk);
+ return NULL;
+ }
+ } else {
+ close(sk);
+ return NULL;
+ }
+
+ if (bind(sk, &s.sa, slen) < 0) {
+ connman_error("Failed to bind %s listener socket", proto);
+ close(sk);
+ return NULL;
+ }
+
+ if (protocol == IPPROTO_TCP) {
+
+ if (listen(sk, 10) < 0) {
+ connman_error("Failed to listen on TCP socket %d/%s",
+ -errno, strerror(errno));
+ close(sk);
+ return NULL;
+ }
+
+ fcntl(sk, F_SETFL, O_NONBLOCK);
+ }
+
+ channel = g_io_channel_unix_new(sk);
+ if (!channel) {
+ connman_error("Failed to create %s listener channel", proto);
+ close(sk);
+ return NULL;
+ }
+
+ g_io_channel_set_close_on_unref(channel, TRUE);
+
+ return channel;
+}
+
+#define UDP_IPv4_FAILED 0x01
+#define TCP_IPv4_FAILED 0x02
+#define UDP_IPv6_FAILED 0x04
+#define TCP_IPv6_FAILED 0x08
+#define UDP_FAILED (UDP_IPv4_FAILED | UDP_IPv6_FAILED)
+#define TCP_FAILED (TCP_IPv4_FAILED | TCP_IPv6_FAILED)
+#define IPv6_FAILED (UDP_IPv6_FAILED | TCP_IPv6_FAILED)
+#define IPv4_FAILED (UDP_IPv4_FAILED | TCP_IPv4_FAILED)
+
+static int create_dns_listener(int protocol, struct listener_data *ifdata)
+{
+ int ret = 0;
+
+ if (protocol == IPPROTO_TCP) {
+ ifdata->tcp4_listener_channel = get_listener(AF_INET, protocol,
+ ifdata->index);
+ if (ifdata->tcp4_listener_channel)
+ ifdata->tcp4_listener_watch =
+ g_io_add_watch(ifdata->tcp4_listener_channel,
+ G_IO_IN, tcp4_listener_event,
+ (gpointer)ifdata);
+ else
+ ret |= TCP_IPv4_FAILED;
+
+ ifdata->tcp6_listener_channel = get_listener(AF_INET6, protocol,
+ ifdata->index);
+ if (ifdata->tcp6_listener_channel)
+ ifdata->tcp6_listener_watch =
+ g_io_add_watch(ifdata->tcp6_listener_channel,
+ G_IO_IN, tcp6_listener_event,
+ (gpointer)ifdata);
+ else
+ ret |= TCP_IPv6_FAILED;
+ } else {
+ ifdata->udp4_listener_channel = get_listener(AF_INET, protocol,
+ ifdata->index);
+ if (ifdata->udp4_listener_channel)
+ ifdata->udp4_listener_watch =
+ g_io_add_watch(ifdata->udp4_listener_channel,
+ G_IO_IN, udp4_listener_event,
+ (gpointer)ifdata);
+ else
+ ret |= UDP_IPv4_FAILED;
+
+ ifdata->udp6_listener_channel = get_listener(AF_INET6, protocol,
+ ifdata->index);
+ if (ifdata->udp6_listener_channel)
+ ifdata->udp6_listener_watch =
+ g_io_add_watch(ifdata->udp6_listener_channel,
+ G_IO_IN, udp6_listener_event,
+ (gpointer)ifdata);
+ else
+ ret |= UDP_IPv6_FAILED;
+ }
+
+ return ret;
+}
+
+static void destroy_udp_listener(struct listener_data *ifdata)
+{
+ DBG("index %d", ifdata->index);
+
+ if (ifdata->udp4_listener_watch > 0)
+ g_source_remove(ifdata->udp4_listener_watch);
+
+ if (ifdata->udp6_listener_watch > 0)
+ g_source_remove(ifdata->udp6_listener_watch);
+
+ if (ifdata->udp4_listener_channel)
+ g_io_channel_unref(ifdata->udp4_listener_channel);
+ if (ifdata->udp6_listener_channel)
+ g_io_channel_unref(ifdata->udp6_listener_channel);
+}
+
+static void destroy_tcp_listener(struct listener_data *ifdata)
+{
+ DBG("index %d", ifdata->index);
+
+ if (ifdata->tcp4_listener_watch > 0)
+ g_source_remove(ifdata->tcp4_listener_watch);
+ if (ifdata->tcp6_listener_watch > 0)
+ g_source_remove(ifdata->tcp6_listener_watch);
+
+ if (ifdata->tcp4_listener_channel)
+ g_io_channel_unref(ifdata->tcp4_listener_channel);
+ if (ifdata->tcp6_listener_channel)
+ g_io_channel_unref(ifdata->tcp6_listener_channel);
+}
+
+static int create_listener(struct listener_data *ifdata)
+{
+ int err, index;
+
+ err = create_dns_listener(IPPROTO_UDP, ifdata);
+ if ((err & UDP_FAILED) == UDP_FAILED)
+ return -EIO;
+
+ err |= create_dns_listener(IPPROTO_TCP, ifdata);
+ if ((err & TCP_FAILED) == TCP_FAILED) {
+ destroy_udp_listener(ifdata);
+ return -EIO;
+ }
+
+ index = connman_inet_ifindex("lo");
+ if (ifdata->index == index) {
+ if ((err & IPv6_FAILED) != IPv6_FAILED)
+ __connman_resolvfile_append(index, NULL, "::1");
+
+ if ((err & IPv4_FAILED) != IPv4_FAILED)
+ __connman_resolvfile_append(index, NULL, "127.0.0.1");
+ }
+
+ return 0;
+}
+
+static void destroy_listener(struct listener_data *ifdata)
+{
+ int index;
+ GSList *list;
+
+ index = connman_inet_ifindex("lo");
+ if (ifdata->index == index) {
+ __connman_resolvfile_remove(index, NULL, "127.0.0.1");
+ __connman_resolvfile_remove(index, NULL, "::1");
+ }
+
+ for (list = request_list; list; list = list->next) {
+ struct request_data *req = list->data;
+
+ DBG("Dropping request (id 0x%04x -> 0x%04x)",
+ req->srcid, req->dstid);
+ destroy_request_data(req);
+ list->data = NULL;
+ }
+
+ g_slist_free(request_list);
+ request_list = NULL;
+
+ destroy_tcp_listener(ifdata);
+ destroy_udp_listener(ifdata);
+}
+
+int __connman_dnsproxy_add_listener(int index)
+{
+ struct listener_data *ifdata;
+ int err;
+
+ DBG("index %d", index);
+
+ if (index < 0)
+ return -EINVAL;
+
+ if (!listener_table)
+ return -ENOENT;
+
+ if (g_hash_table_lookup(listener_table, GINT_TO_POINTER(index)))
+ return 0;
+
+ ifdata = g_try_new0(struct listener_data, 1);
+ if (!ifdata)
+ return -ENOMEM;
+
+ ifdata->index = index;
+ ifdata->udp4_listener_channel = NULL;
+ ifdata->udp4_listener_watch = 0;
+ ifdata->tcp4_listener_channel = NULL;
+ ifdata->tcp4_listener_watch = 0;
+ ifdata->udp6_listener_channel = NULL;
+ ifdata->udp6_listener_watch = 0;
+ ifdata->tcp6_listener_channel = NULL;
+ ifdata->tcp6_listener_watch = 0;
+
+ err = create_listener(ifdata);
+ if (err < 0) {
+ connman_error("Couldn't create listener for index %d err %d",
+ index, err);
+ g_free(ifdata);
+ return err;
+ }
+ g_hash_table_insert(listener_table, GINT_TO_POINTER(ifdata->index),
+ ifdata);
+ return 0;
+}
+
+void __connman_dnsproxy_remove_listener(int index)
+{
+ struct listener_data *ifdata;
+
+ DBG("index %d", index);
+
+ if (!listener_table)
+ return;
+
+ ifdata = g_hash_table_lookup(listener_table, GINT_TO_POINTER(index));
+ if (!ifdata)
+ return;
+
+ destroy_listener(ifdata);
+
+ g_hash_table_remove(listener_table, GINT_TO_POINTER(index));
+}
+
+static void remove_listener(gpointer key, gpointer value, gpointer user_data)
+{
+ int index = GPOINTER_TO_INT(key);
+ struct listener_data *ifdata = value;
+
+ DBG("index %d", index);
+
+ destroy_listener(ifdata);
+}
+
+static void free_partial_reqs(gpointer value)
+{
+ struct tcp_partial_client_data *data = value;
+
+ client_reset(data);
+ g_free(data);
+}
+
+int __connman_dnsproxy_init(void)
+{
+ int err, index;
+
+ DBG("");
+
+ listener_table = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, g_free);
+
+ partial_tcp_req_table = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal,
+ NULL,
+ free_partial_reqs);
+
+ index = connman_inet_ifindex("lo");
+ err = __connman_dnsproxy_add_listener(index);
+ if (err < 0)
+ return err;
+
+ err = connman_notifier_register(&dnsproxy_notifier);
+ if (err < 0)
+ goto destroy;
+
+ return 0;
+
+destroy:
+ __connman_dnsproxy_remove_listener(index);
+ g_hash_table_destroy(listener_table);
+ g_hash_table_destroy(partial_tcp_req_table);
+
+ return err;
+}
+
+void __connman_dnsproxy_cleanup(void)
+{
+ DBG("");
+
+ if (cache_timer) {
+ g_source_remove(cache_timer);
+ cache_timer = 0;
+ }
+
+ if (cache) {
+ g_hash_table_destroy(cache);
+ cache = NULL;
+ }
+
+ connman_notifier_unregister(&dnsproxy_notifier);
+
+ g_hash_table_foreach(listener_table, remove_listener, NULL);
+
+ g_hash_table_destroy(listener_table);
+
+ g_hash_table_destroy(partial_tcp_req_table);
+}
diff --git a/src/eduroam.config b/src/eduroam.config
new file mode 100644
index 0000000..768b7b4
--- /dev/null
+++ b/src/eduroam.config
@@ -0,0 +1,5 @@
+[service_eduroam]
+Type = wifi
+Name = eduroam
+EAP = peap
+Phase2 = MSCHAPV2
diff --git a/src/error.c b/src/error.c
new file mode 100644
index 0000000..1d4e430
--- /dev/null
+++ b/src/error.c
@@ -0,0 +1,193 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+DBusMessage *__connman_error_failed(DBusMessage *msg, int errnum)
+{
+ const char *str = strerror(errnum);
+
+ switch (errnum) {
+ case ESRCH:
+ return __connman_error_not_registered(msg);
+ case ENXIO:
+ return __connman_error_not_found(msg);
+ case EACCES:
+ return __connman_error_permission_denied(msg);
+ case EEXIST:
+ return __connman_error_already_exists(msg);
+ case EINVAL:
+ return __connman_error_invalid_arguments(msg);
+ case ENOSYS:
+ return __connman_error_not_implemented(msg);
+ case ENOLINK:
+ return __connman_error_no_carrier(msg);
+ case ENOTUNIQ:
+ return __connman_error_not_unique(msg);
+ case EOPNOTSUPP:
+ return __connman_error_not_supported(msg);
+ case ECONNABORTED:
+ return __connman_error_operation_aborted(msg);
+ case EISCONN:
+ return __connman_error_already_connected(msg);
+ case ENOTCONN:
+ case ECONNREFUSED:
+ return __connman_error_not_connected(msg);
+ case ETIMEDOUT:
+ return __connman_error_operation_timeout(msg);
+ case EALREADY:
+ case EINPROGRESS:
+ return __connman_error_in_progress(msg);
+ case ENOKEY:
+ return __connman_error_passphrase_required(msg);
+ }
+
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".Failed", "%s", str);
+}
+
+DBusMessage *__connman_error_invalid_arguments(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".InvalidArguments", "Invalid arguments");
+}
+
+DBusMessage *__connman_error_permission_denied(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".PermissionDenied", "Permission denied");
+}
+
+DBusMessage *__connman_error_passphrase_required(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".PassphraseRequired", "Passphrase required");
+}
+
+DBusMessage *__connman_error_not_registered(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NotRegistered", "Not registered");
+}
+
+DBusMessage *__connman_error_not_unique(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NotUnique", "Not unique");
+}
+
+DBusMessage *__connman_error_not_supported(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NotSupported", "Not supported");
+}
+
+DBusMessage *__connman_error_not_implemented(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NotImplemented", "Not implemented");
+}
+
+DBusMessage *__connman_error_not_found(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NotFound", "Not found");
+}
+
+DBusMessage *__connman_error_no_carrier(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NoCarrier", "No carrier");
+}
+
+DBusMessage *__connman_error_in_progress(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".InProgress", "In progress");
+}
+
+DBusMessage *__connman_error_already_exists(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".AlreadyExists", "Already exists");
+}
+
+DBusMessage *__connman_error_already_enabled(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".AlreadyEnabled", "Already enabled");
+}
+
+DBusMessage *__connman_error_already_disabled(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".AlreadyDisabled", "Already disabled");
+}
+
+DBusMessage *__connman_error_already_at_order(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".Already at order", "Already at order");
+}
+
+DBusMessage *__connman_error_already_connected(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".AlreadyConnected", "Already connected");
+}
+
+DBusMessage *__connman_error_not_connected(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".NotConnected", "Not connected");
+}
+DBusMessage *__connman_error_operation_aborted(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".OperationAborted", "Operation aborted");
+}
+
+DBusMessage *__connman_error_operation_timeout(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".OperationTimeout", "Operation timeout");
+}
+
+DBusMessage *__connman_error_invalid_service(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".InvalidService", "Invalid service");
+}
+
+DBusMessage *__connman_error_invalid_property(DBusMessage *msg)
+{
+ return g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".InvalidProperty", "Invalid property");
+}
diff --git a/src/firewall.c b/src/firewall.c
new file mode 100644
index 0000000..90c3d3c
--- /dev/null
+++ b/src/firewall.c
@@ -0,0 +1,460 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <xtables.h>
+#include <linux/netfilter_ipv4/ip_tables.h>
+
+#include "connman.h"
+
+#define CHAIN_PREFIX "connman-"
+
+static const char *builtin_chains[] = {
+ [NF_IP_PRE_ROUTING] = "PREROUTING",
+ [NF_IP_LOCAL_IN] = "INPUT",
+ [NF_IP_FORWARD] = "FORWARD",
+ [NF_IP_LOCAL_OUT] = "OUTPUT",
+ [NF_IP_POST_ROUTING] = "POSTROUTING",
+};
+
+struct connman_managed_table {
+ char *name;
+ unsigned int chains[NF_INET_NUMHOOKS];
+};
+
+struct fw_rule {
+ char *table;
+ char *chain;
+ char *rule_spec;
+};
+
+struct firewall_context {
+ GList *rules;
+};
+
+static GSList *managed_tables;
+
+static bool firewall_is_up;
+
+static int chain_to_index(const char *chain_name)
+{
+ if (!g_strcmp0(builtin_chains[NF_IP_PRE_ROUTING], chain_name))
+ return NF_IP_PRE_ROUTING;
+ if (!g_strcmp0(builtin_chains[NF_IP_LOCAL_IN], chain_name))
+ return NF_IP_LOCAL_IN;
+ if (!g_strcmp0(builtin_chains[NF_IP_FORWARD], chain_name))
+ return NF_IP_FORWARD;
+ if (!g_strcmp0(builtin_chains[NF_IP_LOCAL_OUT], chain_name))
+ return NF_IP_LOCAL_OUT;
+ if (!g_strcmp0(builtin_chains[NF_IP_POST_ROUTING], chain_name))
+ return NF_IP_POST_ROUTING;
+
+ return -1;
+}
+
+static int managed_chain_to_index(const char *chain_name)
+{
+ if (!g_str_has_prefix(chain_name, CHAIN_PREFIX))
+ return -1;
+
+ return chain_to_index(chain_name + strlen(CHAIN_PREFIX));
+}
+
+static int insert_managed_chain(const char *table_name, int id)
+{
+ char *rule, *managed_chain;
+ int err;
+
+ managed_chain = g_strdup_printf("%s%s", CHAIN_PREFIX,
+ builtin_chains[id]);
+
+ err = __connman_iptables_new_chain(table_name, managed_chain);
+ if (err < 0)
+ goto out;
+
+ rule = g_strdup_printf("-j %s", managed_chain);
+ err = __connman_iptables_insert(table_name, builtin_chains[id], rule);
+ g_free(rule);
+ if (err < 0) {
+ __connman_iptables_delete_chain(table_name, managed_chain);
+ goto out;
+ }
+
+out:
+ g_free(managed_chain);
+
+ return err;
+}
+
+static int delete_managed_chain(const char *table_name, int id)
+{
+ char *rule, *managed_chain;
+ int err;
+
+ managed_chain = g_strdup_printf("%s%s", CHAIN_PREFIX,
+ builtin_chains[id]);
+
+ rule = g_strdup_printf("-j %s", managed_chain);
+ err = __connman_iptables_delete(table_name, builtin_chains[id], rule);
+ g_free(rule);
+
+ if (err < 0)
+ goto out;
+
+ err = __connman_iptables_delete_chain(table_name, managed_chain);
+
+out:
+ g_free(managed_chain);
+
+ return err;
+}
+
+static int insert_managed_rule(const char *table_name,
+ const char *chain_name,
+ const char *rule_spec)
+{
+ struct connman_managed_table *mtable = NULL;
+ GSList *list;
+ char *chain;
+ int id, err;
+
+ id = chain_to_index(chain_name);
+ if (id < 0) {
+ /* This chain is not managed */
+ chain = g_strdup(chain_name);
+ goto out;
+ }
+
+ for (list = managed_tables; list; list = list->next) {
+ mtable = list->data;
+
+ if (g_strcmp0(mtable->name, table_name) == 0)
+ break;
+
+ mtable = NULL;
+ }
+
+ if (!mtable) {
+ mtable = g_new0(struct connman_managed_table, 1);
+ mtable->name = g_strdup(table_name);
+
+ managed_tables = g_slist_prepend(managed_tables, mtable);
+ }
+
+ if (mtable->chains[id] == 0) {
+ DBG("table %s add managed chain for %s",
+ table_name, chain_name);
+
+ err = insert_managed_chain(table_name, id);
+ if (err < 0)
+ return err;
+ }
+
+ mtable->chains[id]++;
+ chain = g_strdup_printf("%s%s", CHAIN_PREFIX, chain_name);
+
+out:
+ err = __connman_iptables_append(table_name, chain, rule_spec);
+
+ g_free(chain);
+
+ return err;
+ }
+
+static int delete_managed_rule(const char *table_name,
+ const char *chain_name,
+ const char *rule_spec)
+ {
+ struct connman_managed_table *mtable = NULL;
+ GSList *list;
+ int id, err;
+ char *managed_chain;
+
+ id = chain_to_index(chain_name);
+ if (id < 0) {
+ /* This chain is not managed */
+ return __connman_iptables_delete(table_name, chain_name,
+ rule_spec);
+ }
+
+ managed_chain = g_strdup_printf("%s%s", CHAIN_PREFIX, chain_name);
+
+ err = __connman_iptables_delete(table_name, managed_chain,
+ rule_spec);
+
+ for (list = managed_tables; list; list = list->next) {
+ mtable = list->data;
+
+ if (g_strcmp0(mtable->name, table_name) == 0)
+ break;
+
+ mtable = NULL;
+ }
+
+ if (!mtable) {
+ err = -ENOENT;
+ goto out;
+ }
+
+ mtable->chains[id]--;
+ if (mtable->chains[id] > 0)
+ goto out;
+
+ DBG("table %s remove managed chain for %s",
+ table_name, chain_name);
+
+ err = delete_managed_chain(table_name, id);
+
+ out:
+ g_free(managed_chain);
+
+ return err;
+}
+
+static void cleanup_managed_table(gpointer user_data)
+{
+ struct connman_managed_table *table = user_data;
+
+ g_free(table->name);
+ g_free(table);
+}
+
+static void cleanup_fw_rule(gpointer user_data)
+{
+ struct fw_rule *rule = user_data;
+
+ g_free(rule->rule_spec);
+ g_free(rule->chain);
+ g_free(rule->table);
+ g_free(rule);
+}
+
+struct firewall_context *__connman_firewall_create(void)
+{
+ struct firewall_context *ctx;
+
+ ctx = g_new0(struct firewall_context, 1);
+
+ return ctx;
+}
+
+void __connman_firewall_destroy(struct firewall_context *ctx)
+{
+ g_list_free_full(ctx->rules, cleanup_fw_rule);
+ g_free(ctx);
+}
+
+int __connman_firewall_add_rule(struct firewall_context *ctx,
+ const char *table,
+ const char *chain,
+ const char *rule_fmt, ...)
+{
+ va_list args;
+ char *rule_spec;
+ struct fw_rule *rule;
+
+ va_start(args, rule_fmt);
+
+ rule_spec = g_strdup_vprintf(rule_fmt, args);
+
+ va_end(args);
+
+ rule = g_new0(struct fw_rule, 1);
+
+ rule->table = g_strdup(table);
+ rule->chain = g_strdup(chain);
+ rule->rule_spec = rule_spec;
+
+ ctx->rules = g_list_append(ctx->rules, rule);
+
+ return 0;
+}
+
+static int firewall_disable(GList *rules)
+{
+ struct fw_rule *rule;
+ GList *list;
+ int err;
+
+ for (list = rules; list; list = g_list_previous(list)) {
+ rule = list->data;
+
+ err = delete_managed_rule(rule->table,
+ rule->chain, rule->rule_spec);
+ if (err < 0) {
+ connman_error("Cannot remove previously installed "
+ "iptables rules: %s", strerror(-err));
+ return err;
+ }
+
+ err = __connman_iptables_commit(rule->table);
+ if (err < 0) {
+ connman_error("Cannot remove previously installed "
+ "iptables rules: %s", strerror(-err));
+ return err;
+ }
+ }
+
+ return 0;
+}
+
+int __connman_firewall_enable(struct firewall_context *ctx)
+{
+ struct fw_rule *rule;
+ GList *list;
+ int err;
+
+ for (list = g_list_first(ctx->rules); list;
+ list = g_list_next(list)) {
+ rule = list->data;
+
+ DBG("%s %s %s", rule->table, rule->chain, rule->rule_spec);
+
+ err = insert_managed_rule(rule->table,
+ rule->chain, rule->rule_spec);
+ if (err < 0)
+ goto err;
+
+ err = __connman_iptables_commit(rule->table);
+ if (err < 0)
+ goto err;
+ }
+
+ firewall_is_up = true;
+
+ return 0;
+
+err:
+ connman_warn("Failed to install iptables rules: %s", strerror(-err));
+
+ firewall_disable(g_list_previous(list));
+
+ return err;
+}
+
+int __connman_firewall_disable(struct firewall_context *ctx)
+{
+ return firewall_disable(g_list_last(ctx->rules));
+}
+
+bool __connman_firewall_is_up(void)
+{
+ return firewall_is_up;
+}
+
+static void iterate_chains_cb(const char *chain_name, void *user_data)
+{
+ GSList **chains = user_data;
+ int id;
+
+ id = managed_chain_to_index(chain_name);
+ if (id < 0)
+ return;
+
+ *chains = g_slist_prepend(*chains, GINT_TO_POINTER(id));
+}
+
+static void flush_table(const char *table_name)
+{
+ GSList *chains = NULL, *list;
+ char *rule, *managed_chain;
+ int id, err;
+
+ __connman_iptables_iterate_chains(table_name, iterate_chains_cb,
+ &chains);
+
+ for (list = chains; list; list = list->next) {
+ id = GPOINTER_TO_INT(list->data);
+
+ managed_chain = g_strdup_printf("%s%s", CHAIN_PREFIX,
+ builtin_chains[id]);
+
+ rule = g_strdup_printf("-j %s", managed_chain);
+ err = __connman_iptables_delete(table_name,
+ builtin_chains[id], rule);
+ if (err < 0) {
+ connman_warn("Failed to delete jump rule '%s': %s",
+ rule, strerror(-err));
+ }
+ g_free(rule);
+
+ err = __connman_iptables_flush_chain(table_name, managed_chain);
+ if (err < 0) {
+ connman_warn("Failed to flush chain '%s': %s",
+ managed_chain, strerror(-err));
+ }
+ err = __connman_iptables_delete_chain(table_name, managed_chain);
+ if (err < 0) {
+ connman_warn("Failed to delete chain '%s': %s",
+ managed_chain, strerror(-err));
+ }
+
+ g_free(managed_chain);
+ }
+
+ err = __connman_iptables_commit(table_name);
+ if (err < 0) {
+ connman_warn("Failed to flush table '%s': %s",
+ table_name, strerror(-err));
+ }
+
+ g_slist_free(chains);
+}
+
+static void flush_all_tables(void)
+{
+ /* Flush the tables ConnMan might have modified
+ * But do so if only ConnMan has done something with
+ * iptables */
+
+ if (!g_file_test("/proc/net/ip_tables_names",
+ G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR)) {
+ firewall_is_up = false;
+ return;
+ }
+
+ firewall_is_up = true;
+
+ flush_table("filter");
+ flush_table("mangle");
+ flush_table("nat");
+}
+
+int __connman_firewall_init(void)
+{
+ DBG("");
+
+ flush_all_tables();
+
+ return 0;
+}
+
+void __connman_firewall_cleanup(void)
+{
+ DBG("");
+
+ g_slist_free_full(managed_tables, cleanup_managed_table);
+}
diff --git a/src/genbuiltin b/src/genbuiltin
new file mode 100755
index 0000000..3e1bb0c
--- /dev/null
+++ b/src/genbuiltin
@@ -0,0 +1,17 @@
+#!/bin/sh
+
+for i in $*
+do
+ echo "extern struct connman_plugin_desc __connman_builtin_$i;"
+done
+
+echo
+echo "static struct connman_plugin_desc *__connman_builtin[] = {"
+
+for i in $*
+do
+ echo " &__connman_builtin_$i,"
+done
+
+echo " NULL"
+echo "};"
diff --git a/src/inet.c b/src/inet.c
new file mode 100644
index 0000000..e06d9c8
--- /dev/null
+++ b/src/inet.c
@@ -0,0 +1,2961 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ * Copyright (C) 2003-2005 Go-Core Project
+ * Copyright (C) 2003-2006 Helsinki University of Technology
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <linux/sockios.h>
+#include <netdb.h>
+#include <arpa/inet.h>
+#include <net/route.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <netinet/icmp6.h>
+#include <fcntl.h>
+#include <linux/if_tun.h>
+#include <ctype.h>
+#include <ifaddrs.h>
+#include <linux/fib_rules.h>
+
+#include "connman.h"
+#include <gdhcp/gdhcp.h>
+
+#define NLMSG_TAIL(nmsg) \
+ ((struct rtattr *) (((uint8_t*) (nmsg)) + \
+ NLMSG_ALIGN((nmsg)->nlmsg_len)))
+
+int __connman_inet_rtnl_addattr_l(struct nlmsghdr *n, size_t max_length,
+ int type, const void *data, size_t data_length)
+{
+ size_t length;
+ struct rtattr *rta;
+
+ length = RTA_LENGTH(data_length);
+
+ if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length) > max_length)
+ return -E2BIG;
+
+ rta = NLMSG_TAIL(n);
+ rta->rta_type = type;
+ rta->rta_len = length;
+ memcpy(RTA_DATA(rta), data, data_length);
+ n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length);
+
+ return 0;
+}
+
+int __connman_inet_modify_address(int cmd, int flags,
+ int index, int family,
+ const char *address,
+ const char *peer,
+ unsigned char prefixlen,
+ const char *broadcast)
+{
+ uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
+ NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
+ RTA_LENGTH(sizeof(struct in6_addr)) +
+ RTA_LENGTH(sizeof(struct in6_addr))];
+
+ struct nlmsghdr *header;
+ struct sockaddr_nl nl_addr;
+ struct ifaddrmsg *ifaddrmsg;
+ struct in6_addr ipv6_addr;
+ struct in_addr ipv4_addr, ipv4_dest, ipv4_bcast;
+ int sk, err;
+
+ DBG("cmd %#x flags %#x index %d family %d address %s peer %s "
+ "prefixlen %hhu broadcast %s", cmd, flags, index, family,
+ address, peer, prefixlen, broadcast);
+
+ if (!address)
+ return -EINVAL;
+
+ if (family != AF_INET && family != AF_INET6)
+ return -EINVAL;
+
+ memset(&request, 0, sizeof(request));
+
+ header = (struct nlmsghdr *)request;
+ header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
+ header->nlmsg_type = cmd;
+ header->nlmsg_flags = NLM_F_REQUEST | flags;
+ header->nlmsg_seq = 1;
+
+ ifaddrmsg = NLMSG_DATA(header);
+ ifaddrmsg->ifa_family = family;
+ ifaddrmsg->ifa_prefixlen = prefixlen;
+ ifaddrmsg->ifa_flags = IFA_F_PERMANENT;
+ ifaddrmsg->ifa_scope = RT_SCOPE_UNIVERSE;
+ ifaddrmsg->ifa_index = index;
+
+ if (family == AF_INET) {
+ if (inet_pton(AF_INET, address, &ipv4_addr) < 1)
+ return -1;
+
+ if (broadcast)
+ inet_pton(AF_INET, broadcast, &ipv4_bcast);
+ else
+ ipv4_bcast.s_addr = ipv4_addr.s_addr |
+ htonl(0xfffffffflu >> prefixlen);
+
+ if (peer) {
+ if (inet_pton(AF_INET, peer, &ipv4_dest) < 1)
+ return -1;
+
+ err = __connman_inet_rtnl_addattr_l(header,
+ sizeof(request),
+ IFA_ADDRESS,
+ &ipv4_dest,
+ sizeof(ipv4_dest));
+ if (err < 0)
+ return err;
+ }
+
+ err = __connman_inet_rtnl_addattr_l(header,
+ sizeof(request),
+ IFA_LOCAL,
+ &ipv4_addr,
+ sizeof(ipv4_addr));
+ if (err < 0)
+ return err;
+
+ err = __connman_inet_rtnl_addattr_l(header,
+ sizeof(request),
+ IFA_BROADCAST,
+ &ipv4_bcast,
+ sizeof(ipv4_bcast));
+ if (err < 0)
+ return err;
+
+ } else if (family == AF_INET6) {
+ if (inet_pton(AF_INET6, address, &ipv6_addr) < 1)
+ return -1;
+
+ err = __connman_inet_rtnl_addattr_l(header,
+ sizeof(request),
+ IFA_LOCAL,
+ &ipv6_addr,
+ sizeof(ipv6_addr));
+ if (err < 0)
+ return err;
+ }
+
+ sk = socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
+ if (sk < 0)
+ return -errno;
+
+ memset(&nl_addr, 0, sizeof(nl_addr));
+ nl_addr.nl_family = AF_NETLINK;
+
+ if ((err = sendto(sk, request, header->nlmsg_len, 0,
+ (struct sockaddr *) &nl_addr, sizeof(nl_addr))) < 0)
+ goto done;
+
+ err = 0;
+
+done:
+ close(sk);
+
+ return err;
+}
+
+int connman_inet_ifindex(const char *name)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ if (!name)
+ return -1;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -1;
+
+ memset(&ifr, 0, sizeof(ifr));
+ strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name) - 1);
+
+ err = ioctl(sk, SIOCGIFINDEX, &ifr);
+
+ close(sk);
+
+ if (err < 0)
+ return -1;
+
+ return ifr.ifr_ifindex;
+}
+
+char *connman_inet_ifname(int index)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ if (index < 0)
+ return NULL;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return NULL;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+
+ close(sk);
+
+ if (err < 0)
+ return NULL;
+
+ return g_strdup(ifr.ifr_name);
+}
+
+int connman_inet_ifup(int index)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -errno;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ if (ifr.ifr_flags & IFF_UP) {
+ err = -EALREADY;
+ goto done;
+ }
+
+ ifr.ifr_flags |= (IFF_UP|IFF_DYNAMIC);
+
+ if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ err = 0;
+
+done:
+ close(sk);
+
+ return err;
+}
+
+int connman_inet_ifdown(int index)
+{
+ struct ifreq ifr, addr_ifr;
+ struct sockaddr_in *addr;
+ int sk, err;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -errno;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ memset(&addr_ifr, 0, sizeof(addr_ifr));
+ memcpy(&addr_ifr.ifr_name, &ifr.ifr_name, sizeof(ifr.ifr_name) - 1);
+ addr = (struct sockaddr_in *)&addr_ifr.ifr_addr;
+ addr->sin_family = AF_INET;
+ if (ioctl(sk, SIOCSIFADDR, &addr_ifr) < 0)
+ connman_warn("Could not clear IPv4 address index %d", index);
+
+ if (!(ifr.ifr_flags & IFF_UP)) {
+ err = -EALREADY;
+ goto done;
+ }
+
+ ifr.ifr_flags = (ifr.ifr_flags & ~IFF_UP) | IFF_DYNAMIC;
+
+ if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
+ err = -errno;
+ else
+ err = 0;
+
+done:
+ close(sk);
+
+ return err;
+}
+
+struct in6_ifreq {
+ struct in6_addr ifr6_addr;
+ __u32 ifr6_prefixlen;
+ unsigned int ifr6_ifindex;
+};
+
+int connman_inet_set_ipv6_address(int index,
+ struct connman_ipaddress *ipaddress)
+{
+ int err;
+ unsigned char prefix_len;
+ const char *address;
+
+ if (!ipaddress->local)
+ return 0;
+
+ prefix_len = ipaddress->prefixlen;
+ address = ipaddress->local;
+
+ DBG("index %d address %s prefix_len %d", index, address, prefix_len);
+
+ err = __connman_inet_modify_address(RTM_NEWADDR,
+ NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
+ address, NULL, prefix_len, NULL);
+ if (err < 0) {
+ connman_error("%s: %s", __func__, strerror(-err));
+ return err;
+ }
+
+ return 0;
+}
+
+int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
+{
+ int err;
+ unsigned char prefix_len;
+ const char *address, *broadcast, *peer;
+
+ if (!ipaddress->local)
+ return -1;
+
+ prefix_len = ipaddress->prefixlen;
+ address = ipaddress->local;
+ broadcast = ipaddress->broadcast;
+ peer = ipaddress->peer;
+
+ DBG("index %d address %s prefix_len %d", index, address, prefix_len);
+
+ err = __connman_inet_modify_address(RTM_NEWADDR,
+ NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
+ address, peer, prefix_len, broadcast);
+ if (err < 0) {
+ connman_error("%s: %s", __func__, strerror(-err));
+ return err;
+ }
+
+ return 0;
+}
+
+int connman_inet_clear_ipv6_address(int index, const char *address,
+ int prefix_len)
+{
+ int err;
+
+ DBG("index %d address %s prefix_len %d", index, address, prefix_len);
+
+ if (!address)
+ return -EINVAL;
+
+ err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
+ address, NULL, prefix_len, NULL);
+ if (err < 0) {
+ connman_error("%s: %s", __func__, strerror(-err));
+ return err;
+ }
+
+ return 0;
+}
+
+int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
+{
+ int err;
+ unsigned char prefix_len;
+ const char *address, *broadcast, *peer;
+
+ prefix_len = ipaddress->prefixlen;
+ address = ipaddress->local;
+ broadcast = ipaddress->broadcast;
+ peer = ipaddress->peer;
+
+ DBG("index %d address %s prefix_len %d peer %s broadcast %s", index,
+ address, prefix_len, peer, broadcast);
+
+ if (!address)
+ return -EINVAL;
+
+ err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
+ address, peer, prefix_len, broadcast);
+ if (err < 0) {
+ connman_error("%s: %s", __func__, strerror(-err));
+ return err;
+ }
+
+ return 0;
+}
+
+int connman_inet_add_host_route(int index, const char *host,
+ const char *gateway)
+{
+ return connman_inet_add_network_route(index, host, gateway, NULL);
+}
+
+int connman_inet_del_host_route(int index, const char *host)
+{
+ return connman_inet_del_network_route(index, host);
+}
+
+int connman_inet_add_network_route(int index, const char *host,
+ const char *gateway,
+ const char *netmask)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in addr;
+ int sk, err = 0;
+
+ DBG("index %d host %s gateway %s netmask %s", index,
+ host, gateway, netmask);
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP;
+ if (gateway)
+ rt.rt_flags |= RTF_GATEWAY;
+ if (!netmask)
+ rt.rt_flags |= RTF_HOST;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr(host);
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ if (gateway)
+ addr.sin_addr.s_addr = inet_addr(gateway);
+ else
+ addr.sin_addr.s_addr = INADDR_ANY;
+ memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = INADDR_ANY;
+ if (netmask)
+ addr.sin_addr.s_addr = inet_addr(netmask);
+ else
+ addr.sin_addr.s_addr = INADDR_ANY;
+ memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+
+ rt.rt_dev = ifr.ifr_name;
+
+ if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Adding host route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_del_network_route(int index, const char *host)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in addr;
+ int sk, err = 0;
+
+ DBG("index %d host %s", index, host);
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP | RTF_HOST;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr(host);
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+
+ rt.rt_dev = ifr.ifr_name;
+
+ if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Deleting host route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_del_ipv6_network_route(int index, const char *host,
+ unsigned char prefix_len)
+{
+ struct in6_rtmsg rt;
+ int sk, err = 0;
+
+ DBG("index %d host %s", index, host);
+
+ if (!host)
+ return -EINVAL;
+
+ memset(&rt, 0, sizeof(rt));
+
+ rt.rtmsg_dst_len = prefix_len;
+
+ if (inet_pton(AF_INET6, host, &rt.rtmsg_dst) < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ rt.rtmsg_flags = RTF_UP | RTF_HOST;
+
+ rt.rtmsg_metric = 1;
+ rt.rtmsg_ifindex = index;
+
+ sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Del IPv6 host route error (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_del_ipv6_host_route(int index, const char *host)
+{
+ return connman_inet_del_ipv6_network_route(index, host, 128);
+}
+
+int connman_inet_add_ipv6_network_route(int index, const char *host,
+ const char *gateway,
+ unsigned char prefix_len)
+{
+ struct in6_rtmsg rt;
+ int sk, err = 0;
+
+ DBG("index %d host %s gateway %s", index, host, gateway);
+
+ if (!host)
+ return -EINVAL;
+
+ memset(&rt, 0, sizeof(rt));
+
+ rt.rtmsg_dst_len = prefix_len;
+
+ if (inet_pton(AF_INET6, host, &rt.rtmsg_dst) < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ rt.rtmsg_flags = RTF_UP | RTF_HOST;
+
+ if (gateway) {
+ rt.rtmsg_flags |= RTF_GATEWAY;
+ inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
+ }
+
+ rt.rtmsg_metric = 1;
+ rt.rtmsg_ifindex = index;
+
+ sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Set IPv6 host route error (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_add_ipv6_host_route(int index, const char *host,
+ const char *gateway)
+{
+ return connman_inet_add_ipv6_network_route(index, host, gateway, 128);
+}
+
+int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
+{
+ struct in6_rtmsg rt;
+ int sk, err = 0;
+
+ DBG("index %d gateway %s", index, gateway);
+
+ if (!gateway)
+ return -EINVAL;
+
+ memset(&rt, 0, sizeof(rt));
+
+ if (inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway) < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
+ rt.rtmsg_metric = 1;
+ rt.rtmsg_dst_len = 0;
+ rt.rtmsg_ifindex = index;
+
+ sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Clear default IPv6 gateway error (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_set_gateway_interface(int index)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in addr;
+ int sk, err = 0;
+
+ DBG("index %d", index);
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = INADDR_ANY;
+
+ memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+ memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+
+ rt.rt_dev = ifr.ifr_name;
+
+ if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Setting default interface route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_set_ipv6_gateway_interface(int index)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in6 addr;
+ const struct in6_addr any = IN6ADDR_ANY_INIT;
+ int sk, err = 0;
+
+ DBG("index %d", index);
+
+ sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ addr.sin6_addr = any;
+
+ memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+ memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+
+ rt.rt_dev = ifr.ifr_name;
+
+ if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Setting default interface route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_clear_gateway_address(int index, const char *gateway)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in addr;
+ int sk, err = 0;
+
+ DBG("index %d gateway %s", index, gateway);
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP | RTF_GATEWAY;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = INADDR_ANY;
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = inet_addr(gateway);
+ memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = INADDR_ANY;
+ memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+
+ if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Removing default gateway route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_clear_gateway_interface(int index)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in addr;
+ int sk, err = 0;
+
+ DBG("index %d", index);
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin_family = AF_INET;
+ addr.sin_addr.s_addr = INADDR_ANY;
+
+ memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+ memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+
+ rt.rt_dev = ifr.ifr_name;
+
+ if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Removing default interface route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_clear_ipv6_gateway_interface(int index)
+{
+ struct ifreq ifr;
+ struct rtentry rt;
+ struct sockaddr_in6 addr;
+ const struct in6_addr any = IN6ADDR_ANY_INIT;
+ int sk, err = 0;
+
+ DBG("index %d", index);
+
+ sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ err = -errno;
+ close(sk);
+ goto out;
+ }
+
+ DBG("ifname %s", ifr.ifr_name);
+
+ memset(&rt, 0, sizeof(rt));
+ rt.rt_flags = RTF_UP;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ addr.sin6_addr = any;
+
+ memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
+ memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
+ memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
+
+ rt.rt_dev = ifr.ifr_name;
+
+ if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Removing default interface route failed (%s)",
+ strerror(-err));
+
+ return err;
+}
+
+bool connman_inet_compare_subnet(int index, const char *host)
+{
+ struct ifreq ifr;
+ struct in_addr _host_addr;
+ in_addr_t host_addr, netmask_addr, if_addr;
+ struct sockaddr_in *netmask, *addr;
+ int sk;
+
+ DBG("host %s", host);
+
+ if (!host)
+ return false;
+
+ if (inet_aton(host, &_host_addr) == 0)
+ return -1;
+ host_addr = _host_addr.s_addr;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return false;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ close(sk);
+ return false;
+ }
+
+ if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
+ close(sk);
+ return false;
+ }
+
+ netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
+ netmask_addr = netmask->sin_addr.s_addr;
+
+ if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
+ close(sk);
+ return false;
+ }
+
+ close(sk);
+
+ addr = (struct sockaddr_in *)&ifr.ifr_addr;
+ if_addr = addr->sin_addr.s_addr;
+
+ return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
+}
+
+int connman_inet_remove_from_bridge(int index, const char *bridge)
+{
+ struct ifreq ifr;
+ int sk, err = 0;
+
+ if (!bridge)
+ return -EINVAL;
+
+ sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ strncpy(ifr.ifr_name, bridge, sizeof(ifr.ifr_name) - 1);
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCBRDELIF, &ifr) < 0)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Remove interface from bridge error %s",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_add_to_bridge(int index, const char *bridge)
+{
+ struct ifreq ifr;
+ int sk, err = 0;
+
+ if (!bridge)
+ return -EINVAL;
+
+ sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
+ if (sk < 0) {
+ err = -errno;
+ goto out;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ strncpy(ifr.ifr_name, bridge, sizeof(ifr.ifr_name) - 1);
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCBRADDIF, &ifr) < 0)
+ err = -errno;
+
+ close(sk);
+
+out:
+ if (err < 0)
+ connman_error("Add interface to bridge error %s",
+ strerror(-err));
+
+ return err;
+}
+
+int connman_inet_set_mtu(int index, int mtu)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return sk;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ err = ioctl(sk, SIOCGIFNAME, &ifr);
+ if (err == 0) {
+ ifr.ifr_mtu = mtu;
+ err = ioctl(sk, SIOCSIFMTU, &ifr);
+ }
+
+ close(sk);
+ return err;
+}
+
+int connman_inet_setup_tunnel(char *tunnel, int mtu)
+{
+ struct ifreq ifr;
+ int sk, err, index;
+ __u32 mask;
+ __u32 flags;
+
+ if (!tunnel)
+ return -EINVAL;
+
+ sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return sk;
+
+ index = if_nametoindex(tunnel);
+
+ err = connman_inet_set_mtu(index, mtu);
+ if (err != 0)
+ goto done;
+
+ memset(&ifr, 0, sizeof(ifr));
+ strncpy(ifr.ifr_name, tunnel, sizeof(ifr.ifr_name) - 1);
+ err = ioctl(sk, SIOCGIFFLAGS, &ifr);
+ if (err)
+ goto done;
+
+ mask = IFF_UP;
+ flags = IFF_UP;
+
+ if ((ifr.ifr_flags ^ flags) & mask) {
+ ifr.ifr_flags &= ~mask;
+ ifr.ifr_flags |= mask & flags;
+ err = ioctl(sk, SIOCSIFFLAGS, &ifr);
+ if (err)
+ connman_error("SIOCSIFFLAGS failed: %s",
+ strerror(errno));
+ }
+
+done:
+ close(sk);
+ return err;
+}
+
+int connman_inet_create_tunnel(char **iface)
+{
+ struct ifreq ifr;
+ int i, fd;
+
+ fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
+ if (fd < 0) {
+ i = -errno;
+ connman_error("Failed to open /dev/net/tun: %s",
+ strerror(errno));
+ return i;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
+
+ for (i = 0; i < 256; i++) {
+ sprintf(ifr.ifr_name, "tun%d", i);
+
+ if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
+ break;
+ }
+
+ if (i == 256) {
+ connman_error("Failed to find available tun device");
+ close(fd);
+ return -ENODEV;
+ }
+
+ *iface = g_strdup(ifr.ifr_name);
+
+ return fd;
+}
+
+/*
+ * This callback struct is used when sending router and neighbor
+ * solicitation and advertisement messages.
+ */
+struct xs_cb_data {
+ GIOChannel *channel;
+ void *callback;
+ struct sockaddr_in6 addr;
+ guint timeout;
+ guint watch_id;
+ void *user_data;
+};
+
+#define CMSG_BUF_LEN 512
+#define IN6ADDR_ALL_NODES_MC_INIT \
+ { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x1 } } } /* ff02::1 */
+#define IN6ADDR_ALL_ROUTERS_MC_INIT \
+ { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x2 } } } /* ff02::2 */
+
+static const struct in6_addr in6addr_all_nodes_mc = IN6ADDR_ALL_NODES_MC_INIT;
+static const struct in6_addr in6addr_all_routers_mc =
+ IN6ADDR_ALL_ROUTERS_MC_INIT;
+
+static void xs_cleanup(struct xs_cb_data *data)
+{
+ if (data->channel) {
+ g_io_channel_shutdown(data->channel, TRUE, NULL);
+ g_io_channel_unref(data->channel);
+ data->channel = NULL;
+ }
+
+ if (data->timeout > 0)
+ g_source_remove(data->timeout);
+
+ if (data->watch_id > 0)
+ g_source_remove(data->watch_id);
+
+ g_free(data);
+}
+
+static gboolean rs_timeout_cb(gpointer user_data)
+{
+ struct xs_cb_data *data = user_data;
+
+ DBG("user data %p", user_data);
+
+ if (!data)
+ return FALSE;
+
+ if (data->callback) {
+ __connman_inet_rs_cb_t cb = data->callback;
+ cb(NULL, 0, data->user_data);
+ }
+
+ data->timeout = 0;
+ xs_cleanup(data);
+ return FALSE;
+}
+
+static int icmpv6_recv(int fd, gpointer user_data)
+{
+ struct msghdr mhdr;
+ struct iovec iov;
+ unsigned char chdr[CMSG_BUF_LEN];
+ unsigned char buf[1540];
+ struct xs_cb_data *data = user_data;
+ struct nd_router_advert *hdr;
+ struct sockaddr_in6 saddr;
+ ssize_t len;
+ __connman_inet_rs_cb_t cb = data->callback;
+
+ DBG("");
+
+ iov.iov_len = sizeof(buf);
+ iov.iov_base = buf;
+
+ mhdr.msg_name = (void *)&saddr;
+ mhdr.msg_namelen = sizeof(struct sockaddr_in6);
+ mhdr.msg_flags = 0;
+ mhdr.msg_iov = &iov;
+ mhdr.msg_iovlen = 1;
+ mhdr.msg_control = (void *)chdr;
+ mhdr.msg_controllen = CMSG_BUF_LEN;
+
+ len = recvmsg(fd, &mhdr, 0);
+ if (len < 0) {
+ cb(NULL, 0, data->user_data);
+ xs_cleanup(data);
+ return -errno;
+ }
+
+ hdr = (struct nd_router_advert *)buf;
+ DBG("code %d len %zd hdr %zd", hdr->nd_ra_code, len,
+ sizeof(struct nd_router_advert));
+ if (hdr->nd_ra_code != 0)
+ return 0;
+
+ cb(hdr, len, data->user_data);
+ xs_cleanup(data);
+
+ return len;
+}
+
+static gboolean icmpv6_event(GIOChannel *chan, GIOCondition cond, gpointer data)
+{
+ int fd, ret;
+
+ DBG("");
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ fd = g_io_channel_unix_get_fd(chan);
+ ret = icmpv6_recv(fd, data);
+ if (ret == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+/* Adapted from RFC 1071 "C" Implementation Example */
+static uint16_t csum(const void *phdr, const void *data, socklen_t datalen,
+ const void *extra_data, socklen_t extra_datalen)
+{
+ register unsigned long sum = 0;
+ socklen_t count;
+ uint16_t *addr;
+ int i;
+
+ /* caller must make sure datalen is even */
+
+ addr = (uint16_t *)phdr;
+ for (i = 0; i < 20; i++)
+ sum += *addr++;
+
+ count = datalen;
+ addr = (uint16_t *)data;
+
+ while (count > 1) {
+ sum += *(addr++);
+ count -= 2;
+ }
+
+ if (extra_data) {
+ count = extra_datalen;
+ addr = (uint16_t *)extra_data;
+
+ while (count > 1) {
+ sum += *(addr++);
+ count -= 2;
+ }
+ }
+
+ while (sum >> 16)
+ sum = (sum & 0xffff) + (sum >> 16);
+
+ return (uint16_t)~sum;
+}
+
+static int ndisc_send_unspec(int type, int oif, const struct in6_addr *dest,
+ const struct in6_addr *source,
+ unsigned char *buf, size_t len, uint16_t lifetime)
+{
+ struct _phdr {
+ struct in6_addr src;
+ struct in6_addr dst;
+ uint32_t plen;
+ uint8_t reserved[3];
+ uint8_t nxt;
+ } phdr;
+
+ struct {
+ struct ip6_hdr ip;
+ union {
+ struct icmp6_hdr icmp;
+ struct nd_neighbor_solicit ns;
+ struct nd_router_solicit rs;
+ struct nd_router_advert ra;
+ } i;
+ } frame;
+
+ struct msghdr msgh;
+ struct cmsghdr *cmsg;
+ struct in6_pktinfo *pinfo;
+ struct sockaddr_in6 dst, src;
+ char cbuf[CMSG_SPACE(sizeof(*pinfo))];
+ struct iovec iov[2];
+ int fd, datalen, ret, iovlen = 1;
+
+ DBG("");
+
+ fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
+ if (fd < 0)
+ return -errno;
+
+ memset(&frame, 0, sizeof(frame));
+ memset(&dst, 0, sizeof(dst));
+
+ if (type == ND_ROUTER_SOLICIT)
+ datalen = sizeof(frame.i.rs); /* 8, csum() safe */
+ else if (type == ND_ROUTER_ADVERT) {
+ datalen = sizeof(frame.i.ra); /* 16, csum() safe */
+ frame.i.ra.nd_ra_router_lifetime = htons(lifetime);
+ } else if (type == ND_NEIGHBOR_SOLICIT) {
+ datalen = sizeof(frame.i.ns); /* 24, csum() safe */
+ memcpy(&frame.i.ns.nd_ns_target, buf, sizeof(struct in6_addr));
+ } else {
+ close(fd);
+ return -EINVAL;
+ }
+
+ dst.sin6_addr = *dest;
+
+ if (source)
+ src.sin6_addr = *source;
+ else
+ src.sin6_addr = in6addr_any;
+
+ /* Fill in the IPv6 header */
+ frame.ip.ip6_vfc = 0x60;
+ frame.ip.ip6_plen = htons(datalen + len);
+ frame.ip.ip6_nxt = IPPROTO_ICMPV6;
+ frame.ip.ip6_hlim = 255;
+ frame.ip.ip6_dst = dst.sin6_addr;
+ frame.ip.ip6_src = src.sin6_addr;
+ /* all other fields are already set to zero */
+
+ /* Prepare pseudo header for csum */
+ memset(&phdr, 0, sizeof(phdr));
+ phdr.dst = dst.sin6_addr;
+ phdr.src = src.sin6_addr;
+ phdr.plen = htonl(datalen + len);
+ phdr.nxt = IPPROTO_ICMPV6;
+
+ /* Fill in remaining ICMP header fields */
+ frame.i.icmp.icmp6_type = type;
+ frame.i.icmp.icmp6_cksum = csum(&phdr, &frame.i, datalen, buf, len);
+
+ iov[0].iov_base = &frame;
+ iov[0].iov_len = sizeof(frame.ip) + datalen;
+
+ if (buf) {
+ iov[1].iov_base = buf;
+ iov[1].iov_len = len;
+ iovlen = 2;
+ }
+
+ dst.sin6_family = AF_INET6;
+ msgh.msg_name = &dst;
+ msgh.msg_namelen = sizeof(dst);
+ msgh.msg_iov = iov;
+ msgh.msg_iovlen = iovlen;
+ msgh.msg_flags = 0;
+
+ memset(cbuf, 0, CMSG_SPACE(sizeof(*pinfo)));
+ cmsg = (struct cmsghdr *)cbuf;
+ pinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
+ pinfo->ipi6_ifindex = oif;
+
+ cmsg->cmsg_len = CMSG_LEN(sizeof(*pinfo));
+ cmsg->cmsg_level = IPPROTO_IPV6;
+ cmsg->cmsg_type = IPV6_PKTINFO;
+ msgh.msg_control = cmsg;
+ msgh.msg_controllen = cmsg->cmsg_len;
+
+ ret = sendmsg(fd, &msgh, 0);
+
+ close(fd);
+ return ret;
+}
+
+static inline void ipv6_addr_set(struct in6_addr *addr,
+ uint32_t w1, uint32_t w2,
+ uint32_t w3, uint32_t w4)
+{
+ addr->s6_addr32[0] = w1;
+ addr->s6_addr32[1] = w2;
+ addr->s6_addr32[2] = w3;
+ addr->s6_addr32[3] = w4;
+}
+
+static inline void ipv6_addr_solict_mult(const struct in6_addr *addr,
+ struct in6_addr *solicited)
+{
+ ipv6_addr_set(solicited, htonl(0xFF020000), 0, htonl(0x1),
+ htonl(0xFF000000) | addr->s6_addr32[3]);
+}
+
+static int if_mc_group(int sock, int ifindex, const struct in6_addr *mc_addr,
+ int cmd)
+{
+ unsigned int val = 0;
+ struct ipv6_mreq mreq;
+ int ret;
+
+ memset(&mreq, 0, sizeof(mreq));
+ mreq.ipv6mr_interface = ifindex;
+ mreq.ipv6mr_multiaddr = *mc_addr;
+
+ ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
+ &val, sizeof(int));
+ if (ret < 0) {
+ ret = -errno;
+ DBG("Cannot set IPV6_MULTICAST_LOOP %d/%s", ret,
+ strerror(-ret));
+ return ret;
+ }
+
+ ret = setsockopt(sock, IPPROTO_IPV6, cmd, &mreq, sizeof(mreq));
+ if (ret < 0) {
+ ret = -errno;
+ DBG("Cannot set option %d %d/%s", cmd, ret, strerror(-ret));
+ return ret;
+ }
+
+ return 0;
+}
+
+int __connman_inet_ipv6_send_rs(int index, int timeout,
+ __connman_inet_rs_cb_t callback, void *user_data)
+{
+ struct xs_cb_data *data;
+ struct icmp6_filter filter;
+ struct in6_addr solicit;
+ struct in6_addr dst = in6addr_all_routers_mc;
+ int sk;
+
+ if (timeout <= 0)
+ return -EINVAL;
+
+ data = g_try_malloc0(sizeof(struct xs_cb_data));
+ if (!data)
+ return -ENOMEM;
+
+ data->callback = callback;
+ data->user_data = user_data;
+ data->timeout = g_timeout_add_seconds(timeout, rs_timeout_cb, data);
+
+ sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
+ if (sk < 0)
+ return -errno;
+
+ DBG("sock %d", sk);
+
+ ICMP6_FILTER_SETBLOCKALL(&filter);
+ ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
+
+ setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
+ sizeof(struct icmp6_filter));
+
+ ipv6_addr_solict_mult(&dst, &solicit);
+ if_mc_group(sk, index, &in6addr_all_nodes_mc, IPV6_JOIN_GROUP);
+ if_mc_group(sk, index, &solicit, IPV6_JOIN_GROUP);
+
+ data->channel = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(data->channel, TRUE);
+
+ g_io_channel_set_encoding(data->channel, NULL, NULL);
+ g_io_channel_set_buffered(data->channel, FALSE);
+
+ data->watch_id = g_io_add_watch(data->channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ icmpv6_event, data);
+
+ ndisc_send_unspec(ND_ROUTER_SOLICIT, index, &dst, NULL, NULL, 0, 0);
+
+ return 0;
+}
+
+static inline void ipv6_addr_advert_mult(const struct in6_addr *addr,
+ struct in6_addr *advert)
+{
+ ipv6_addr_set(advert, htonl(0xFF020000), 0, htonl(0x2),
+ htonl(0xFF000000) | addr->s6_addr32[3]);
+}
+
+#define MSG_SIZE_SEND 1452
+
+static int inc_len(int len, int inc)
+{
+ if (len > MSG_SIZE_SEND)
+ return -EINVAL;
+
+ len += inc;
+ return len;
+}
+
+int __connman_inet_ipv6_send_ra(int index, struct in6_addr *src_addr,
+ GSList *prefixes, int router_lifetime)
+{
+ GSList *list;
+ struct in6_addr src, *source;
+ struct in6_addr dst = in6addr_all_nodes_mc;
+ GDHCPIAPrefix *prefix;
+ unsigned char buf[MSG_SIZE_SEND];
+ char addr_str[INET6_ADDRSTRLEN];
+ int sk, err = 0;
+ int len, count = 0;
+
+ if (!prefixes)
+ return -EINVAL;
+
+ sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
+ if (sk < 0)
+ return -errno;
+
+ if (!src_addr) {
+ __connman_inet_get_interface_ll_address(index, AF_INET6, &src);
+ source = &src;
+ } else
+ source = src_addr;
+
+ DBG("sock %d index %d prefixes %p src %s lifetime %d", sk, index,
+ prefixes, inet_ntop(AF_INET6, source, addr_str,
+ INET6_ADDRSTRLEN),
+ router_lifetime);
+
+ memset(buf, 0, MSG_SIZE_SEND);
+ len = 0;
+
+ for (list = prefixes; list; list = list->next) {
+ struct nd_opt_prefix_info *pinfo;
+
+ prefix = list->data;
+ pinfo = (struct nd_opt_prefix_info *)(buf + len);
+
+ len = inc_len(len, sizeof(*pinfo));
+ if (len < 0) {
+ err = len;
+ goto out;
+ }
+
+ pinfo->nd_opt_pi_type = ND_OPT_PREFIX_INFORMATION;
+ pinfo->nd_opt_pi_len = 4;
+ pinfo->nd_opt_pi_prefix_len = prefix->prefixlen;
+ pinfo->nd_opt_pi_flags_reserved = ND_OPT_PI_FLAG_ONLINK;
+ pinfo->nd_opt_pi_flags_reserved |= ND_OPT_PI_FLAG_AUTO;
+ if (router_lifetime > 0) {
+ pinfo->nd_opt_pi_valid_time = htonl(prefix->valid);
+ pinfo->nd_opt_pi_preferred_time =
+ htonl(prefix->preferred);
+ }
+ pinfo->nd_opt_pi_reserved2 = 0;
+
+ memcpy(&pinfo->nd_opt_pi_prefix, &prefix->prefix,
+ sizeof(struct in6_addr));
+
+ DBG("[%d] index %d prefix %s/%d", count, index,
+ inet_ntop(AF_INET6, &prefix->prefix, addr_str,
+ INET6_ADDRSTRLEN), prefix->prefixlen);
+
+ count++;
+ }
+
+ if (count > 0) {
+ err = ndisc_send_unspec(ND_ROUTER_ADVERT, index, &dst, source,
+ buf, len, router_lifetime);
+ if (err < 0)
+ DBG("cannot send RA %d/%s", err, strerror(-err));
+ }
+
+out:
+ close(sk);
+ return err;
+}
+
+void __connman_inet_ipv6_stop_recv_rs(void *context)
+{
+ if (!context)
+ return;
+
+ xs_cleanup(context);
+}
+
+static int icmpv6_rs_recv(int fd, gpointer user_data)
+{
+ struct msghdr mhdr;
+ struct iovec iov;
+ unsigned char chdr[CMSG_BUF_LEN];
+ unsigned char buf[1540];
+ struct xs_cb_data *data = user_data;
+ struct nd_router_solicit *hdr;
+ struct sockaddr_in6 saddr;
+ ssize_t len;
+ __connman_inet_recv_rs_cb_t cb = data->callback;
+
+ DBG("");
+
+ iov.iov_len = sizeof(buf);
+ iov.iov_base = buf;
+
+ mhdr.msg_name = (void *)&saddr;
+ mhdr.msg_namelen = sizeof(struct sockaddr_in6);
+ mhdr.msg_flags = 0;
+ mhdr.msg_iov = &iov;
+ mhdr.msg_iovlen = 1;
+ mhdr.msg_control = (void *)chdr;
+ mhdr.msg_controllen = CMSG_BUF_LEN;
+
+ len = recvmsg(fd, &mhdr, 0);
+ if (len < 0) {
+ cb(NULL, 0, data->user_data);
+ return -errno;
+ }
+
+ hdr = (struct nd_router_solicit *)buf;
+ DBG("code %d len %zd hdr %zd", hdr->nd_rs_code, len,
+ sizeof(struct nd_router_solicit));
+ if (hdr->nd_rs_code != 0)
+ return 0;
+
+ cb(hdr, len, data->user_data);
+ return len;
+}
+
+static gboolean icmpv6_rs_event(GIOChannel *chan, GIOCondition cond,
+ gpointer data)
+{
+ int fd, ret;
+
+ DBG("");
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ fd = g_io_channel_unix_get_fd(chan);
+ ret = icmpv6_rs_recv(fd, data);
+ if (ret == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+int __connman_inet_ipv6_start_recv_rs(int index,
+ __connman_inet_recv_rs_cb_t callback,
+ void *user_data,
+ void **context)
+{
+ struct xs_cb_data *data;
+ struct icmp6_filter filter;
+ char addr_str[INET6_ADDRSTRLEN];
+ int sk, err;
+
+ data = g_try_malloc0(sizeof(struct xs_cb_data));
+ if (!data)
+ return -ENOMEM;
+
+ data->callback = callback;
+ data->user_data = user_data;
+
+ sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
+ if (sk < 0) {
+ g_free(data);
+ return -errno;
+ }
+
+ DBG("sock %d", sk);
+
+ ICMP6_FILTER_SETBLOCKALL(&filter);
+ ICMP6_FILTER_SETPASS(ND_ROUTER_SOLICIT, &filter);
+
+ setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
+ sizeof(struct icmp6_filter));
+
+ err = if_mc_group(sk, index, &in6addr_all_routers_mc, IPV6_JOIN_GROUP);
+ if (err < 0)
+ DBG("Cannot join mc %s %d/%s", inet_ntop(AF_INET6,
+ &in6addr_all_routers_mc, addr_str, INET6_ADDRSTRLEN),
+ err, strerror(-err));
+
+ data->channel = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(data->channel, TRUE);
+
+ g_io_channel_set_encoding(data->channel, NULL, NULL);
+ g_io_channel_set_buffered(data->channel, FALSE);
+
+ data->watch_id = g_io_add_watch(data->channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ icmpv6_rs_event, data);
+
+ *context = data;
+
+ return 0;
+}
+
+static gboolean ns_timeout_cb(gpointer user_data)
+{
+ struct xs_cb_data *data = user_data;
+
+ DBG("user data %p", user_data);
+
+ if (!data)
+ return FALSE;
+
+ if (data->callback) {
+ __connman_inet_ns_cb_t cb = data->callback;
+ cb(NULL, 0, &data->addr.sin6_addr, data->user_data);
+ }
+
+ data->timeout = 0;
+ xs_cleanup(data);
+ return FALSE;
+}
+
+static int icmpv6_nd_recv(int fd, gpointer user_data)
+{
+ struct msghdr mhdr;
+ struct iovec iov;
+ unsigned char chdr[CMSG_BUF_LEN];
+ unsigned char buf[1540];
+ struct xs_cb_data *data = user_data;
+ struct nd_neighbor_advert *hdr;
+ struct sockaddr_in6 saddr;
+ ssize_t len;
+ __connman_inet_ns_cb_t cb = data->callback;
+
+ DBG("");
+
+ iov.iov_len = sizeof(buf);
+ iov.iov_base = buf;
+
+ mhdr.msg_name = (void *)&saddr;
+ mhdr.msg_namelen = sizeof(struct sockaddr_in6);
+ mhdr.msg_flags = 0;
+ mhdr.msg_iov = &iov;
+ mhdr.msg_iovlen = 1;
+ mhdr.msg_control = (void *)chdr;
+ mhdr.msg_controllen = CMSG_BUF_LEN;
+
+ len = recvmsg(fd, &mhdr, 0);
+ if (len < 0) {
+ cb(NULL, 0, &data->addr.sin6_addr, data->user_data);
+ xs_cleanup(data);
+ return -errno;
+ }
+
+ hdr = (struct nd_neighbor_advert *)buf;
+ DBG("code %d len %zd hdr %zd", hdr->nd_na_code, len,
+ sizeof(struct nd_neighbor_advert));
+ if (hdr->nd_na_code != 0)
+ return 0;
+
+ /*
+ * We can receive any neighbor advertisement so we need to check if the
+ * packet was meant for us and ignore the packet otherwise.
+ */
+ if (memcmp(&data->addr.sin6_addr, &hdr->nd_na_target,
+ sizeof(struct in6_addr)))
+ return 0;
+
+ cb(hdr, len, &data->addr.sin6_addr, data->user_data);
+ xs_cleanup(data);
+
+ return len;
+}
+
+static gboolean icmpv6_nd_event(GIOChannel *chan, GIOCondition cond,
+ gpointer data)
+{
+ int fd, ret;
+
+ DBG("");
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ fd = g_io_channel_unix_get_fd(chan);
+ ret = icmpv6_nd_recv(fd, data);
+ if (ret == 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+int __connman_inet_ipv6_do_dad(int index, int timeout_ms,
+ struct in6_addr *addr,
+ __connman_inet_ns_cb_t callback,
+ void *user_data)
+{
+ struct xs_cb_data *data;
+ struct icmp6_filter filter;
+ struct in6_addr solicit;
+ int sk, err, val = 1;
+
+ if (timeout_ms <= 0)
+ return -EINVAL;
+
+ data = g_try_malloc0(sizeof(struct xs_cb_data));
+ if (!data)
+ return -ENOMEM;
+
+ data->callback = callback;
+ data->user_data = user_data;
+ data->timeout = g_timeout_add_full(G_PRIORITY_DEFAULT,
+ (guint)timeout_ms,
+ ns_timeout_cb,
+ data,
+ NULL);
+ memcpy(&data->addr.sin6_addr, addr, sizeof(struct in6_addr));
+
+ sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
+ if (sk < 0)
+ return -errno;
+
+ DBG("sock %d", sk);
+
+ ICMP6_FILTER_SETBLOCKALL(&filter);
+ ICMP6_FILTER_SETPASS(ND_NEIGHBOR_ADVERT, &filter);
+
+ setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
+ sizeof(struct icmp6_filter));
+
+ if (setsockopt(sk, IPPROTO_IPV6, IPV6_RECVPKTINFO,
+ &val, sizeof(val)) < 0) {
+ err = -errno;
+ DBG("Cannot set IPV6_RECVPKTINFO %d/%s", err,
+ strerror(-err));
+ close(sk);
+ return err;
+ }
+
+ if (setsockopt(sk, IPPROTO_IPV6, IPV6_RECVHOPLIMIT,
+ &val, sizeof(val)) < 0) {
+ err = -errno;
+ DBG("Cannot set IPV6_RECVHOPLIMIT %d/%s", err,
+ strerror(-err));
+ close(sk);
+ return err;
+ }
+
+ val = 0;
+ setsockopt(sk, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &val, sizeof(val));
+
+ ipv6_addr_solict_mult(addr, &solicit);
+ if_mc_group(sk, index, &in6addr_all_nodes_mc, IPV6_JOIN_GROUP);
+ if_mc_group(sk, index, &solicit, IPV6_JOIN_GROUP);
+
+ data->channel = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(data->channel, TRUE);
+
+ g_io_channel_set_encoding(data->channel, NULL, NULL);
+ g_io_channel_set_buffered(data->channel, FALSE);
+
+ data->watch_id = g_io_add_watch(data->channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ icmpv6_nd_event, data);
+
+ err = ndisc_send_unspec(ND_NEIGHBOR_SOLICIT, index, &solicit, NULL,
+ (unsigned char *)addr, 0, 0);
+ if (err < 0) {
+ DBG("Cannot send NS %d/%s", err, strerror(-err));
+ xs_cleanup(data);
+ }
+
+ return err;
+}
+
+GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
+ unsigned int length)
+{
+ GSList *prefixes = NULL;
+ uint8_t *pos;
+ int len;
+
+ if (length <= sizeof(struct nd_router_advert))
+ return NULL;
+
+ len = length - sizeof(struct nd_router_advert);
+ pos = (uint8_t *)hdr + sizeof(struct nd_router_advert);
+
+ while (len > 0) {
+ struct nd_opt_prefix_info *pinfo;
+ char prefix_str[INET6_ADDRSTRLEN+1], *str;
+ const char *prefix;
+ int optlen;
+
+ if (len < 2)
+ break;
+
+ optlen = pos[1] << 3;
+ if (optlen == 0 || optlen > len)
+ break;
+
+ switch (pos[0]) {
+ case ND_OPT_PREFIX_INFORMATION:
+ pinfo = (struct nd_opt_prefix_info *)pos;
+ prefix = inet_ntop(AF_INET6, &pinfo->nd_opt_pi_prefix,
+ prefix_str, INET6_ADDRSTRLEN);
+ if (!prefix)
+ break;
+
+ str = g_strdup_printf("%s/%d", prefix,
+ pinfo->nd_opt_pi_prefix_len);
+ prefixes = g_slist_prepend(prefixes, str);
+
+ DBG("prefix %s", str);
+
+ break;
+ }
+
+ len -= optlen;
+ pos += optlen;
+ }
+
+ return prefixes;
+}
+
+static int get_dest_addr(int family, int index, char *buf, int len)
+{
+ struct ifreq ifr;
+ void *addr;
+ int sk;
+
+ sk = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -errno;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = index;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
+ DBG("SIOCGIFNAME (%d/%s)", errno, strerror(errno));
+ close(sk);
+ return -errno;
+ }
+
+ if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
+ DBG("SIOCGIFFLAGS (%d/%s)", errno, strerror(errno));
+ close(sk);
+ return -errno;
+ }
+
+ if ((ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
+ close(sk);
+ errno = EINVAL;
+ return -errno;
+ }
+
+ DBG("index %d %s", index, ifr.ifr_name);
+
+ if (ioctl(sk, SIOCGIFDSTADDR, &ifr) < 0) {
+ connman_error("Get destination address failed (%s)",
+ strerror(errno));
+ close(sk);
+ return -errno;
+ }
+
+ close(sk);
+
+ switch (family) {
+ case AF_INET:
+ addr = &((struct sockaddr_in *)&ifr.ifr_dstaddr)->sin_addr;
+ break;
+ case AF_INET6:
+ addr = &((struct sockaddr_in6 *)&ifr.ifr_dstaddr)->sin6_addr;
+ break;
+ default:
+ errno = EINVAL;
+ return -errno;
+ }
+
+ if (!inet_ntop(family, addr, buf, len)) {
+ DBG("error %d/%s", errno, strerror(errno));
+ return -errno;
+ }
+
+ return 0;
+}
+
+int connman_inet_get_dest_addr(int index, char **dest)
+{
+ char addr[INET_ADDRSTRLEN];
+ int ret;
+
+ ret = get_dest_addr(PF_INET, index, addr, INET_ADDRSTRLEN);
+ if (ret < 0)
+ return ret;
+
+ *dest = g_strdup(addr);
+
+ DBG("destination %s", *dest);
+
+ return 0;
+}
+
+int connman_inet_ipv6_get_dest_addr(int index, char **dest)
+{
+ char addr[INET6_ADDRSTRLEN];
+ int ret;
+
+ ret = get_dest_addr(PF_INET6, index, addr, INET6_ADDRSTRLEN);
+ if (ret < 0)
+ return ret;
+
+ *dest = g_strdup(addr);
+
+ DBG("destination %s", *dest);
+
+ return 0;
+}
+
+int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth)
+{
+ int sndbuf = 1024;
+ int rcvbuf = 1024 * 4;
+
+ rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
+ if (rth->fd < 0) {
+ connman_error("Can not open netlink socket: %s",
+ strerror(errno));
+ return -errno;
+ }
+
+ if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
+ sizeof(sndbuf)) < 0) {
+ connman_error("SO_SNDBUF: %s", strerror(errno));
+ return -errno;
+ }
+
+ if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
+ sizeof(rcvbuf)) < 0) {
+ connman_error("SO_RCVBUF: %s", strerror(errno));
+ return -errno;
+ }
+
+ memset(&rth->local, 0, sizeof(rth->local));
+ rth->local.nl_family = AF_NETLINK;
+ rth->local.nl_groups = 0;
+
+ if (bind(rth->fd, (struct sockaddr *)&rth->local,
+ sizeof(rth->local)) < 0) {
+ connman_error("Can not bind netlink socket: %s",
+ strerror(errno));
+ return -errno;
+ }
+
+ rth->seq = time(NULL);
+
+ DBG("fd %d", rth->fd);
+
+ return 0;
+}
+
+struct inet_rtnl_cb_data {
+ GIOChannel *channel;
+ __connman_inet_rtnl_cb_t callback;
+ guint rtnl_timeout;
+ guint watch_id;
+ struct __connman_inet_rtnl_handle *rtnl;
+ void *user_data;
+};
+
+static void inet_rtnl_cleanup(struct inet_rtnl_cb_data *data)
+{
+ struct __connman_inet_rtnl_handle *rth = data->rtnl;
+
+ if (data->channel) {
+ g_io_channel_shutdown(data->channel, TRUE, NULL);
+ g_io_channel_unref(data->channel);
+ data->channel = NULL;
+ }
+
+ DBG("data %p", data);
+
+ if (data->rtnl_timeout > 0)
+ g_source_remove(data->rtnl_timeout);
+
+ if (data->watch_id > 0)
+ g_source_remove(data->watch_id);
+
+ if (rth) {
+ __connman_inet_rtnl_close(rth);
+ g_free(rth);
+ }
+
+ g_free(data);
+}
+
+static gboolean inet_rtnl_timeout_cb(gpointer user_data)
+{
+ struct inet_rtnl_cb_data *data = user_data;
+
+ DBG("user data %p", user_data);
+
+ if (!data)
+ return FALSE;
+
+ if (data->callback)
+ data->callback(NULL, data->user_data);
+
+ data->rtnl_timeout = 0;
+ inet_rtnl_cleanup(data);
+ return FALSE;
+}
+
+static int inet_rtnl_recv(GIOChannel *chan, gpointer user_data)
+{
+ struct inet_rtnl_cb_data *rtnl_data = user_data;
+ struct __connman_inet_rtnl_handle *rth = rtnl_data->rtnl;
+ struct nlmsghdr *h = NULL;
+ struct sockaddr_nl nladdr;
+ socklen_t addr_len = sizeof(nladdr);
+ unsigned char buf[4096];
+ void *ptr = buf;
+ gsize len;
+ int status, fd;
+
+ memset(buf, 0, sizeof(buf));
+ memset(&nladdr, 0, sizeof(nladdr));
+
+ fd = g_io_channel_unix_get_fd(chan);
+
+ status = recvfrom(fd, buf, sizeof(buf), 0,
+ (struct sockaddr *) &nladdr, &addr_len);
+ if (status < 0) {
+ if (errno == EINTR || errno == EAGAIN)
+ return 0;
+
+ return -1;
+ }
+
+ if (status == 0)
+ return -1;
+
+ if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
+ DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
+ return 0;
+ }
+
+ len = status;
+
+ while (len > 0) {
+ struct nlmsgerr *err;
+
+ h = ptr;
+
+ if (!NLMSG_OK(h, len))
+ return -1;
+
+ if (h->nlmsg_seq != rth->seq) {
+ /* Skip this msg */
+ DBG("skip %d/%d len %d", rth->seq,
+ h->nlmsg_seq, h->nlmsg_len);
+
+ len -= h->nlmsg_len;
+ ptr += h->nlmsg_len;
+ continue;
+ }
+
+ switch (h->nlmsg_type) {
+ case NLMSG_NOOP:
+ case NLMSG_OVERRUN:
+ return -1;
+
+ case NLMSG_ERROR:
+ err = (struct nlmsgerr *)NLMSG_DATA(h);
+ connman_error("RTNETLINK answers %s (%d)",
+ strerror(-err->error), -err->error);
+ return err->error;
+ }
+
+ break;
+ }
+
+ if (h->nlmsg_seq == rth->seq) {
+ DBG("received %d seq %d", h->nlmsg_len, h->nlmsg_seq);
+
+ rtnl_data->callback(h, rtnl_data->user_data);
+
+ inet_rtnl_cleanup(rtnl_data);
+ }
+
+ return 0;
+}
+
+static gboolean inet_rtnl_event(GIOChannel *chan, GIOCondition cond,
+ gpointer user_data)
+{
+ int ret;
+
+ DBG("");
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ ret = inet_rtnl_recv(chan, user_data);
+ if (ret != 0)
+ return TRUE;
+
+ return FALSE;
+}
+
+int __connman_inet_rtnl_talk(struct __connman_inet_rtnl_handle *rtnl,
+ struct nlmsghdr *n, int timeout,
+ __connman_inet_rtnl_cb_t callback, void *user_data)
+{
+ struct sockaddr_nl nladdr;
+ struct inet_rtnl_cb_data *data;
+ unsigned seq;
+ int err;
+
+ memset(&nladdr, 0, sizeof(nladdr));
+ nladdr.nl_family = AF_NETLINK;
+
+ n->nlmsg_seq = seq = ++rtnl->seq;
+
+ if (callback) {
+ data = g_try_malloc0(sizeof(struct inet_rtnl_cb_data));
+ if (!data)
+ return -ENOMEM;
+
+ data->callback = callback;
+ data->user_data = user_data;
+ data->rtnl = rtnl;
+ data->rtnl_timeout = g_timeout_add_seconds(timeout,
+ inet_rtnl_timeout_cb, data);
+
+ data->channel = g_io_channel_unix_new(rtnl->fd);
+ g_io_channel_set_close_on_unref(data->channel, TRUE);
+
+ g_io_channel_set_encoding(data->channel, NULL, NULL);
+ g_io_channel_set_buffered(data->channel, FALSE);
+
+ data->watch_id = g_io_add_watch(data->channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ inet_rtnl_event, data);
+ } else
+ n->nlmsg_flags |= NLM_F_ACK;
+
+ err = sendto(rtnl->fd, &rtnl->req.n, rtnl->req.n.nlmsg_len, 0,
+ (struct sockaddr *) &nladdr, sizeof(nladdr));
+ DBG("handle %p len %d", rtnl, rtnl->req.n.nlmsg_len);
+ if (err < 0) {
+ connman_error("Can not talk to rtnetlink err %d %s",
+ -errno, strerror(errno));
+ return -errno;
+ }
+
+ if ((unsigned int)err != rtnl->req.n.nlmsg_len) {
+ connman_error("Sent %d bytes, msg truncated", err);
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth)
+{
+ DBG("handle %p", rth);
+
+ if (rth->fd >= 0) {
+ close(rth->fd);
+ rth->fd = -1;
+ }
+}
+
+int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen, int type,
+ __u32 data)
+{
+ int len = RTA_LENGTH(4);
+ struct rtattr *rta;
+
+ if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
+ DBG("Error! max allowed bound %zd exceeded", maxlen);
+ return -1;
+ }
+ rta = NLMSG_TAIL(n);
+ rta->rta_type = type;
+ rta->rta_len = len;
+ memcpy(RTA_DATA(rta), &data, 4);
+ n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
+
+ return 0;
+}
+
+static int parse_rtattr(struct rtattr *tb[], int max,
+ struct rtattr *rta, int len)
+{
+ memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
+ while (RTA_OK(rta, len)) {
+ if ((rta->rta_type <= max) && (!tb[rta->rta_type]))
+ tb[rta->rta_type] = rta;
+ rta = RTA_NEXT(rta, len);
+ }
+ if (len)
+ connman_error("Deficit %d, rta_len=%d", len, rta->rta_len);
+
+ return 0;
+}
+
+struct get_route_cb_data {
+ connman_inet_addr_cb_t callback;
+ void *user_data;
+};
+
+static void get_route_cb(struct nlmsghdr *answer, void *user_data)
+{
+ struct get_route_cb_data *data = user_data;
+ struct rtattr *tb[RTA_MAX+1];
+ struct rtmsg *r = NLMSG_DATA(answer);
+ int len, index = -1;
+ char abuf[256];
+ const char *addr = NULL;
+
+ DBG("answer %p data %p", answer, user_data);
+
+ if (!answer)
+ goto out;
+
+ len = answer->nlmsg_len;
+
+ if (answer->nlmsg_type != RTM_NEWROUTE &&
+ answer->nlmsg_type != RTM_DELROUTE) {
+ connman_error("Not a route: %08x %08x %08x",
+ answer->nlmsg_len, answer->nlmsg_type,
+ answer->nlmsg_flags);
+ goto out;
+ }
+
+ len -= NLMSG_LENGTH(sizeof(*r));
+ if (len < 0) {
+ connman_error("BUG: wrong nlmsg len %d", len);
+ goto out;
+ }
+
+ parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
+
+ if (tb[RTA_OIF])
+ index = *(int *)RTA_DATA(tb[RTA_OIF]);
+
+ if (tb[RTA_GATEWAY])
+ addr = inet_ntop(r->rtm_family,
+ RTA_DATA(tb[RTA_GATEWAY]),
+ abuf, sizeof(abuf));
+
+ DBG("addr %s index %d user %p", addr, index, data->user_data);
+
+out:
+ if (data && data->callback)
+ data->callback(addr, index, data->user_data);
+
+ g_free(data);
+
+ return;
+}
+
+/*
+ * Return the interface index that contains route to host.
+ */
+int __connman_inet_get_route(const char *dest_address,
+ connman_inet_addr_cb_t callback, void *user_data)
+{
+ struct get_route_cb_data *data;
+ struct addrinfo hints, *rp;
+ struct __connman_inet_rtnl_handle *rth;
+ int err;
+
+ DBG("dest %s", dest_address);
+
+ if (!dest_address)
+ return -EINVAL;
+
+ memset(&hints, 0, sizeof(hints));
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
+
+ err = getaddrinfo(dest_address, NULL, &hints, &rp);
+ if (err)
+ return -EINVAL;
+
+ rth = g_try_malloc0(sizeof(struct __connman_inet_rtnl_handle));
+ if (!rth) {
+ freeaddrinfo(rp);
+ return -ENOMEM;
+ }
+
+ rth->req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ rth->req.n.nlmsg_flags = NLM_F_REQUEST;
+ rth->req.n.nlmsg_type = RTM_GETROUTE;
+ rth->req.u.r.rt.rtm_family = rp->ai_family;
+ rth->req.u.r.rt.rtm_table = 0;
+ rth->req.u.r.rt.rtm_protocol = 0;
+ rth->req.u.r.rt.rtm_scope = 0;
+ rth->req.u.r.rt.rtm_type = 0;
+ rth->req.u.r.rt.rtm_src_len = 0;
+ rth->req.u.r.rt.rtm_dst_len = rp->ai_addrlen << 3;
+ rth->req.u.r.rt.rtm_tos = 0;
+
+ __connman_inet_rtnl_addattr_l(&rth->req.n, sizeof(rth->req), RTA_DST,
+ &rp->ai_addr, rp->ai_addrlen);
+
+ freeaddrinfo(rp);
+
+ err = __connman_inet_rtnl_open(rth);
+ if (err < 0)
+ goto fail;
+
+ data = g_try_malloc(sizeof(struct get_route_cb_data));
+ if (!data) {
+ err = -ENOMEM;
+ goto done;
+ }
+
+ data->callback = callback;
+ data->user_data = user_data;
+
+#define GET_ROUTE_TIMEOUT 2
+ err = __connman_inet_rtnl_talk(rth, &rth->req.n, GET_ROUTE_TIMEOUT,
+ get_route_cb, data);
+ if (err < 0) {
+ g_free(data);
+ goto done;
+ }
+
+ return 0;
+
+done:
+ __connman_inet_rtnl_close(rth);
+
+fail:
+ g_free(rth);
+ return err;
+}
+
+int connman_inet_check_ipaddress(const char *host)
+{
+ struct addrinfo hints;
+ struct addrinfo *addr;
+ int result;
+
+ memset(&hints, 0, sizeof(struct addrinfo));
+ hints.ai_flags = AI_NUMERICHOST;
+ addr = NULL;
+
+ result = getaddrinfo(host, NULL, &hints, &addr);
+ if (result == 0)
+ result = addr->ai_family;
+ freeaddrinfo(addr);
+
+ return result;
+}
+
+/* Check routine modified from ics-dhcp 4.2.3-P2 */
+bool connman_inet_check_hostname(const char *ptr, size_t len)
+{
+ const char *p;
+
+ /*
+ * Not empty or complete length not over 255 characters.
+ */
+ if ((len == 0) || (len > 256))
+ return false;
+
+ /*
+ * Consists of [[:alnum:]-]+ labels separated by [.]
+ * a [_] is against RFC but seems to be "widely used"
+ */
+ for (p = ptr; (*p != 0) && (len-- > 0); p++) {
+
+ if ((*p == '-') || (*p == '_')) {
+ /*
+ * Not allowed at begin or end of a label.
+ */
+ if (((p - ptr) == 0) || (len == 0) || (p[1] == '.'))
+ return false;
+
+ } else if (*p == '.') {
+ /*
+ * Each label has to be 1-63 characters;
+ * we allow [.] at the end ('foo.bar.')
+ */
+ size_t d = p - ptr;
+
+ if ((d <= 0) || (d >= 64))
+ return false;
+
+ ptr = p + 1; /* Jump to the next label */
+
+ } else if (isalnum((unsigned char)*p) == 0) {
+ /*
+ * Also numbers at the begin are fine
+ */
+ return false;
+ }
+ }
+
+ return true;
+}
+
+char **__connman_inet_get_running_interfaces(void)
+{
+ char **result;
+ struct ifconf ifc;
+ struct ifreq *ifr = NULL;
+ int sk, i, numif, count = 0;
+
+ memset(&ifc, 0, sizeof(ifc));
+
+ sk = socket(AF_INET, SOCK_DGRAM, 0);
+ if (sk < 0)
+ return NULL;
+
+ if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
+ goto error;
+
+ /*
+ * Allocate some extra bytes just in case there will
+ * be new interfaces added between two SIOCGIFCONF
+ * calls.
+ */
+ ifr = g_try_malloc0(ifc.ifc_len * 2);
+ if (!ifr)
+ goto error;
+
+ ifc.ifc_req = ifr;
+
+ if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
+ goto error;
+
+ numif = ifc.ifc_len / sizeof(struct ifreq);
+
+ result = g_try_malloc0((numif + 1) * sizeof(char *));
+ if (!result)
+ goto error;
+
+ close(sk);
+
+ for (i = 0; i < numif; i++) {
+ struct ifreq *r = &ifr[i];
+ struct in6_addr *addr6;
+ in_addr_t addr4;
+
+ /*
+ * Note that we do not return loopback interfaces here as they
+ * are not needed for our purposes.
+ */
+ switch (r->ifr_addr.sa_family) {
+ case AF_INET:
+ addr4 = ntohl(((struct sockaddr_in *)
+ &r->ifr_addr)->sin_addr.s_addr);
+ if (((addr4 & 0xff000000) >> 24) == 127)
+ continue;
+ break;
+ case AF_INET6:
+ addr6 = &((struct sockaddr_in6 *)
+ &r->ifr_addr)->sin6_addr;
+ if (IN6_IS_ADDR_LINKLOCAL(addr6))
+ continue;
+ break;
+ }
+
+ result[count++] = g_strdup(r->ifr_name);
+ }
+
+ g_free(ifr);
+
+ if (count < numif)
+ result = g_try_realloc(result, (count + 1) * sizeof(char *));
+
+ return result;
+
+error:
+ close(sk);
+ g_free(ifr);
+ return NULL;
+}
+
+bool connman_inet_is_ipv6_supported()
+{
+ int sk;
+
+ sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return false;
+
+ close(sk);
+ return true;
+}
+
+int __connman_inet_get_interface_address(int index, int family, void *address)
+{
+ struct ifaddrs *ifaddr, *ifa;
+ int err = -ENOENT;
+ char name[IF_NAMESIZE];
+
+ if (!if_indextoname(index, name))
+ return -EINVAL;
+
+ DBG("index %d interface %s", index, name);
+
+ if (getifaddrs(&ifaddr) < 0) {
+ err = -errno;
+ DBG("Cannot get addresses err %d/%s", err, strerror(-err));
+ return err;
+ }
+
+ for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
+ if (!ifa->ifa_addr)
+ continue;
+
+ if (strncmp(ifa->ifa_name, name, IF_NAMESIZE) == 0 &&
+ ifa->ifa_addr->sa_family == family) {
+ if (family == AF_INET) {
+ struct sockaddr_in *in4 = (struct sockaddr_in *)
+ ifa->ifa_addr;
+ if (in4->sin_addr.s_addr == INADDR_ANY)
+ continue;
+ memcpy(address, &in4->sin_addr,
+ sizeof(struct in_addr));
+ } else if (family == AF_INET6) {
+ struct sockaddr_in6 *in6 =
+ (struct sockaddr_in6 *)ifa->ifa_addr;
+ if (memcmp(&in6->sin6_addr, &in6addr_any,
+ sizeof(struct in6_addr)) == 0)
+ continue;
+ memcpy(address, &in6->sin6_addr,
+ sizeof(struct in6_addr));
+
+ } else {
+ err = -EINVAL;
+ goto out;
+ }
+
+ err = 0;
+ break;
+ }
+ }
+
+out:
+ freeifaddrs(ifaddr);
+ return err;
+}
+
+static int iprule_modify(int cmd, int family, uint32_t table_id,
+ uint32_t fwmark)
+{
+ struct __connman_inet_rtnl_handle rth;
+ int ret;
+
+ memset(&rth, 0, sizeof(rth));
+
+ rth.req.n.nlmsg_type = cmd;
+ rth.req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ rth.req.n.nlmsg_flags = NLM_F_REQUEST;
+ rth.req.u.r.rt.rtm_family = family;
+ rth.req.u.r.rt.rtm_protocol = RTPROT_BOOT;
+ rth.req.u.r.rt.rtm_scope = RT_SCOPE_UNIVERSE;
+ rth.req.u.r.rt.rtm_table = table_id;
+ rth.req.u.r.rt.rtm_type = RTN_UNSPEC;
+ rth.req.u.r.rt.rtm_flags = 0;
+
+ if (cmd == RTM_NEWRULE) {
+ rth.req.n.nlmsg_flags |= NLM_F_CREATE|NLM_F_EXCL;
+ rth.req.u.r.rt.rtm_type = RTN_UNICAST;
+ }
+
+ __connman_inet_rtnl_addattr32(&rth.req.n, sizeof(rth.req),
+ FRA_FWMARK, fwmark);
+
+ if (table_id < 256) {
+ rth.req.u.r.rt.rtm_table = table_id;
+ } else {
+ rth.req.u.r.rt.rtm_table = RT_TABLE_UNSPEC;
+ __connman_inet_rtnl_addattr32(&rth.req.n, sizeof(rth.req),
+ FRA_TABLE, table_id);
+ }
+
+ if (rth.req.u.r.rt.rtm_family == AF_UNSPEC)
+ rth.req.u.r.rt.rtm_family = AF_INET;
+
+ ret = __connman_inet_rtnl_open(&rth);
+ if (ret < 0)
+ goto done;
+
+ ret = __connman_inet_rtnl_send(&rth, &rth.req.n);
+
+done:
+ __connman_inet_rtnl_close(&rth);
+
+ return ret;
+}
+
+int __connman_inet_add_fwmark_rule(uint32_t table_id, int family, uint32_t fwmark)
+{
+ /* ip rule add fwmark 9876 table 1234 */
+
+ return iprule_modify(RTM_NEWRULE, family, table_id, fwmark);
+}
+
+int __connman_inet_del_fwmark_rule(uint32_t table_id, int family, uint32_t fwmark)
+{
+ return iprule_modify(RTM_DELRULE, family, table_id, fwmark);
+}
+
+static int iproute_default_modify(int cmd, uint32_t table_id, int ifindex,
+ const char *gateway)
+{
+ struct __connman_inet_rtnl_handle rth;
+ unsigned char buf[sizeof(struct in6_addr)];
+ int ret, len;
+ int family = connman_inet_check_ipaddress(gateway);
+
+ switch (family) {
+ case AF_INET:
+ len = 4;
+ break;
+ case AF_INET6:
+ len = 16;
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ ret = inet_pton(family, gateway, buf);
+ if (ret <= 0)
+ return -EINVAL;
+
+ memset(&rth, 0, sizeof(rth));
+
+ rth.req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
+ rth.req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_CREATE | NLM_F_EXCL;
+ rth.req.n.nlmsg_type = cmd;
+ rth.req.u.r.rt.rtm_family = family;
+ rth.req.u.r.rt.rtm_table = RT_TABLE_MAIN;
+ rth.req.u.r.rt.rtm_scope = RT_SCOPE_NOWHERE;
+ rth.req.u.r.rt.rtm_protocol = RTPROT_BOOT;
+ rth.req.u.r.rt.rtm_scope = RT_SCOPE_UNIVERSE;
+ rth.req.u.r.rt.rtm_type = RTN_UNICAST;
+
+ __connman_inet_rtnl_addattr_l(&rth.req.n, sizeof(rth.req), RTA_GATEWAY,
+ buf, len);
+ if (table_id < 256) {
+ rth.req.u.r.rt.rtm_table = table_id;
+ } else {
+ rth.req.u.r.rt.rtm_table = RT_TABLE_UNSPEC;
+ __connman_inet_rtnl_addattr32(&rth.req.n, sizeof(rth.req),
+ RTA_TABLE, table_id);
+ }
+
+ __connman_inet_rtnl_addattr32(&rth.req.n, sizeof(rth.req),
+ RTA_OIF, ifindex);
+
+ ret = __connman_inet_rtnl_open(&rth);
+ if (ret < 0)
+ goto done;
+
+ ret = __connman_inet_rtnl_send(&rth, &rth.req.n);
+
+done:
+ __connman_inet_rtnl_close(&rth);
+
+ return ret;
+}
+
+int __connman_inet_add_default_to_table(uint32_t table_id, int ifindex,
+ const char *gateway)
+{
+ /* ip route add default via 1.2.3.4 dev wlan0 table 1234 */
+
+ return iproute_default_modify(RTM_NEWROUTE, table_id, ifindex, gateway);
+}
+
+int __connman_inet_del_default_from_table(uint32_t table_id, int ifindex,
+ const char *gateway)
+{
+ /* ip route del default via 1.2.3.4 dev wlan0 table 1234 */
+
+ return iproute_default_modify(RTM_DELROUTE, table_id, ifindex, gateway);
+}
+
+int __connman_inet_get_interface_ll_address(int index, int family,
+ void *address)
+{
+ struct ifaddrs *ifaddr, *ifa;
+ int err = -ENOENT;
+ char name[IF_NAMESIZE];
+
+ if (!if_indextoname(index, name))
+ return -EINVAL;
+
+ DBG("index %d interface %s", index, name);
+
+ if (getifaddrs(&ifaddr) < 0) {
+ err = -errno;
+ DBG("Cannot get addresses err %d/%s", err, strerror(-err));
+ return err;
+ }
+
+ for (ifa = ifaddr; ifa; ifa = ifa->ifa_next) {
+ if (!ifa->ifa_addr)
+ continue;
+
+ if (strncmp(ifa->ifa_name, name, IF_NAMESIZE) == 0 &&
+ ifa->ifa_addr->sa_family == family) {
+ if (family == AF_INET) {
+ struct sockaddr_in *in4 = (struct sockaddr_in *)
+ ifa->ifa_addr;
+ if (in4->sin_addr.s_addr == INADDR_ANY)
+ continue;
+ if ((in4->sin_addr.s_addr & IN_CLASSB_NET) !=
+ ((in_addr_t) 0xa9fe0000))
+ continue;
+ memcpy(address, &in4->sin_addr,
+ sizeof(struct in_addr));
+ } else if (family == AF_INET6) {
+ struct sockaddr_in6 *in6 =
+ (struct sockaddr_in6 *)ifa->ifa_addr;
+ if (memcmp(&in6->sin6_addr, &in6addr_any,
+ sizeof(struct in6_addr)) == 0)
+ continue;
+ if (!IN6_IS_ADDR_LINKLOCAL(&in6->sin6_addr))
+ continue;
+
+ memcpy(address, &in6->sin6_addr,
+ sizeof(struct in6_addr));
+ } else {
+ err = -EINVAL;
+ goto out;
+ }
+
+ err = 0;
+ break;
+ }
+ }
+
+out:
+ freeifaddrs(ifaddr);
+ return err;
+}
+
+int __connman_inet_get_address_netmask(int ifindex,
+ struct sockaddr_in *address,
+ struct sockaddr_in *netmask)
+{
+ int sk, ret = -EINVAL;
+ struct ifreq ifr;
+
+ DBG("index %d", ifindex);
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -EINVAL;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_ifindex = ifindex;
+
+ if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
+ goto out;
+
+ if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0)
+ goto out;
+
+ memcpy(netmask, (struct sockaddr_in *)&ifr.ifr_netmask,
+ sizeof(struct sockaddr_in));
+
+ if (ioctl(sk, SIOCGIFADDR, &ifr) < 0)
+ goto out;
+
+ memcpy(address, (struct sockaddr_in *)&ifr.ifr_addr,
+ sizeof(struct sockaddr_in));
+ ret = 0;
+
+out:
+ close(sk);
+ return ret;
+}
diff --git a/src/inotify.c b/src/inotify.c
new file mode 100644
index 0000000..c251c6f
--- /dev/null
+++ b/src/inotify.c
@@ -0,0 +1,261 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <dirent.h>
+#include <sys/inotify.h>
+
+#include <connman/storage.h>
+
+#include "connman.h"
+
+struct connman_inotify {
+ unsigned int refcount;
+
+ GIOChannel *channel;
+ uint watch;
+ int wd;
+
+ GSList *list;
+};
+
+static void cleanup_inotify(gpointer user_data);
+
+static void connman_inotify_ref(struct connman_inotify *i)
+{
+ __sync_fetch_and_add(&i->refcount, 1);
+}
+
+static void connman_inotify_unref(gpointer data)
+{
+ struct connman_inotify *i = data;
+
+ if (__sync_fetch_and_sub(&i->refcount, 1) != 1)
+ return;
+
+ cleanup_inotify(data);
+}
+
+static GHashTable *inotify_hash;
+
+static gboolean inotify_data(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct connman_inotify *inotify = user_data;
+ char buffer[sizeof(struct inotify_event) + NAME_MAX + 1];
+ char *next_event;
+ gsize bytes_read;
+ GIOStatus status;
+ GSList *list;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ inotify->watch = 0;
+ return FALSE;
+ }
+
+ status = g_io_channel_read_chars(channel, buffer,
+ sizeof(buffer), &bytes_read, NULL);
+
+ switch (status) {
+ case G_IO_STATUS_NORMAL:
+ break;
+ case G_IO_STATUS_AGAIN:
+ return TRUE;
+ default:
+ connman_error("Reading from inotify channel failed");
+ inotify->watch = 0;
+ return FALSE;
+ }
+
+ next_event = buffer;
+
+ connman_inotify_ref(inotify);
+
+ while (bytes_read > 0) {
+ struct inotify_event *event;
+ gchar *ident;
+ gsize len;
+
+ event = (struct inotify_event *) next_event;
+ if (event->len)
+ ident = next_event + sizeof(struct inotify_event);
+ else
+ ident = NULL;
+
+ len = sizeof(struct inotify_event) + event->len;
+
+ /* check if inotify_event block fit */
+ if (len > bytes_read)
+ break;
+
+ next_event += len;
+ bytes_read -= len;
+
+ for (list = inotify->list; list; list = list->next) {
+ inotify_event_cb callback = list->data;
+
+ (*callback)(event, ident);
+ }
+ }
+
+ connman_inotify_unref(inotify);
+
+ return TRUE;
+}
+
+static int create_watch(const char *path, struct connman_inotify *inotify)
+{
+ int fd;
+
+ DBG("Add directory watch for %s", path);
+
+ fd = inotify_init();
+ if (fd < 0)
+ return -EIO;
+
+ inotify->wd = inotify_add_watch(fd, path,
+ IN_MODIFY | IN_CREATE | IN_DELETE |
+ IN_MOVED_TO | IN_MOVED_FROM);
+ if (inotify->wd < 0) {
+ connman_error("Creation of %s watch failed", path);
+ close(fd);
+ return -EIO;
+ }
+
+ inotify->channel = g_io_channel_unix_new(fd);
+ if (!inotify->channel) {
+ connman_error("Creation of inotify channel failed");
+ inotify_rm_watch(fd, inotify->wd);
+ inotify->wd = 0;
+
+ close(fd);
+ return -EIO;
+ }
+
+ g_io_channel_set_close_on_unref(inotify->channel, TRUE);
+ g_io_channel_set_encoding(inotify->channel, NULL, NULL);
+ g_io_channel_set_buffered(inotify->channel, FALSE);
+
+ inotify->watch = g_io_add_watch(inotify->channel,
+ G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
+ inotify_data, inotify);
+
+ return 0;
+}
+
+static void remove_watch(struct connman_inotify *inotify)
+{
+ int fd;
+
+ if (!inotify->channel)
+ return;
+
+ if (inotify->watch > 0)
+ g_source_remove(inotify->watch);
+
+ fd = g_io_channel_unix_get_fd(inotify->channel);
+
+ if (inotify->wd >= 0)
+ inotify_rm_watch(fd, inotify->wd);
+
+ g_io_channel_unref(inotify->channel);
+}
+
+int connman_inotify_register(const char *path, inotify_event_cb callback)
+{
+ struct connman_inotify *inotify;
+ int err;
+
+ if (!callback)
+ return -EINVAL;
+
+ inotify = g_hash_table_lookup(inotify_hash, path);
+ if (inotify)
+ goto update;
+
+ inotify = g_try_new0(struct connman_inotify, 1);
+ if (!inotify)
+ return -ENOMEM;
+
+ inotify->refcount = 1;
+ inotify->wd = -1;
+
+ err = create_watch(path, inotify);
+ if (err < 0) {
+ g_free(inotify);
+ return err;
+ }
+
+ g_hash_table_replace(inotify_hash, g_strdup(path), inotify);
+
+update:
+ inotify->list = g_slist_prepend(inotify->list, callback);
+
+ return 0;
+}
+
+static void cleanup_inotify(gpointer user_data)
+{
+ struct connman_inotify *inotify = user_data;
+
+ g_slist_free(inotify->list);
+
+ remove_watch(inotify);
+ g_free(inotify);
+}
+
+void connman_inotify_unregister(const char *path, inotify_event_cb callback)
+{
+ struct connman_inotify *inotify;
+
+ inotify = g_hash_table_lookup(inotify_hash, path);
+ if (!inotify)
+ return;
+
+ inotify->list = g_slist_remove(inotify->list, callback);
+ if (inotify->list)
+ return;
+
+ g_hash_table_remove(inotify_hash, path);
+}
+
+int __connman_inotify_init(void)
+{
+ DBG("");
+
+ inotify_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, connman_inotify_unref);
+ return 0;
+}
+
+void __connman_inotify_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(inotify_hash);
+}
diff --git a/src/ipaddress.c b/src/ipaddress.c
new file mode 100644
index 0000000..d63d95c
--- /dev/null
+++ b/src/ipaddress.c
@@ -0,0 +1,228 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <glib.h>
+
+#include <connman/ipaddress.h>
+
+#include "connman.h"
+
+unsigned char connman_ipaddress_calc_netmask_len(const char *netmask)
+{
+ unsigned char bits;
+ in_addr_t mask;
+ in_addr_t host;
+
+ if (!netmask)
+ return 32;
+
+ mask = inet_network(netmask);
+ host = ~mask;
+
+ /* a valid netmask must be 2^n - 1 */
+ if ((host & (host + 1)) != 0)
+ return -1;
+
+ bits = 0;
+ for (; mask; mask <<= 1)
+ ++bits;
+
+ return bits;
+}
+
+struct connman_ipaddress *connman_ipaddress_alloc(int family)
+{
+ struct connman_ipaddress *ipaddress;
+
+ ipaddress = g_try_new0(struct connman_ipaddress, 1);
+ if (!ipaddress)
+ return NULL;
+
+ ipaddress->family = family;
+ ipaddress->prefixlen = 0;
+ ipaddress->local = NULL;
+ ipaddress->peer = NULL;
+ ipaddress->broadcast = NULL;
+ ipaddress->gateway = NULL;
+
+ return ipaddress;
+}
+
+void connman_ipaddress_free(struct connman_ipaddress *ipaddress)
+{
+ if (!ipaddress)
+ return;
+
+ g_free(ipaddress->broadcast);
+ g_free(ipaddress->peer);
+ g_free(ipaddress->local);
+ g_free(ipaddress->gateway);
+ g_free(ipaddress);
+}
+
+static bool check_ipv6_address(const char *address)
+{
+ unsigned char buf[sizeof(struct in6_addr)];
+ int err;
+
+ if (!address)
+ return false;
+
+ err = inet_pton(AF_INET6, address, buf);
+ if (err > 0)
+ return true;
+
+ return false;
+}
+
+int connman_ipaddress_set_ipv6(struct connman_ipaddress *ipaddress,
+ const char *address,
+ unsigned char prefix_length,
+ const char *gateway)
+{
+ if (!ipaddress)
+ return -EINVAL;
+
+ if (!check_ipv6_address(address))
+ return -EINVAL;
+
+ DBG("prefix_len %d address %s gateway %s",
+ prefix_length, address, gateway);
+
+ ipaddress->family = AF_INET6;
+
+ ipaddress->prefixlen = prefix_length;
+
+ g_free(ipaddress->local);
+ ipaddress->local = g_strdup(address);
+
+ g_free(ipaddress->gateway);
+ ipaddress->gateway = g_strdup(gateway);
+
+ return 0;
+}
+
+int connman_ipaddress_get_ip(struct connman_ipaddress *ipaddress,
+ const char **address,
+ unsigned char *netmask_prefix_length)
+{
+ if (!ipaddress)
+ return -EINVAL;
+
+ *netmask_prefix_length = ipaddress->prefixlen;
+ *address = ipaddress->local;
+
+ return 0;
+}
+
+int connman_ipaddress_set_ipv4(struct connman_ipaddress *ipaddress,
+ const char *address, const char *netmask, const char *gateway)
+{
+ if (!ipaddress)
+ return -EINVAL;
+
+ ipaddress->family = AF_INET;
+
+ ipaddress->prefixlen = connman_ipaddress_calc_netmask_len(netmask);
+
+ g_free(ipaddress->local);
+ ipaddress->local = g_strdup(address);
+
+ g_free(ipaddress->gateway);
+ ipaddress->gateway = g_strdup(gateway);
+
+ return 0;
+}
+
+void connman_ipaddress_set_peer(struct connman_ipaddress *ipaddress,
+ const char *peer)
+{
+ if (!ipaddress)
+ return;
+
+ g_free(ipaddress->peer);
+ ipaddress->peer = g_strdup(peer);
+}
+
+void connman_ipaddress_clear(struct connman_ipaddress *ipaddress)
+{
+ if (!ipaddress)
+ return;
+
+ ipaddress->prefixlen = 0;
+
+ g_free(ipaddress->local);
+ ipaddress->local = NULL;
+
+ g_free(ipaddress->peer);
+ ipaddress->peer = NULL;
+
+ g_free(ipaddress->broadcast);
+ ipaddress->broadcast = NULL;
+
+ g_free(ipaddress->gateway);
+ ipaddress->gateway = NULL;
+}
+
+/*
+ * Note that this copy function only copies the actual address and
+ * prefixlen. Use the other copy function to copy the whole struct.
+ */
+void connman_ipaddress_copy_address(struct connman_ipaddress *ipaddress,
+ struct connman_ipaddress *source)
+{
+ if (!ipaddress || !source)
+ return;
+
+ ipaddress->family = source->family;
+ ipaddress->prefixlen = source->prefixlen;
+
+ g_free(ipaddress->local);
+ ipaddress->local = g_strdup(source->local);
+}
+
+struct connman_ipaddress *
+connman_ipaddress_copy(struct connman_ipaddress *ipaddress)
+{
+ struct connman_ipaddress *copy;
+
+ if (!ipaddress)
+ return NULL;
+
+ copy = g_new0(struct connman_ipaddress, 1);
+
+ copy->family = ipaddress->family;
+ copy->prefixlen = ipaddress->prefixlen;
+ copy->local = g_strdup(ipaddress->local);
+ copy->peer = g_strdup(ipaddress->peer);
+ copy->broadcast = g_strdup(ipaddress->broadcast);
+ copy->gateway = g_strdup(ipaddress->gateway);
+
+ return copy;
+}
diff --git a/src/ipconfig.c b/src/ipconfig.c
new file mode 100644
index 0000000..cc932c4
--- /dev/null
+++ b/src/ipconfig.c
@@ -0,0 +1,2460 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <linux/if_link.h>
+#include <string.h>
+#include <stdlib.h>
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+#include <gdbus.h>
+#include <connman/ipaddress.h>
+
+#include "connman.h"
+
+struct connman_ipconfig {
+ int refcount;
+ int index;
+ enum connman_ipconfig_type type;
+
+ const struct connman_ipconfig_ops *ops;
+ void *ops_data;
+
+ bool enabled;
+ enum connman_ipconfig_method method;
+ struct connman_ipaddress *address;
+ struct connman_ipaddress *system;
+
+ int ipv6_privacy_config;
+ char *last_dhcp_address;
+ char **last_dhcpv6_prefixes;
+};
+
+struct connman_ipdevice {
+ int index;
+ unsigned short type;
+ unsigned int flags;
+ char *address;
+ uint16_t mtu;
+ uint32_t rx_packets;
+ uint32_t tx_packets;
+ uint32_t rx_bytes;
+ uint32_t tx_bytes;
+ uint32_t rx_errors;
+ uint32_t tx_errors;
+ uint32_t rx_dropped;
+ uint32_t tx_dropped;
+
+ GSList *address_list;
+ char *ipv4_gateway;
+ char *ipv6_gateway;
+
+ char *pac;
+
+ struct connman_ipconfig *config_ipv4;
+ struct connman_ipconfig *config_ipv6;
+
+ bool ipv6_enabled;
+ int ipv6_privacy;
+};
+
+static GHashTable *ipdevice_hash = NULL;
+static GList *ipconfig_list = NULL;
+static bool is_ipv6_supported = false;
+
+void __connman_ipconfig_clear_address(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return;
+
+ connman_ipaddress_clear(ipconfig->address);
+}
+
+static void free_address_list(struct connman_ipdevice *ipdevice)
+{
+ GSList *list;
+
+ for (list = ipdevice->address_list; list; list = list->next) {
+ struct connman_ipaddress *ipaddress = list->data;
+
+ connman_ipaddress_free(ipaddress);
+ list->data = NULL;
+ }
+
+ g_slist_free(ipdevice->address_list);
+ ipdevice->address_list = NULL;
+}
+
+static struct connman_ipaddress *find_ipaddress(struct connman_ipdevice *ipdevice,
+ unsigned char prefixlen, const char *local)
+{
+ GSList *list;
+
+ for (list = ipdevice->address_list; list; list = list->next) {
+ struct connman_ipaddress *ipaddress = list->data;
+
+ if (g_strcmp0(ipaddress->local, local) == 0 &&
+ ipaddress->prefixlen == prefixlen)
+ return ipaddress;
+ }
+
+ return NULL;
+}
+
+const char *__connman_ipconfig_type2string(enum connman_ipconfig_type type)
+{
+ switch (type) {
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ return "unknown";
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ return "IPv4";
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ return "IPv6";
+ }
+
+ return NULL;
+}
+
+static const char *type2str(unsigned short type)
+{
+ switch (type) {
+ case ARPHRD_ETHER:
+ return "ETHER";
+ case ARPHRD_LOOPBACK:
+ return "LOOPBACK";
+ case ARPHRD_PPP:
+ return "PPP";
+ case ARPHRD_NONE:
+ return "NONE";
+ case ARPHRD_VOID:
+ return "VOID";
+ }
+
+ return "";
+}
+
+static const char *scope2str(unsigned char scope)
+{
+ switch (scope) {
+ case 0:
+ return "UNIVERSE";
+ case 253:
+ return "LINK";
+ }
+
+ return "";
+}
+
+static bool get_ipv6_state(gchar *ifname)
+{
+ int disabled;
+ gchar *path;
+ FILE *f;
+ bool enabled = false;
+
+ if (!ifname)
+ path = g_strdup("/proc/sys/net/ipv6/conf/all/disable_ipv6");
+ else
+ path = g_strdup_printf(
+ "/proc/sys/net/ipv6/conf/%s/disable_ipv6", ifname);
+
+ if (!path)
+ return enabled;
+
+ f = fopen(path, "r");
+
+ g_free(path);
+
+ if (f) {
+ if (fscanf(f, "%d", &disabled) > 0)
+ enabled = !disabled;
+ fclose(f);
+ }
+
+ return enabled;
+}
+
+static void set_ipv6_state(gchar *ifname, bool enable)
+{
+ gchar *path;
+ FILE *f;
+
+ DBG("on %s", ifname);
+
+ if (!ifname)
+ path = g_strdup("/proc/sys/net/ipv6/conf/all/disable_ipv6");
+ else
+ path = g_strdup_printf(
+ "/proc/sys/net/ipv6/conf/%s/disable_ipv6", ifname);
+
+ if (!path)
+ return;
+
+ f = fopen(path, "r+");
+
+ g_free(path);
+
+ if (!f)
+ return;
+
+ if (!enable)
+ fprintf(f, "1");
+ else
+ fprintf(f, "0");
+
+ fclose(f);
+}
+
+static int get_ipv6_privacy(gchar *ifname)
+{
+ gchar *path;
+ FILE *f;
+ int value;
+
+ if (!ifname)
+ return 0;
+
+ path = g_strdup_printf("/proc/sys/net/ipv6/conf/%s/use_tempaddr",
+ ifname);
+
+ if (!path)
+ return 0;
+
+ f = fopen(path, "r");
+
+ g_free(path);
+
+ if (!f)
+ return 0;
+
+ if (fscanf(f, "%d", &value) <= 0)
+ value = 0;
+
+ fclose(f);
+
+ return value;
+}
+
+/* Enable the IPv6 privacy extension for stateless address autoconfiguration.
+ * The privacy extension is described in RFC 3041 and RFC 4941
+ */
+static void set_ipv6_privacy(gchar *ifname, int value)
+{
+ gchar *path;
+ FILE *f;
+
+ if (!ifname)
+ return;
+
+ path = g_strdup_printf("/proc/sys/net/ipv6/conf/%s/use_tempaddr",
+ ifname);
+
+ if (!path)
+ return;
+
+ if (value < 0)
+ value = 0;
+
+ f = fopen(path, "r+");
+
+ g_free(path);
+
+ if (!f)
+ return;
+
+ fprintf(f, "%d", value);
+ fclose(f);
+}
+
+static int get_rp_filter(void)
+{
+ FILE *f;
+ int value = -EINVAL, tmp;
+
+ f = fopen("/proc/sys/net/ipv4/conf/all/rp_filter", "r");
+
+ if (f) {
+ if (fscanf(f, "%d", &tmp) == 1)
+ value = tmp;
+ fclose(f);
+ }
+
+ return value;
+}
+
+static void set_rp_filter(int value)
+{
+ FILE *f;
+
+ f = fopen("/proc/sys/net/ipv4/conf/all/rp_filter", "r+");
+
+ if (!f)
+ return;
+
+ fprintf(f, "%d", value);
+
+ fclose(f);
+}
+
+int __connman_ipconfig_set_rp_filter()
+{
+ int value;
+
+ value = get_rp_filter();
+
+ if (value < 0)
+ return value;
+
+ set_rp_filter(2);
+
+ connman_info("rp_filter set to 2 (loose mode routing), "
+ "old value was %d", value);
+
+ return value;
+}
+
+void __connman_ipconfig_unset_rp_filter(int old_value)
+{
+ set_rp_filter(old_value);
+
+ connman_info("rp_filter restored to %d", old_value);
+}
+
+bool __connman_ipconfig_ipv6_privacy_enabled(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return false;
+
+ return ipconfig->ipv6_privacy_config == 0 ? FALSE : TRUE;
+}
+
+bool __connman_ipconfig_ipv6_is_enabled(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+ char *ifname;
+ bool ret;
+
+ if (!ipconfig)
+ return false;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return false;
+
+ ifname = connman_inet_ifname(ipconfig->index);
+ ret = get_ipv6_state(ifname);
+ g_free(ifname);
+
+ return ret;
+}
+
+static void free_ipdevice(gpointer data)
+{
+ struct connman_ipdevice *ipdevice = data;
+ char *ifname = connman_inet_ifname(ipdevice->index);
+
+ connman_info("%s {remove} index %d", ifname, ipdevice->index);
+
+ if (ipdevice->config_ipv4) {
+ __connman_ipconfig_unref(ipdevice->config_ipv4);
+ ipdevice->config_ipv4 = NULL;
+ }
+
+ if (ipdevice->config_ipv6) {
+ __connman_ipconfig_unref(ipdevice->config_ipv6);
+ ipdevice->config_ipv6 = NULL;
+ }
+
+ free_address_list(ipdevice);
+ g_free(ipdevice->ipv4_gateway);
+ g_free(ipdevice->ipv6_gateway);
+ g_free(ipdevice->pac);
+
+ g_free(ipdevice->address);
+
+ if (ifname) {
+ set_ipv6_state(ifname, ipdevice->ipv6_enabled);
+ set_ipv6_privacy(ifname, ipdevice->ipv6_privacy);
+ }
+
+ g_free(ifname);
+ g_free(ipdevice);
+}
+
+static void __connman_ipconfig_lower_up(struct connman_ipdevice *ipdevice)
+{
+ DBG("ipconfig ipv4 %p ipv6 %p", ipdevice->config_ipv4,
+ ipdevice->config_ipv6);
+}
+
+static void __connman_ipconfig_lower_down(struct connman_ipdevice *ipdevice)
+{
+ DBG("ipconfig ipv4 %p ipv6 %p", ipdevice->config_ipv4,
+ ipdevice->config_ipv6);
+
+ if (ipdevice->config_ipv4)
+ connman_inet_clear_address(ipdevice->index,
+ ipdevice->config_ipv4->address);
+
+ if (ipdevice->config_ipv6)
+ connman_inet_clear_ipv6_address(ipdevice->index,
+ ipdevice->config_ipv6->address->local,
+ ipdevice->config_ipv6->address->prefixlen);
+}
+
+static void update_stats(struct connman_ipdevice *ipdevice,
+ const char *ifname, struct rtnl_link_stats *stats)
+{
+ struct connman_service *service;
+
+ if (stats->rx_packets == 0 && stats->tx_packets == 0)
+ return;
+
+ connman_info("%s {RX} %u packets %u bytes", ifname,
+ stats->rx_packets, stats->rx_bytes);
+ connman_info("%s {TX} %u packets %u bytes", ifname,
+ stats->tx_packets, stats->tx_bytes);
+
+ if (!ipdevice->config_ipv4 && !ipdevice->config_ipv6)
+ return;
+
+ service = __connman_service_lookup_from_index(ipdevice->index);
+
+ DBG("service %p", service);
+
+ if (!service)
+ return;
+
+ ipdevice->rx_packets = stats->rx_packets;
+ ipdevice->tx_packets = stats->tx_packets;
+ ipdevice->rx_bytes = stats->rx_bytes;
+ ipdevice->tx_bytes = stats->tx_bytes;
+ ipdevice->rx_errors = stats->rx_errors;
+ ipdevice->tx_errors = stats->tx_errors;
+ ipdevice->rx_dropped = stats->rx_dropped;
+ ipdevice->tx_dropped = stats->tx_dropped;
+
+ __connman_service_notify(service,
+ ipdevice->rx_packets, ipdevice->tx_packets,
+ ipdevice->rx_bytes, ipdevice->tx_bytes,
+ ipdevice->rx_errors, ipdevice->tx_errors,
+ ipdevice->rx_dropped, ipdevice->tx_dropped);
+}
+
+struct connman_ipdevice *
+connman_ipdevice_lookup_from_index(int index)
+{
+ return g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+}
+
+void
+connman_ipdevice_set_address(struct connman_ipdevice *ipdevice, const char* address)
+{
+ if(ipdevice->address)
+ g_free(ipdevice->address);
+
+ if(0 != strcmp(address,"00:00:00:00:00:00"))
+ ipdevice->address = g_strdup(address);
+ else
+ ipdevice->address = NULL;
+}
+
+void __connman_ipconfig_newlink(int index, unsigned short type,
+ unsigned int flags, const char *address,
+ unsigned short mtu,
+ struct rtnl_link_stats *stats)
+{
+ struct connman_ipdevice *ipdevice;
+ GList *list, *ipconfig_copy;
+ GString *str;
+ bool up = false, down = false;
+ bool lower_up = false, lower_down = false;
+ char *ifname;
+
+ DBG("index %d", index);
+
+ if (type == ARPHRD_LOOPBACK)
+ return;
+
+ ifname = connman_inet_ifname(index);
+
+ // null name means the lookup failed so ignore the request.
+ // This will cause bad side effects later on.
+ // For example, a NULL means to disable ipv6 for all!
+ if (!ifname) {
+ DBG("interface name is (null)");
+ goto out;
+ }
+
+ if (__connman_device_isfiltered(ifname)) {
+ connman_info("Ignoring interface %s (filtered)", ifname);
+ goto out;
+ }
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (ipdevice)
+ goto update;
+
+ ipdevice = g_try_new0(struct connman_ipdevice, 1);
+ if (!ipdevice)
+ goto out;
+
+ ipdevice->index = index;
+ ipdevice->type = type;
+
+ ipdevice->ipv6_enabled = get_ipv6_state(ifname);
+ ipdevice->ipv6_privacy = get_ipv6_privacy(ifname);
+
+ connman_ipdevice_set_address(ipdevice, address);
+
+ g_hash_table_insert(ipdevice_hash, GINT_TO_POINTER(index), ipdevice);
+
+ connman_info("%s {create} index %d type %d <%s>", ifname,
+ index, type, type2str(type));
+
+update:
+ ipdevice->mtu = mtu;
+
+ update_stats(ipdevice, ifname, stats);
+
+ if (flags == ipdevice->flags)
+ goto out;
+
+ if ((ipdevice->flags & IFF_UP) != (flags & IFF_UP)) {
+ if (flags & IFF_UP)
+ up = true;
+ else
+ down = true;
+ }
+
+ if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) !=
+ (flags & (IFF_RUNNING | IFF_LOWER_UP))) {
+ if ((flags & (IFF_RUNNING | IFF_LOWER_UP)) ==
+ (IFF_RUNNING | IFF_LOWER_UP))
+ lower_up = true;
+ else if ((flags & (IFF_RUNNING | IFF_LOWER_UP)) == 0)
+ lower_down = true;
+ }
+
+ ipdevice->flags = flags;
+
+ str = g_string_new(NULL);
+ if (!str)
+ goto out;
+
+ if (flags & IFF_UP)
+ g_string_append(str, "UP");
+ else
+ g_string_append(str, "DOWN");
+
+ if (flags & IFF_RUNNING)
+ g_string_append(str, ",RUNNING");
+
+ if (flags & IFF_LOWER_UP)
+ g_string_append(str, ",LOWER_UP");
+
+ connman_info("%s {update} flags %u <%s>", ifname, flags, str->str);
+
+ g_string_free(str, TRUE);
+
+ ipconfig_copy = g_list_copy(ipconfig_list);
+
+ for (list = g_list_first(ipconfig_copy); list;
+ list = g_list_next(list)) {
+ struct connman_ipconfig *ipconfig = list->data;
+
+ if (index != ipconfig->index)
+ continue;
+
+ if (!ipconfig->ops)
+ continue;
+
+ if (up && ipconfig->ops->up)
+ ipconfig->ops->up(ipconfig, ifname);
+ if (lower_up && ipconfig->ops->lower_up)
+ ipconfig->ops->lower_up(ipconfig, ifname);
+
+ if (lower_down && ipconfig->ops->lower_down)
+ ipconfig->ops->lower_down(ipconfig, ifname);
+ if (down && ipconfig->ops->down)
+ ipconfig->ops->down(ipconfig, ifname);
+ }
+
+ g_list_free(ipconfig_copy);
+
+ if (lower_up)
+ __connman_ipconfig_lower_up(ipdevice);
+ if (lower_down)
+ __connman_ipconfig_lower_down(ipdevice);
+
+out:
+ g_free(ifname);
+}
+
+void __connman_ipconfig_dellink(int index, struct rtnl_link_stats *stats)
+{
+ struct connman_ipdevice *ipdevice;
+ GList *list;
+ char *ifname;
+
+ DBG("index %d", index);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return;
+
+ ifname = connman_inet_ifname(index);
+
+ update_stats(ipdevice, ifname, stats);
+
+ for (list = g_list_first(ipconfig_list); list;
+ list = g_list_next(list)) {
+ struct connman_ipconfig *ipconfig = list->data;
+
+ if (index != ipconfig->index)
+ continue;
+
+ ipconfig->index = -1;
+
+ if (!ipconfig->ops)
+ continue;
+
+ if (ipconfig->ops->lower_down)
+ ipconfig->ops->lower_down(ipconfig, ifname);
+ if (ipconfig->ops->down)
+ ipconfig->ops->down(ipconfig, ifname);
+ }
+
+ g_free(ifname);
+
+ __connman_ipconfig_lower_down(ipdevice);
+
+ g_hash_table_remove(ipdevice_hash, GINT_TO_POINTER(index));
+}
+
+static inline gint check_duplicate_address(gconstpointer a, gconstpointer b)
+{
+ const struct connman_ipaddress *addr1 = a;
+ const struct connman_ipaddress *addr2 = b;
+
+ if (addr1->prefixlen != addr2->prefixlen)
+ return addr2->prefixlen - addr1->prefixlen;
+
+ return g_strcmp0(addr1->local, addr2->local);
+}
+
+int __connman_ipconfig_newaddr(int index, int family, const char *label,
+ unsigned char prefixlen, const char *address)
+{
+ struct connman_ipdevice *ipdevice;
+ struct connman_ipaddress *ipaddress;
+ enum connman_ipconfig_type type;
+ GList *list;
+ char *ifname;
+
+ DBG("index %d", index);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return -ENXIO;
+
+ ipaddress = connman_ipaddress_alloc(family);
+ if (!ipaddress)
+ return -ENOMEM;
+
+ ipaddress->prefixlen = prefixlen;
+ ipaddress->local = g_strdup(address);
+
+ if (g_slist_find_custom(ipdevice->address_list, ipaddress,
+ check_duplicate_address)) {
+ connman_ipaddress_free(ipaddress);
+ return -EALREADY;
+ }
+
+ if (family == AF_INET)
+ type = CONNMAN_IPCONFIG_TYPE_IPV4;
+ else if (family == AF_INET6)
+ type = CONNMAN_IPCONFIG_TYPE_IPV6;
+ else
+ return -EINVAL;
+
+ ipdevice->address_list = g_slist_prepend(ipdevice->address_list,
+ ipaddress);
+
+ ifname = connman_inet_ifname(index);
+ connman_info("%s {add} address %s/%u label %s family %d",
+ ifname, address, prefixlen, label, family);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ __connman_ippool_newaddr(index, address, prefixlen);
+
+ if (ipdevice->config_ipv4 && family == AF_INET)
+ connman_ipaddress_copy_address(ipdevice->config_ipv4->system,
+ ipaddress);
+
+ else if (ipdevice->config_ipv6 && family == AF_INET6)
+ connman_ipaddress_copy_address(ipdevice->config_ipv6->system,
+ ipaddress);
+ else
+ goto out;
+
+ if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) != (IFF_RUNNING | IFF_LOWER_UP))
+ goto out;
+
+ for (list = g_list_first(ipconfig_list); list;
+ list = g_list_next(list)) {
+ struct connman_ipconfig *ipconfig = list->data;
+
+ if (index != ipconfig->index)
+ continue;
+
+ if (type != ipconfig->type)
+ continue;
+
+ if (!ipconfig->ops)
+ continue;
+
+ if (ipconfig->ops->ip_bound)
+ ipconfig->ops->ip_bound(ipconfig, ifname);
+ }
+
+out:
+ g_free(ifname);
+ return 0;
+}
+
+void __connman_ipconfig_deladdr(int index, int family, const char *label,
+ unsigned char prefixlen, const char *address)
+{
+ struct connman_ipdevice *ipdevice;
+ struct connman_ipaddress *ipaddress;
+ enum connman_ipconfig_type type;
+ GList *list;
+ char *ifname;
+
+ DBG("index %d", index);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return;
+
+ ipaddress = find_ipaddress(ipdevice, prefixlen, address);
+ if (!ipaddress)
+ return;
+
+ if (family == AF_INET)
+ type = CONNMAN_IPCONFIG_TYPE_IPV4;
+ else if (family == AF_INET6)
+ type = CONNMAN_IPCONFIG_TYPE_IPV6;
+ else
+ return;
+
+ ipdevice->address_list = g_slist_remove(ipdevice->address_list,
+ ipaddress);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ __connman_ippool_deladdr(index, address, prefixlen);
+
+ connman_ipaddress_clear(ipaddress);
+ g_free(ipaddress);
+
+ ifname = connman_inet_ifname(index);
+ connman_info("%s {del} address %s/%u label %s", ifname,
+ address, prefixlen, label);
+
+ if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) != (IFF_RUNNING | IFF_LOWER_UP))
+ goto out;
+
+ if (g_slist_length(ipdevice->address_list) > 0)
+ goto out;
+
+ for (list = g_list_first(ipconfig_list); list;
+ list = g_list_next(list)) {
+ struct connman_ipconfig *ipconfig = list->data;
+
+ if (index != ipconfig->index)
+ continue;
+
+ if (type != ipconfig->type)
+ continue;
+
+ if (!ipconfig->ops)
+ continue;
+
+ if (ipconfig->ops->ip_release)
+ ipconfig->ops->ip_release(ipconfig, ifname);
+ }
+
+out:
+ g_free(ifname);
+}
+
+void __connman_ipconfig_newroute(int index, int family, unsigned char scope,
+ const char *dst, const char *gateway)
+{
+ struct connman_ipdevice *ipdevice;
+ char *ifname;
+
+ DBG("index %d", index);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return;
+
+ ifname = connman_inet_ifname(index);
+
+ if (scope == 0 && (g_strcmp0(dst, "0.0.0.0") == 0 ||
+ g_strcmp0(dst, "::") == 0)) {
+ GList *config_list;
+ enum connman_ipconfig_type type;
+
+ if (family == AF_INET6) {
+ type = CONNMAN_IPCONFIG_TYPE_IPV6;
+ g_free(ipdevice->ipv6_gateway);
+ ipdevice->ipv6_gateway = g_strdup(gateway);
+
+ if (ipdevice->config_ipv6 &&
+ ipdevice->config_ipv6->system) {
+ g_free(ipdevice->config_ipv6->system->gateway);
+ ipdevice->config_ipv6->system->gateway =
+ g_strdup(gateway);
+ }
+ } else if (family == AF_INET) {
+ type = CONNMAN_IPCONFIG_TYPE_IPV4;
+ g_free(ipdevice->ipv4_gateway);
+ ipdevice->ipv4_gateway = g_strdup(gateway);
+
+ if (ipdevice->config_ipv4 &&
+ ipdevice->config_ipv4->system) {
+ g_free(ipdevice->config_ipv4->system->gateway);
+ ipdevice->config_ipv4->system->gateway =
+ g_strdup(gateway);
+ }
+ } else
+ goto out;
+
+ for (config_list = g_list_first(ipconfig_list); config_list;
+ config_list = g_list_next(config_list)) {
+ struct connman_ipconfig *ipconfig = config_list->data;
+
+ if (index != ipconfig->index)
+ continue;
+
+ if (type != ipconfig->type)
+ continue;
+
+ if (!ipconfig->ops)
+ continue;
+
+ if (ipconfig->ops->route_set)
+ ipconfig->ops->route_set(ipconfig, ifname);
+ }
+ }
+
+ connman_info("%s {add} route %s gw %s scope %u <%s>",
+ ifname, dst, gateway, scope, scope2str(scope));
+
+out:
+ g_free(ifname);
+}
+
+void __connman_ipconfig_delroute(int index, int family, unsigned char scope,
+ const char *dst, const char *gateway)
+{
+ struct connman_ipdevice *ipdevice;
+ char *ifname;
+
+ DBG("index %d", index);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return;
+
+ ifname = connman_inet_ifname(index);
+
+ if (scope == 0 && (g_strcmp0(dst, "0.0.0.0") == 0 ||
+ g_strcmp0(dst, "::") == 0)) {
+ GList *config_list;
+ enum connman_ipconfig_type type;
+
+ if (family == AF_INET6) {
+ type = CONNMAN_IPCONFIG_TYPE_IPV6;
+ g_free(ipdevice->ipv6_gateway);
+ ipdevice->ipv6_gateway = NULL;
+
+ if (ipdevice->config_ipv6 &&
+ ipdevice->config_ipv6->system) {
+ g_free(ipdevice->config_ipv6->system->gateway);
+ ipdevice->config_ipv6->system->gateway = NULL;
+ }
+ } else if (family == AF_INET) {
+ type = CONNMAN_IPCONFIG_TYPE_IPV4;
+ g_free(ipdevice->ipv4_gateway);
+ ipdevice->ipv4_gateway = NULL;
+
+ if (ipdevice->config_ipv4 &&
+ ipdevice->config_ipv4->system) {
+ g_free(ipdevice->config_ipv4->system->gateway);
+ ipdevice->config_ipv4->system->gateway = NULL;
+ }
+ } else
+ goto out;
+
+ for (config_list = g_list_first(ipconfig_list); config_list;
+ config_list = g_list_next(config_list)) {
+ struct connman_ipconfig *ipconfig = config_list->data;
+
+ if (index != ipconfig->index)
+ continue;
+
+ if (type != ipconfig->type)
+ continue;
+
+ if (!ipconfig->ops)
+ continue;
+
+ if (ipconfig->ops->route_unset)
+ ipconfig->ops->route_unset(ipconfig, ifname);
+ }
+ }
+
+ connman_info("%s {del} route %s gw %s scope %u <%s>",
+ ifname, dst, gateway, scope, scope2str(scope));
+
+out:
+ g_free(ifname);
+}
+
+void __connman_ipconfig_foreach(void (*function) (int index, void *user_data),
+ void *user_data)
+{
+ GList *list, *keys;
+
+ keys = g_hash_table_get_keys(ipdevice_hash);
+ if (!keys)
+ return;
+
+ for (list = g_list_first(keys); list; list = g_list_next(list)) {
+ int index = GPOINTER_TO_INT(list->data);
+
+ function(index, user_data);
+ }
+
+ g_list_free(keys);
+}
+
+enum connman_ipconfig_type __connman_ipconfig_get_config_type(
+ struct connman_ipconfig *ipconfig)
+{
+ return ipconfig ? ipconfig->type : CONNMAN_IPCONFIG_TYPE_UNKNOWN;
+}
+
+unsigned short __connman_ipconfig_get_type_from_index(int index)
+{
+ struct connman_ipdevice *ipdevice;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return ARPHRD_VOID;
+
+ return ipdevice->type;
+}
+
+unsigned int __connman_ipconfig_get_flags_from_index(int index)
+{
+ struct connman_ipdevice *ipdevice;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return 0;
+
+ return ipdevice->flags;
+}
+
+const char *__connman_ipconfig_get_gateway_from_index(int index,
+ enum connman_ipconfig_type type)
+{
+ struct connman_ipdevice *ipdevice;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return NULL;
+
+ if (type != CONNMAN_IPCONFIG_TYPE_IPV6) {
+ if (ipdevice->ipv4_gateway)
+ return ipdevice->ipv4_gateway;
+
+ if (ipdevice->config_ipv4 &&
+ ipdevice->config_ipv4->address)
+ return ipdevice->config_ipv4->address->gateway;
+ }
+
+ if (type != CONNMAN_IPCONFIG_TYPE_IPV4) {
+ if (ipdevice->ipv6_gateway)
+ return ipdevice->ipv6_gateway;
+
+ if (ipdevice->config_ipv6 &&
+ ipdevice->config_ipv6->address)
+ return ipdevice->config_ipv6->address->gateway;
+ }
+
+ return NULL;
+}
+
+void __connman_ipconfig_set_index(struct connman_ipconfig *ipconfig, int index)
+{
+ ipconfig->index = index;
+}
+
+const char *__connman_ipconfig_get_local(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->local;
+}
+
+void __connman_ipconfig_set_local(struct connman_ipconfig *ipconfig,
+ const char *address)
+{
+ if (!ipconfig->address)
+ return;
+
+ g_free(ipconfig->address->local);
+ ipconfig->address->local = g_strdup(address);
+}
+
+const char *__connman_ipconfig_get_peer(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->peer;
+}
+
+void __connman_ipconfig_set_peer(struct connman_ipconfig *ipconfig,
+ const char *address)
+{
+ if (!ipconfig->address)
+ return;
+
+ g_free(ipconfig->address->peer);
+ ipconfig->address->peer = g_strdup(address);
+}
+
+const char *__connman_ipconfig_get_broadcast(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->broadcast;
+}
+
+void __connman_ipconfig_set_broadcast(struct connman_ipconfig *ipconfig,
+ const char *broadcast)
+{
+ if (!ipconfig->address)
+ return;
+
+ g_free(ipconfig->address->broadcast);
+ ipconfig->address->broadcast = g_strdup(broadcast);
+}
+
+const char *__connman_ipconfig_get_gateway(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->gateway;
+}
+
+void __connman_ipconfig_set_gateway(struct connman_ipconfig *ipconfig,
+ const char *gateway)
+{
+ DBG("");
+
+ if (!ipconfig->address)
+ return;
+ g_free(ipconfig->address->gateway);
+ ipconfig->address->gateway = g_strdup(gateway);
+}
+
+int __connman_ipconfig_gateway_add(struct connman_ipconfig *ipconfig)
+{
+ struct connman_service *service;
+
+ DBG("");
+
+ if (!ipconfig->address)
+ return -EINVAL;
+
+ service = __connman_service_lookup_from_index(ipconfig->index);
+ if (!service)
+ return -EINVAL;
+
+ DBG("type %d gw %s peer %s", ipconfig->type,
+ ipconfig->address->gateway, ipconfig->address->peer);
+
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6 ||
+ ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ return __connman_connection_gateway_add(service,
+ ipconfig->address->gateway,
+ ipconfig->type,
+ ipconfig->address->peer);
+
+ return 0;
+}
+
+void __connman_ipconfig_gateway_remove(struct connman_ipconfig *ipconfig)
+{
+ struct connman_service *service;
+
+ DBG("");
+
+ service = __connman_service_lookup_from_index(ipconfig->index);
+ if (service)
+ __connman_connection_gateway_remove(service, ipconfig->type);
+}
+
+unsigned char __connman_ipconfig_get_prefixlen(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return 0;
+
+ return ipconfig->address->prefixlen;
+}
+
+void __connman_ipconfig_set_prefixlen(struct connman_ipconfig *ipconfig,
+ unsigned char prefixlen)
+{
+ if (!ipconfig->address)
+ return;
+
+ ipconfig->address->prefixlen = prefixlen;
+}
+
+static struct connman_ipconfig *create_ipv6config(int index)
+{
+ struct connman_ipconfig *ipv6config;
+ struct connman_ipdevice *ipdevice;
+
+ DBG("index %d", index);
+
+ ipv6config = g_try_new0(struct connman_ipconfig, 1);
+ if (!ipv6config)
+ return NULL;
+
+ ipv6config->refcount = 1;
+
+ ipv6config->index = index;
+ ipv6config->enabled = false;
+ ipv6config->type = CONNMAN_IPCONFIG_TYPE_IPV6;
+
+ if (!is_ipv6_supported)
+ ipv6config->method = CONNMAN_IPCONFIG_METHOD_OFF;
+ else
+ ipv6config->method = CONNMAN_IPCONFIG_METHOD_AUTO;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (ipdevice)
+ ipv6config->ipv6_privacy_config = ipdevice->ipv6_privacy;
+
+ ipv6config->address = connman_ipaddress_alloc(AF_INET6);
+ if (!ipv6config->address) {
+ g_free(ipv6config);
+ return NULL;
+ }
+
+ ipv6config->system = connman_ipaddress_alloc(AF_INET6);
+
+ DBG("ipconfig %p method %s", ipv6config,
+ __connman_ipconfig_method2string(ipv6config->method));
+
+ return ipv6config;
+}
+
+/**
+ * connman_ipconfig_create:
+ *
+ * Allocate a new ipconfig structure.
+ *
+ * Returns: a newly-allocated #connman_ipconfig structure
+ */
+struct connman_ipconfig *__connman_ipconfig_create(int index,
+ enum connman_ipconfig_type type)
+{
+ struct connman_ipconfig *ipconfig;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ return create_ipv6config(index);
+
+ DBG("index %d", index);
+
+ ipconfig = g_try_new0(struct connman_ipconfig, 1);
+ if (!ipconfig)
+ return NULL;
+
+ ipconfig->refcount = 1;
+
+ ipconfig->index = index;
+ ipconfig->enabled = false;
+ ipconfig->type = CONNMAN_IPCONFIG_TYPE_IPV4;
+
+ ipconfig->address = connman_ipaddress_alloc(AF_INET);
+ if (!ipconfig->address) {
+ g_free(ipconfig);
+ return NULL;
+ }
+
+ ipconfig->system = connman_ipaddress_alloc(AF_INET);
+
+ DBG("ipconfig %p", ipconfig);
+
+ return ipconfig;
+}
+
+
+/**
+ * connman_ipconfig_ref:
+ * @ipconfig: ipconfig structure
+ *
+ * Increase reference counter of ipconfig
+ */
+struct connman_ipconfig *
+__connman_ipconfig_ref_debug(struct connman_ipconfig *ipconfig,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", ipconfig, ipconfig->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&ipconfig->refcount, 1);
+
+ return ipconfig;
+}
+
+/**
+ * connman_ipconfig_unref:
+ * @ipconfig: ipconfig structure
+ *
+ * Decrease reference counter of ipconfig
+ */
+void __connman_ipconfig_unref_debug(struct connman_ipconfig *ipconfig,
+ const char *file, int line, const char *caller)
+{
+ if (!ipconfig)
+ return;
+
+ DBG("%p ref %d by %s:%d:%s()", ipconfig, ipconfig->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&ipconfig->refcount, 1) != 1)
+ return;
+
+ if (__connman_ipconfig_disable(ipconfig) < 0)
+ ipconfig_list = g_list_remove(ipconfig_list, ipconfig);
+
+ __connman_ipconfig_set_ops(ipconfig, NULL);
+
+ connman_ipaddress_free(ipconfig->system);
+ connman_ipaddress_free(ipconfig->address);
+ g_free(ipconfig->last_dhcp_address);
+ g_strfreev(ipconfig->last_dhcpv6_prefixes);
+ g_free(ipconfig);
+}
+
+/**
+ * connman_ipconfig_get_data:
+ * @ipconfig: ipconfig structure
+ *
+ * Get private data pointer
+ */
+void *__connman_ipconfig_get_data(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return NULL;
+
+ return ipconfig->ops_data;
+}
+
+/**
+ * connman_ipconfig_set_data:
+ * @ipconfig: ipconfig structure
+ * @data: data pointer
+ *
+ * Set private data pointer
+ */
+void __connman_ipconfig_set_data(struct connman_ipconfig *ipconfig, void *data)
+{
+ ipconfig->ops_data = data;
+}
+
+/**
+ * connman_ipconfig_get_index:
+ * @ipconfig: ipconfig structure
+ *
+ * Get interface index
+ */
+int __connman_ipconfig_get_index(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return -1;
+
+ return ipconfig->index;
+}
+
+/**
+ * connman_ipconfig_set_ops:
+ * @ipconfig: ipconfig structure
+ * @ops: operation callbacks
+ *
+ * Set the operation callbacks
+ */
+void __connman_ipconfig_set_ops(struct connman_ipconfig *ipconfig,
+ const struct connman_ipconfig_ops *ops)
+{
+ ipconfig->ops = ops;
+}
+
+/**
+ * connman_ipconfig_set_method:
+ * @ipconfig: ipconfig structure
+ * @method: configuration method
+ *
+ * Set the configuration method
+ */
+int __connman_ipconfig_set_method(struct connman_ipconfig *ipconfig,
+ enum connman_ipconfig_method method)
+{
+ ipconfig->method = method;
+
+ return 0;
+}
+
+enum connman_ipconfig_method __connman_ipconfig_get_method(
+ struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+
+ return ipconfig->method;
+}
+
+int __connman_ipconfig_address_add(struct connman_ipconfig *ipconfig)
+{
+ DBG("");
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ return connman_inet_set_address(ipconfig->index,
+ ipconfig->address);
+ else if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ return connman_inet_set_ipv6_address(
+ ipconfig->index, ipconfig->address);
+ }
+
+ return 0;
+}
+
+int __connman_ipconfig_address_remove(struct connman_ipconfig *ipconfig)
+{
+ int err;
+
+ DBG("");
+
+ if (!ipconfig)
+ return 0;
+
+ DBG("method %d", ipconfig->method);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ err = __connman_ipconfig_address_unset(ipconfig);
+ connman_ipaddress_clear(ipconfig->address);
+
+ return err;
+ }
+
+ return 0;
+}
+
+int __connman_ipconfig_address_unset(struct connman_ipconfig *ipconfig)
+{
+ int err;
+
+ DBG("");
+
+ if (!ipconfig)
+ return 0;
+
+ DBG("method %d", ipconfig->method);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ err = connman_inet_clear_address(ipconfig->index,
+ ipconfig->address);
+ else if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ err = connman_inet_clear_ipv6_address(
+ ipconfig->index,
+ ipconfig->address->local,
+ ipconfig->address->prefixlen);
+ else
+ err = -EINVAL;
+
+ return err;
+ }
+
+ return 0;
+}
+
+int __connman_ipconfig_set_proxy_autoconfig(struct connman_ipconfig *ipconfig,
+ const char *url)
+{
+ struct connman_ipdevice *ipdevice;
+
+ DBG("ipconfig %p", ipconfig);
+
+ if (!ipconfig || ipconfig->index < 0)
+ return -ENODEV;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return -ENXIO;
+
+ g_free(ipdevice->pac);
+ ipdevice->pac = g_strdup(url);
+
+ return 0;
+}
+
+const char *__connman_ipconfig_get_proxy_autoconfig(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+
+ DBG("ipconfig %p", ipconfig);
+
+ if (!ipconfig || ipconfig->index < 0)
+ return NULL;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return NULL;
+
+ return ipdevice->pac;
+}
+
+void __connman_ipconfig_set_dhcp_address(struct connman_ipconfig *ipconfig,
+ const char *address)
+{
+ if (!ipconfig)
+ return;
+
+ g_free(ipconfig->last_dhcp_address);
+ ipconfig->last_dhcp_address = g_strdup(address);
+}
+
+char *__connman_ipconfig_get_dhcp_address(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return NULL;
+
+ return ipconfig->last_dhcp_address;
+}
+
+void __connman_ipconfig_set_dhcpv6_prefixes(struct connman_ipconfig *ipconfig,
+ char **prefixes)
+{
+ if (!ipconfig)
+ return;
+
+ g_strfreev(ipconfig->last_dhcpv6_prefixes);
+ ipconfig->last_dhcpv6_prefixes = prefixes;
+}
+
+char **__connman_ipconfig_get_dhcpv6_prefixes(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return NULL;
+
+ return ipconfig->last_dhcpv6_prefixes;
+}
+
+static void disable_ipv6(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+ char *ifname;
+
+ DBG("");
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return;
+
+ ifname = connman_inet_ifname(ipconfig->index);
+
+ if (ifname)
+ set_ipv6_state(ifname, false);
+
+ g_free(ifname);
+}
+
+static void enable_ipv6(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+ char *ifname;
+
+ DBG("");
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return;
+
+ ifname = connman_inet_ifname(ipconfig->index);
+
+ if (ipconfig->method == CONNMAN_IPCONFIG_METHOD_AUTO)
+ set_ipv6_privacy(ifname, ipconfig->ipv6_privacy_config);
+
+ set_ipv6_state(ifname, true);
+
+ g_free(ifname);
+}
+
+void __connman_ipconfig_enable_ipv6(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig || ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6)
+ return;
+
+ enable_ipv6(ipconfig);
+}
+
+void __connman_ipconfig_disable_ipv6(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig || ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6)
+ return;
+
+ disable_ipv6(ipconfig);
+}
+
+bool __connman_ipconfig_is_usable(struct connman_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return false;
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ return false;
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ break;
+ }
+
+ return true;
+}
+
+int __connman_ipconfig_enable(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+ bool up = false, down = false;
+ bool lower_up = false, lower_down = false;
+ enum connman_ipconfig_type type;
+ char *ifname;
+
+ DBG("ipconfig %p", ipconfig);
+
+ if (!ipconfig || ipconfig->index < 0)
+ return -ENODEV;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return -ENXIO;
+
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ if (ipdevice->config_ipv4 == ipconfig)
+ return -EALREADY;
+ type = CONNMAN_IPCONFIG_TYPE_IPV4;
+ } else if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ if (ipdevice->config_ipv6 == ipconfig)
+ return -EALREADY;
+ type = CONNMAN_IPCONFIG_TYPE_IPV6;
+ } else
+ return -EINVAL;
+
+ ipconfig->enabled = true;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+ ipdevice->config_ipv4) {
+ ipconfig_list = g_list_remove(ipconfig_list,
+ ipdevice->config_ipv4);
+
+ connman_ipaddress_clear(ipdevice->config_ipv4->system);
+
+ __connman_ipconfig_unref(ipdevice->config_ipv4);
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+ ipdevice->config_ipv6) {
+ ipconfig_list = g_list_remove(ipconfig_list,
+ ipdevice->config_ipv6);
+
+ connman_ipaddress_clear(ipdevice->config_ipv6->system);
+
+ __connman_ipconfig_unref(ipdevice->config_ipv6);
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ ipdevice->config_ipv4 = __connman_ipconfig_ref(ipconfig);
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ ipdevice->config_ipv6 = __connman_ipconfig_ref(ipconfig);
+
+ enable_ipv6(ipdevice->config_ipv6);
+ }
+ ipconfig_list = g_list_append(ipconfig_list, ipconfig);
+
+ if (ipdevice->flags & IFF_UP)
+ up = true;
+ else
+ down = true;
+
+ if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) ==
+ (IFF_RUNNING | IFF_LOWER_UP))
+ lower_up = true;
+ else if ((ipdevice->flags & (IFF_RUNNING | IFF_LOWER_UP)) == 0)
+ lower_down = true;
+
+ ifname = connman_inet_ifname(ipconfig->index);
+
+ if (up && ipconfig->ops->up)
+ ipconfig->ops->up(ipconfig, ifname);
+ if (lower_up && ipconfig->ops->lower_up)
+ ipconfig->ops->lower_up(ipconfig, ifname);
+
+ if (lower_down && ipconfig->ops->lower_down)
+ ipconfig->ops->lower_down(ipconfig, ifname);
+ if (down && ipconfig->ops->down)
+ ipconfig->ops->down(ipconfig, ifname);
+
+ g_free(ifname);
+
+ return 0;
+}
+
+int __connman_ipconfig_disable(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+
+ DBG("ipconfig %p", ipconfig);
+
+ if (!ipconfig || ipconfig->index < 0)
+ return -ENODEV;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return -ENXIO;
+
+ if (!ipdevice->config_ipv4 && !ipdevice->config_ipv6)
+ return -EINVAL;
+
+ ipconfig->enabled = false;
+
+ if (ipdevice->config_ipv4 == ipconfig) {
+ ipconfig_list = g_list_remove(ipconfig_list, ipconfig);
+
+ connman_ipaddress_clear(ipdevice->config_ipv4->system);
+ __connman_ipconfig_unref(ipdevice->config_ipv4);
+ ipdevice->config_ipv4 = NULL;
+ return 0;
+ }
+
+ if (ipdevice->config_ipv6 == ipconfig) {
+ ipconfig_list = g_list_remove(ipconfig_list, ipconfig);
+
+ connman_ipaddress_clear(ipdevice->config_ipv6->system);
+ __connman_ipconfig_unref(ipdevice->config_ipv6);
+ ipdevice->config_ipv6 = NULL;
+ return 0;
+ }
+
+ return -EINVAL;
+}
+
+const char *__connman_ipconfig_method2string(enum connman_ipconfig_method method)
+{
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ return "off";
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ return "fixed";
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ return "manual";
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ return "dhcp";
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ return "auto";
+ }
+
+ return NULL;
+}
+
+enum connman_ipconfig_method __connman_ipconfig_string2method(const char *method)
+{
+ if (g_strcmp0(method, "off") == 0)
+ return CONNMAN_IPCONFIG_METHOD_OFF;
+ else if (g_strcmp0(method, "fixed") == 0)
+ return CONNMAN_IPCONFIG_METHOD_FIXED;
+ else if (g_strcmp0(method, "manual") == 0)
+ return CONNMAN_IPCONFIG_METHOD_MANUAL;
+ else if (g_strcmp0(method, "dhcp") == 0)
+ return CONNMAN_IPCONFIG_METHOD_DHCP;
+ else if (g_strcmp0(method, "auto") == 0)
+ return CONNMAN_IPCONFIG_METHOD_AUTO;
+ else
+ return CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+}
+
+static const char *privacy2string(int privacy)
+{
+ if (privacy <= 0)
+ return "disabled";
+ else if (privacy == 1)
+ return "enabled";
+ else
+ return "prefered";
+}
+
+static int string2privacy(const char *privacy)
+{
+ if (g_strcmp0(privacy, "disabled") == 0)
+ return 0;
+ else if (g_strcmp0(privacy, "enabled") == 0)
+ return 1;
+ else if (g_strcmp0(privacy, "preferred") == 0)
+ return 2;
+ else if (g_strcmp0(privacy, "prefered") == 0)
+ return 2;
+ else
+ return 0;
+}
+
+int __connman_ipconfig_ipv6_reset_privacy(struct connman_ipconfig *ipconfig)
+{
+ struct connman_ipdevice *ipdevice;
+ int err;
+
+ if (!ipconfig)
+ return -EINVAL;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return -ENODEV;
+
+ err = __connman_ipconfig_ipv6_set_privacy(ipconfig, privacy2string(
+ ipdevice->ipv6_privacy));
+
+ return err;
+}
+
+int __connman_ipconfig_ipv6_set_privacy(struct connman_ipconfig *ipconfig,
+ const char *value)
+{
+ int privacy;
+
+ if (!ipconfig)
+ return -EINVAL;
+
+ DBG("ipconfig %p privacy %s", ipconfig, value);
+
+ privacy = string2privacy(value);
+
+ ipconfig->ipv6_privacy_config = privacy;
+
+ enable_ipv6(ipconfig);
+
+ return 0;
+}
+
+void __connman_ipconfig_append_ipv4(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter)
+{
+ struct connman_ipaddress *append_addr = NULL;
+ const char *str;
+
+ DBG("");
+
+ if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV4)
+ return;
+
+ str = __connman_ipconfig_method2string(ipconfig->method);
+ if (!str)
+ return;
+
+ connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ return;
+
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ append_addr = ipconfig->address;
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ append_addr = ipconfig->system;
+ break;
+ }
+
+ if (!append_addr)
+ return;
+
+ if (append_addr->local) {
+ in_addr_t addr;
+ struct in_addr netmask;
+ char *mask;
+
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &append_addr->local);
+
+ addr = 0xffffffff << (32 - append_addr->prefixlen);
+ netmask.s_addr = htonl(addr);
+ mask = inet_ntoa(netmask);
+ connman_dbus_dict_append_basic(iter, "Netmask",
+ DBUS_TYPE_STRING, &mask);
+ }
+
+ if (append_addr->gateway)
+ connman_dbus_dict_append_basic(iter, "Gateway",
+ DBUS_TYPE_STRING, &append_addr->gateway);
+}
+
+void __connman_ipconfig_append_ipv6(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter,
+ struct connman_ipconfig *ipconfig_ipv4)
+{
+ struct connman_ipaddress *append_addr = NULL;
+ const char *str, *privacy;
+
+ DBG("");
+
+ if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6)
+ return;
+
+ str = __connman_ipconfig_method2string(ipconfig->method);
+ if (!str)
+ return;
+
+ if (ipconfig_ipv4 &&
+ ipconfig->method == CONNMAN_IPCONFIG_METHOD_AUTO) {
+ if (__connman_6to4_check(ipconfig_ipv4) == 1)
+ str = "6to4";
+ }
+
+ connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ return;
+
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ append_addr = ipconfig->address;
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ append_addr = ipconfig->system;
+ break;
+ }
+
+ if (!append_addr)
+ return;
+
+ if (append_addr->local) {
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &append_addr->local);
+ connman_dbus_dict_append_basic(iter, "PrefixLength",
+ DBUS_TYPE_BYTE,
+ &append_addr->prefixlen);
+ }
+
+ if (append_addr->gateway)
+ connman_dbus_dict_append_basic(iter, "Gateway",
+ DBUS_TYPE_STRING, &append_addr->gateway);
+
+ privacy = privacy2string(ipconfig->ipv6_privacy_config);
+ connman_dbus_dict_append_basic(iter, "Privacy",
+ DBUS_TYPE_STRING, &privacy);
+}
+
+void __connman_ipconfig_append_ipv6config(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter)
+{
+ const char *str, *privacy;
+
+ DBG("");
+
+ str = __connman_ipconfig_method2string(ipconfig->method);
+ if (!str)
+ return;
+
+ connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ return;
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ break;
+ }
+
+ if (!ipconfig->address)
+ return;
+
+ if (ipconfig->address->local) {
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &ipconfig->address->local);
+ connman_dbus_dict_append_basic(iter, "PrefixLength",
+ DBUS_TYPE_BYTE,
+ &ipconfig->address->prefixlen);
+ }
+
+ if (ipconfig->address->gateway)
+ connman_dbus_dict_append_basic(iter, "Gateway",
+ DBUS_TYPE_STRING, &ipconfig->address->gateway);
+
+ privacy = privacy2string(ipconfig->ipv6_privacy_config);
+ connman_dbus_dict_append_basic(iter, "Privacy",
+ DBUS_TYPE_STRING, &privacy);
+}
+
+void __connman_ipconfig_append_ipv4config(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter)
+{
+ const char *str;
+
+ DBG("");
+
+ str = __connman_ipconfig_method2string(ipconfig->method);
+ if (!str)
+ return;
+
+ connman_dbus_dict_append_basic(iter, "Method", DBUS_TYPE_STRING, &str);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ return;
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ break;
+ }
+
+ if (!ipconfig->address)
+ return;
+
+ if (ipconfig->address->local) {
+ in_addr_t addr;
+ struct in_addr netmask;
+ char *mask;
+
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &ipconfig->address->local);
+
+ addr = 0xffffffff << (32 - ipconfig->address->prefixlen);
+ netmask.s_addr = htonl(addr);
+ mask = inet_ntoa(netmask);
+ connman_dbus_dict_append_basic(iter, "Netmask",
+ DBUS_TYPE_STRING, &mask);
+ }
+
+ if (ipconfig->address->gateway)
+ connman_dbus_dict_append_basic(iter, "Gateway",
+ DBUS_TYPE_STRING, &ipconfig->address->gateway);
+}
+
+int __connman_ipconfig_set_config(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *array)
+{
+ enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ const char *address = NULL, *netmask = NULL, *gateway = NULL,
+ *privacy_string = NULL;
+ int prefix_length = 0, privacy = 0;
+ DBusMessageIter dict;
+ int type = -1;
+
+ DBG("ipconfig %p", ipconfig);
+
+ if (dbus_message_iter_get_arg_type(array) != DBUS_TYPE_ARRAY)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(&entry, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ if (g_str_equal(key, "Method")) {
+ const char *str;
+
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &str);
+ method = __connman_ipconfig_string2method(str);
+ } else if (g_str_equal(key, "Address")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &address);
+ } else if (g_str_equal(key, "PrefixLength")) {
+ if (type != DBUS_TYPE_BYTE)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &prefix_length);
+
+ if (prefix_length < 0 || prefix_length > 128)
+ return -EINVAL;
+ } else if (g_str_equal(key, "Netmask")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &netmask);
+ } else if (g_str_equal(key, "Gateway")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &gateway);
+ } else if (g_str_equal(key, "Privacy")) {
+ if (type != DBUS_TYPE_STRING)
+ return -EINVAL;
+
+ dbus_message_iter_get_basic(&value, &privacy_string);
+ privacy = string2privacy(privacy_string);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ DBG("method %d address %s netmask %s gateway %s prefix_length %d "
+ "privacy %s",
+ method, address, netmask, gateway, prefix_length,
+ privacy_string);
+
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ return -EINVAL;
+
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ ipconfig->method = method;
+
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV6)
+ return -EOPNOTSUPP;
+
+ ipconfig->method = method;
+ if (privacy_string)
+ ipconfig->ipv6_privacy_config = privacy;
+
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ switch (ipconfig->type) {
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ type = AF_INET;
+ break;
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ type = AF_INET6;
+ break;
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ type = -1;
+ break;
+ }
+
+ if ((address && connman_inet_check_ipaddress(address)
+ != type) ||
+ (netmask &&
+ connman_inet_check_ipaddress(netmask)
+ != type) ||
+ (gateway &&
+ connman_inet_check_ipaddress(gateway)
+ != type))
+ return -EINVAL;
+
+ ipconfig->method = method;
+
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ connman_ipaddress_set_ipv4(ipconfig->address,
+ address, netmask, gateway);
+ else
+ return connman_ipaddress_set_ipv6(
+ ipconfig->address, address,
+ prefix_length, gateway);
+
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ if (ipconfig->type != CONNMAN_IPCONFIG_TYPE_IPV4)
+ return -EOPNOTSUPP;
+
+ ipconfig->method = method;
+ break;
+ }
+
+ return 0;
+}
+
+void __connman_ipconfig_append_ethernet(struct connman_ipconfig *ipconfig,
+ DBusMessageIter *iter)
+{
+ struct connman_ipdevice *ipdevice;
+ const char *method = "auto";
+
+ connman_dbus_dict_append_basic(iter, "Method",
+ DBUS_TYPE_STRING, &method);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash,
+ GINT_TO_POINTER(ipconfig->index));
+ if (!ipdevice)
+ return;
+
+ if (ipconfig->index >= 0) {
+ char *ifname = connman_inet_ifname(ipconfig->index);
+ if (ifname) {
+ connman_dbus_dict_append_basic(iter, "Interface",
+ DBUS_TYPE_STRING, &ifname);
+ g_free(ifname);
+ }
+ }
+
+ if (ipdevice->address)
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &ipdevice->address);
+
+ if (ipdevice->mtu > 0)
+ connman_dbus_dict_append_basic(iter, "MTU",
+ DBUS_TYPE_UINT16, &ipdevice->mtu);
+}
+
+int __connman_ipconfig_load(struct connman_ipconfig *ipconfig,
+ GKeyFile *keyfile, const char *identifier, const char *prefix)
+{
+ char *method;
+ char *key;
+ char *str;
+
+ DBG("ipconfig %p identifier %s", ipconfig, identifier);
+
+ key = g_strdup_printf("%smethod", prefix);
+ method = g_key_file_get_string(keyfile, identifier, key, NULL);
+ if (!method) {
+ switch (ipconfig->type) {
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ ipconfig->method = CONNMAN_IPCONFIG_METHOD_DHCP;
+ break;
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ ipconfig->method = CONNMAN_IPCONFIG_METHOD_AUTO;
+ break;
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ ipconfig->method = CONNMAN_IPCONFIG_METHOD_OFF;
+ break;
+ }
+ } else
+ ipconfig->method = __connman_ipconfig_string2method(method);
+
+ if (ipconfig->method == CONNMAN_IPCONFIG_METHOD_UNKNOWN)
+ ipconfig->method = CONNMAN_IPCONFIG_METHOD_OFF;
+
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ gsize length;
+ char *pprefix;
+
+ if (ipconfig->method == CONNMAN_IPCONFIG_METHOD_AUTO ||
+ ipconfig->method == CONNMAN_IPCONFIG_METHOD_MANUAL) {
+ char *privacy;
+
+ pprefix = g_strdup_printf("%sprivacy", prefix);
+ privacy = g_key_file_get_string(keyfile, identifier,
+ pprefix, NULL);
+ ipconfig->ipv6_privacy_config = string2privacy(privacy);
+ g_free(pprefix);
+ g_free(privacy);
+ }
+
+ pprefix = g_strdup_printf("%sDHCP.LastPrefixes", prefix);
+ ipconfig->last_dhcpv6_prefixes =
+ g_key_file_get_string_list(keyfile, identifier, pprefix,
+ &length, NULL);
+ if (ipconfig->last_dhcpv6_prefixes && length == 0) {
+ g_free(ipconfig->last_dhcpv6_prefixes);
+ ipconfig->last_dhcpv6_prefixes = NULL;
+ }
+ g_free(pprefix);
+ }
+
+ g_free(method);
+ g_free(key);
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+
+ key = g_strdup_printf("%snetmask_prefixlen", prefix);
+ ipconfig->address->prefixlen = g_key_file_get_integer(
+ keyfile, identifier, key, NULL);
+ g_free(key);
+
+ key = g_strdup_printf("%slocal_address", prefix);
+ g_free(ipconfig->address->local);
+ ipconfig->address->local = g_key_file_get_string(
+ keyfile, identifier, key, NULL);
+ g_free(key);
+
+ key = g_strdup_printf("%speer_address", prefix);
+ g_free(ipconfig->address->peer);
+ ipconfig->address->peer = g_key_file_get_string(
+ keyfile, identifier, key, NULL);
+ g_free(key);
+
+ key = g_strdup_printf("%sbroadcast_address", prefix);
+ g_free(ipconfig->address->broadcast);
+ ipconfig->address->broadcast = g_key_file_get_string(
+ keyfile, identifier, key, NULL);
+ g_free(key);
+
+ key = g_strdup_printf("%sgateway", prefix);
+ g_free(ipconfig->address->gateway);
+ ipconfig->address->gateway = g_key_file_get_string(
+ keyfile, identifier, key, NULL);
+ g_free(key);
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+
+ key = g_strdup_printf("%sDHCP.LastAddress", prefix);
+ str = g_key_file_get_string(keyfile, identifier, key, NULL);
+ if (str) {
+ g_free(ipconfig->last_dhcp_address);
+ ipconfig->last_dhcp_address = str;
+ }
+ g_free(key);
+
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ break;
+ }
+
+ return 0;
+}
+
+int __connman_ipconfig_save(struct connman_ipconfig *ipconfig,
+ GKeyFile *keyfile, const char *identifier, const char *prefix)
+{
+ const char *method;
+ char *key;
+
+ method = __connman_ipconfig_method2string(ipconfig->method);
+
+ DBG("ipconfig %p identifier %s method %s", ipconfig, identifier,
+ method);
+ if (method) {
+ key = g_strdup_printf("%smethod", prefix);
+ g_key_file_set_string(keyfile, identifier, key, method);
+ g_free(key);
+ }
+
+ if (ipconfig->type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ const char *privacy;
+ privacy = privacy2string(ipconfig->ipv6_privacy_config);
+ key = g_strdup_printf("%sprivacy", prefix);
+ g_key_file_set_string(keyfile, identifier, key, privacy);
+ g_free(key);
+
+ key = g_strdup_printf("%sDHCP.LastAddress", prefix);
+ if (ipconfig->last_dhcp_address &&
+ strlen(ipconfig->last_dhcp_address) > 0)
+ g_key_file_set_string(keyfile, identifier, key,
+ ipconfig->last_dhcp_address);
+ else
+ g_key_file_remove_key(keyfile, identifier, key, NULL);
+ g_free(key);
+
+ key = g_strdup_printf("%sDHCP.LastPrefixes", prefix);
+ if (ipconfig->last_dhcpv6_prefixes &&
+ ipconfig->last_dhcpv6_prefixes[0]) {
+ guint len =
+ g_strv_length(ipconfig->last_dhcpv6_prefixes);
+
+ g_key_file_set_string_list(keyfile, identifier, key,
+ (const gchar **)ipconfig->last_dhcpv6_prefixes,
+ len);
+ } else
+ g_key_file_remove_key(keyfile, identifier, key, NULL);
+ g_free(key);
+ }
+
+ switch (ipconfig->method) {
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ key = g_strdup_printf("%sDHCP.LastAddress", prefix);
+ if (ipconfig->last_dhcp_address &&
+ strlen(ipconfig->last_dhcp_address) > 0)
+ g_key_file_set_string(keyfile, identifier, key,
+ ipconfig->last_dhcp_address);
+ else
+ g_key_file_remove_key(keyfile, identifier, key, NULL);
+ g_free(key);
+ /* fall through */
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ return 0;
+ }
+
+ key = g_strdup_printf("%snetmask_prefixlen", prefix);
+ if (ipconfig->address->prefixlen != 0)
+ g_key_file_set_integer(keyfile, identifier,
+ key, ipconfig->address->prefixlen);
+ g_free(key);
+
+ key = g_strdup_printf("%slocal_address", prefix);
+ if (ipconfig->address->local)
+ g_key_file_set_string(keyfile, identifier,
+ key, ipconfig->address->local);
+ g_free(key);
+
+ key = g_strdup_printf("%speer_address", prefix);
+ if (ipconfig->address->peer)
+ g_key_file_set_string(keyfile, identifier,
+ key, ipconfig->address->peer);
+ g_free(key);
+
+ key = g_strdup_printf("%sbroadcast_address", prefix);
+ if (ipconfig->address->broadcast)
+ g_key_file_set_string(keyfile, identifier,
+ key, ipconfig->address->broadcast);
+ g_free(key);
+
+ key = g_strdup_printf("%sgateway", prefix);
+ if (ipconfig->address->gateway)
+ g_key_file_set_string(keyfile, identifier,
+ key, ipconfig->address->gateway);
+ g_free(key);
+
+ return 0;
+}
+
+int __connman_ipconfig_init(void)
+{
+ DBG("");
+
+ ipdevice_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_ipdevice);
+
+ is_ipv6_supported = connman_inet_is_ipv6_supported();
+
+ return 0;
+}
+
+void __connman_ipconfig_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(ipdevice_hash);
+ ipdevice_hash = NULL;
+}
diff --git a/src/ippool.c b/src/ippool.c
new file mode 100644
index 0000000..bb8568d
--- /dev/null
+++ b/src/ippool.c
@@ -0,0 +1,469 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/errno.h>
+#include <sys/socket.h>
+
+#include "connman.h"
+
+struct address_info {
+ int index;
+ uint32_t start;
+ uint32_t end;
+
+ unsigned int use_count;
+ struct connman_ippool *pool;
+};
+
+struct connman_ippool {
+ unsigned int refcount;
+
+ struct address_info *info;
+
+ char *gateway;
+ char *broadcast;
+ char *start_ip;
+ char *end_ip;
+ char *subnet_mask;
+
+ ippool_collision_cb_t collision_cb;
+ void *user_data;
+};
+
+GSList *allocated_blocks;
+GHashTable *pool_hash;
+
+static uint32_t last_block;
+static uint32_t block_16_bits;
+static uint32_t block_20_bits;
+static uint32_t block_24_bits;
+static uint32_t subnet_mask_24;
+
+struct connman_ippool *
+__connman_ippool_ref_debug(struct connman_ippool *pool,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", pool, pool->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&pool->refcount, 1);
+
+ return pool;
+}
+
+void __connman_ippool_unref_debug(struct connman_ippool *pool,
+ const char *file, int line, const char *caller)
+{
+ if (!pool)
+ return;
+
+ DBG("%p ref %d by %s:%d:%s()", pool, pool->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&pool->refcount, 1) != 1)
+ return;
+
+ g_hash_table_remove(pool_hash, pool);
+}
+
+static char *get_ip(uint32_t ip)
+{
+ struct in_addr addr;
+
+ addr.s_addr = htonl(ip);
+
+ return g_strdup(inet_ntoa(addr));
+}
+
+static uint32_t next_block(uint32_t block)
+{
+ uint32_t next;
+
+ /*
+ * Return the next IP block within the private IP range
+ *
+ * 16-bit block 192.168.0.0 – 192.168.255.255
+ * 20-bit block 172.16.0.0 – 172.31.255.255
+ * 24-bit block 10.0.0.0 – 10.255.255.255
+ */
+
+ next = (block & 0x0000ff00) >> 8;
+ next += 1;
+
+ if (next == 255) {
+ if ((block & 0xffff0000) == block_16_bits) {
+ /*
+ * Reached the end of the 16 bit block, switch
+ * to the 20-bit block.
+ */
+ return block_20_bits;
+ }
+
+ if ((block & 0xffff0000) >= block_20_bits) {
+ next = (block & 0x00ff0000) >> 16;
+ if (next >= 16 && next < 32)
+ next += 1;
+
+ if (next == 32) {
+ /*
+ * Reached the end of the 20 bit
+ * block, switch to the 24-bit block.
+ */
+ return block_24_bits;
+ }
+
+ return (block & 0xff000000) |
+ ((next << 16) & 0x00ff0000);
+ }
+
+ if ((block & 0xff000000) == block_24_bits) {
+ next = (block & 0x00ff0000) >> 16;
+ if (next < 255)
+ next += 1;
+
+ if (next == 255) {
+ /*
+ * Reached the end of the 24 bit
+ * block, switch to the 16-bit block.
+ */
+ return block_16_bits;
+ }
+
+ return (block & 0xff000000) |
+ ((next << 16) & 0x00ff0000);
+ }
+ }
+
+ return (block & 0xffff0000) | ((next << 8) & 0x0000ff00);
+}
+
+static uint32_t get_free_block(unsigned int size)
+{
+ struct address_info *info;
+ uint32_t block;
+ GSList *list;
+ bool collision;
+
+ /*
+ * Instead starting always from the 16 bit block, we start
+ * from the last assigned block. This is a simple optimimazion
+ * for the case where a lot of blocks have been assigned, e.g.
+ * the first half of the private IP pool is in use and a new
+ * we need to find a new block.
+ *
+ * To only thing we have to make sure is that we terminated if
+ * there is no block left.
+ */
+ if (last_block == 0)
+ block = block_16_bits;
+ else
+ block = next_block(last_block);
+
+ do {
+ collision = false;
+ for (list = allocated_blocks; list; list = list->next) {
+ info = list->data;
+
+ if (info->start <= block && block <= info->end) {
+ collision = true;
+ break;
+ }
+ }
+
+ if (!collision)
+ return block;
+
+ block = next_block(block);
+ } while (block != last_block);
+
+ return 0;
+}
+
+static struct address_info *lookup_info(int index, uint32_t start)
+{
+ GSList *list;
+
+ for (list = allocated_blocks; list; list = list->next) {
+ struct address_info *info = list->data;
+
+ if (info->index == index && info->start == start)
+ return info;
+ }
+
+ return NULL;
+}
+
+static bool is_private_address(uint32_t address)
+{
+ unsigned int a, b;
+
+ a = (address & 0xff000000) >> 24;
+ b = (address & 0x00ff0000) >> 16;
+
+ if (a == 10 || (a == 192 && b == 168) ||
+ (a == 172 && (b >= 16 && b <= 31)))
+ return true;
+
+ return false;
+}
+
+void __connman_ippool_newaddr(int index, const char *address,
+ unsigned char prefixlen)
+{
+ struct address_info *info, *it;
+ struct in_addr inp;
+ uint32_t start, end, mask;
+ GSList *list;
+
+ if (inet_aton(address, &inp) == 0)
+ return;
+
+ start = ntohl(inp.s_addr);
+ if (!is_private_address(start))
+ return;
+
+ if (prefixlen >= 32)
+ mask = 0xffffffff;
+ else
+ mask = ~(0xffffffff >> prefixlen);
+
+ start = start & mask;
+ end = start | ~mask;
+
+ info = lookup_info(index, start);
+ if (info)
+ goto update;
+
+ info = g_try_new0(struct address_info, 1);
+ if (!info)
+ return;
+
+ info->index = index;
+ info->start = start;
+ info->end = end;
+
+ allocated_blocks = g_slist_prepend(allocated_blocks, info);
+
+update:
+ info->use_count = info->use_count + 1;
+
+ if (info->use_count > 1 || info->pool) {
+ /*
+ * We need only to check for the first IP in a block for
+ * collisions.
+ */
+ return;
+ }
+
+ for (list = allocated_blocks; list; list = list->next) {
+ it = list->data;
+
+ if (it == info)
+ continue;
+
+ if (!(info->start >= it->start && info->start <= it->end))
+ continue;
+
+ if (it->pool && it->pool->collision_cb)
+ it->pool->collision_cb(it->pool, it->pool->user_data);
+
+ return;
+ }
+}
+
+void __connman_ippool_deladdr(int index, const char *address,
+ unsigned char prefixlen)
+{
+ struct address_info *info;
+ struct in_addr inp;
+ uint32_t start, mask;
+
+ if (inet_aton(address, &inp) == 0)
+ return;
+
+ start = ntohl(inp.s_addr);
+ if (!is_private_address(start))
+ return;
+
+ mask = ~(0xffffffff >> prefixlen);
+ start = start & mask;
+
+ info = lookup_info(index, start);
+ if (!info) {
+ /* In theory this should never happen */
+ connman_error("Inconsistent IP pool management (start not found)");
+ return;
+ }
+
+ info->use_count = info->use_count - 1;
+ if (info->pool)
+ return;
+
+ if (info->use_count > 0)
+ return;
+
+ allocated_blocks = g_slist_remove(allocated_blocks, info);
+ g_free(info);
+}
+
+struct connman_ippool *__connman_ippool_create(int index,
+ unsigned int start,
+ unsigned int range,
+ ippool_collision_cb_t collision_cb,
+ void *user_data)
+{
+ struct connman_ippool *pool;
+ struct address_info *info;
+ uint32_t block;
+
+ DBG("");
+
+ /*
+ * The range is at max 255 and we don't support overlapping
+ * blocks.
+ */
+ if (start + range > 254) {
+ connman_error("IP pool does not support pool size larger than 254");
+ return NULL;
+ }
+
+ block = get_free_block(start + range);
+ if (block == 0) {
+ connman_warn("Could not find a free IP block");
+ return NULL;
+ }
+
+ pool = g_try_new0(struct connman_ippool, 1);
+ if (!pool)
+ return NULL;
+
+ info = g_try_new0(struct address_info, 1);
+ if (!info) {
+ g_free(pool);
+ return NULL;
+ }
+
+ last_block = block;
+
+ info->index = index;
+ info->start = block;
+ info->end = block + range;
+
+ pool->refcount = 1;
+ pool->info = info;
+ pool->collision_cb = collision_cb;
+ pool->user_data = user_data;
+
+ info->pool = pool;
+
+ if (range == 0)
+ range = 1;
+
+ pool->gateway = get_ip(info->start + 1);
+ pool->broadcast = get_ip(info->start + 255);
+ pool->subnet_mask = get_ip(subnet_mask_24);
+ pool->start_ip = get_ip(block + start);
+ pool->end_ip = get_ip(block + start + range);
+
+ allocated_blocks = g_slist_prepend(allocated_blocks, info);
+ g_hash_table_insert(pool_hash, pool, pool);
+
+ return pool;
+}
+
+const char *__connman_ippool_get_gateway(struct connman_ippool *pool)
+{
+ return pool->gateway;
+}
+
+const char *__connman_ippool_get_broadcast(struct connman_ippool *pool)
+{
+ return pool->broadcast;
+}
+
+const char *__connman_ippool_get_start_ip(struct connman_ippool *pool)
+{
+ return pool->start_ip;
+}
+
+const char *__connman_ippool_get_end_ip(struct connman_ippool *pool)
+{
+ return pool->end_ip;
+}
+
+const char *__connman_ippool_get_subnet_mask(struct connman_ippool *pool)
+{
+ return pool->subnet_mask;
+}
+
+static void pool_free(gpointer data)
+{
+ struct connman_ippool *pool = data;
+
+ if (pool->info) {
+ allocated_blocks = g_slist_remove(allocated_blocks, pool->info);
+ g_free(pool->info);
+ }
+
+ g_free(pool->gateway);
+ g_free(pool->broadcast);
+ g_free(pool->start_ip);
+ g_free(pool->end_ip);
+ g_free(pool->subnet_mask);
+
+ g_free(pool);
+}
+
+int __connman_ippool_init(void)
+{
+ DBG("");
+
+ block_16_bits = ntohl(inet_addr("192.168.0.0"));
+ block_20_bits = ntohl(inet_addr("172.16.0.0"));
+ block_24_bits = ntohl(inet_addr("10.0.0.0"));
+ subnet_mask_24 = ntohl(inet_addr("255.255.255.0"));
+
+ pool_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL,
+ pool_free);
+
+ return 0;
+}
+
+void __connman_ippool_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(pool_hash);
+ pool_hash = NULL;
+
+ g_slist_free_full(allocated_blocks, g_free);
+ last_block = 0;
+ allocated_blocks = NULL;
+}
diff --git a/src/iptables.c b/src/iptables.c
new file mode 100644
index 0000000..2602dfd
--- /dev/null
+++ b/src/iptables.c
@@ -0,0 +1,2449 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <getopt.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/errno.h>
+#include <sys/socket.h>
+#include <xtables.h>
+#include <inttypes.h>
+
+#include <linux/netfilter_ipv4/ip_tables.h>
+
+#include "connman.h"
+#include "src/shared/util.h"
+
+/*
+ * Some comments on how the iptables API works (some of them from the
+ * source code from iptables and the kernel):
+ *
+ * - valid_hooks: bit indicates valid IDs for hook_entry
+ * - hook_entry[ID] offset to the chain start
+ * - overflows should be end of entry chains, and uncodintional policy nodes.
+ * - policy entry: last entry in a chain
+ * - user chain: end of last builtin + policy entry
+ * - final entry must be error node
+ * - Underflows must be unconditional and use the STANDARD target with
+ * ACCEPT/DROP
+ * - IPT_SO_GET_INFO and IPT_SO_GET_ENTRIES are used to read a table
+ * - IPT_SO_GET_INFO: struct ipt_getinfo (note the lack of table content)
+ * - IPT_SO_GET_ENTRIES: struct ipt_get_entries (contains only parts of the
+ * table header/meta info. The table is appended after the header. The entries
+ * are of the type struct ipt_entry.
+ * - After the ipt_entry the matches are appended. After the matches
+ * the target is appended.
+ * - ipt_entry->target_offset = Size of ipt_entry + matches
+ * - ipt_entry->next_offset = Size of ipt_entry + matches + target
+ * - IPT_SO_SET_REPLACE is used to write a table (contains the complete
+ * - hook_entry and overflow mark the begining and the end of a chain, e.g
+ * entry hook: pre/in/fwd/out/post -1/0/352/504/-1
+ * underflow: pre/in/fwd/out/post -1/200/352/904/-1
+ * means that INPUT starts at offset 0 and ends at 200 (the start offset to
+ * the last element). FORWARD has one entry starting/ending at 352. The entry
+ * has a size of 152. 352 + 152 = 504 which is the start of the OUTPUT chain
+ * which then ends at 904. PREROUTING and POSTROUTING are invalid hooks in
+ * the filter table.
+ * - 'iptables -t filter -A INPUT -m mark --mark 999 -j LOG'
+ * writing that table looks like this:
+ *
+ * filter valid_hooks 0x0000000e num_entries 5 size 856
+ * entry hook: pre/in/fwd/out/post -1/0/376/528/-1
+ * underflow: pre/in/fwd/out/post -1/224/376/528/-1
+ * entry 0x699d30 offset 0 size 224
+ * RULE match 0x699da0 target 0x699dd0
+ * match mark match 0x3e7
+ * target LOG flags 0 level 4
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x699e10 offset 224 size 152
+ * RULE match 0x699e80 target 0x699e80
+ * target ACCEPT
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x699ea8 offset 376 size 152
+ * RULE match 0x699f18 target 0x699f18
+ * target ACCEPT
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x699f40 offset 528 size 152
+ * RULE match 0x699fb0 target 0x699fb0
+ * target ACCEPT
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x699fd8 offset 680 size 176
+ * USER CHAIN (ERROR) match 0x69a048 target 0x69a048
+ *
+ * Reading the filter table looks like this:
+ *
+ * filter valid_hooks 0x0000000e num_entries 5 size 856
+ * entry hook: pre/in/fwd/out/post -1/0/376/528/-1
+ * underflow: pre/in/fwd/out/post -1/224/376/528/-1
+ * entry 0x25fec28 offset 0 size 224
+ * CHAIN (INPUT) match 0x25fec98 target 0x25fecc8
+ * match mark match 0x3e7
+ * target LOG flags 0 level 4
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x25fed08 offset 224 size 152
+ * RULE match 0x25fed78 target 0x25fed78
+ * target ACCEPT
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x25feda0 offset 376 size 152
+ * CHAIN (FORWARD) match 0x25fee10 target 0x25fee10
+ * target ACCEPT
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x25fee38 offset 528 size 152
+ * CHAIN (OUTPUT) match 0x25feea8 target 0x25feea8
+ * target ACCEPT
+ * src 0.0.0.0/0.0.0.0
+ * dst 0.0.0.0/0.0.0.0
+ * entry 0x25feed0 offset 680 size 176
+ * End of CHAIN
+ */
+
+static const char *hooknames[] = {
+ [NF_IP_PRE_ROUTING] = "PREROUTING",
+ [NF_IP_LOCAL_IN] = "INPUT",
+ [NF_IP_FORWARD] = "FORWARD",
+ [NF_IP_LOCAL_OUT] = "OUTPUT",
+ [NF_IP_POST_ROUTING] = "POSTROUTING",
+};
+
+#define LABEL_ACCEPT "ACCEPT"
+#define LABEL_DROP "DROP"
+#define LABEL_QUEUE "QUEUE"
+#define LABEL_RETURN "RETURN"
+
+#define XT_OPTION_OFFSET_SCALE 256
+
+#define MIN_ALIGN (__alignof__(struct ipt_entry))
+
+#define ALIGN(s) (((s) + ((MIN_ALIGN)-1)) & ~((MIN_ALIGN)-1))
+
+struct error_target {
+ struct xt_entry_target t;
+ char error[IPT_TABLE_MAXNAMELEN];
+};
+
+struct connman_iptables_entry {
+ int offset;
+ int builtin;
+ int counter_idx;
+
+ struct ipt_entry *entry;
+};
+
+struct connman_iptables {
+ char *name;
+ int ipt_sock;
+
+ struct ipt_getinfo *info;
+ struct ipt_get_entries *blob_entries;
+
+ unsigned int num_entries;
+ unsigned int old_entries;
+ unsigned int size;
+
+ unsigned int underflow[NF_INET_NUMHOOKS];
+ unsigned int hook_entry[NF_INET_NUMHOOKS];
+
+ GList *entries;
+};
+
+static GHashTable *table_hash = NULL;
+static bool debug_enabled = false;
+
+typedef int (*iterate_entries_cb_t)(struct ipt_entry *entry, int builtin,
+ unsigned int hook, size_t size,
+ unsigned int offset, void *user_data);
+
+static unsigned int next_hook_entry_index(unsigned int *valid_hooks)
+{
+ unsigned int h;
+
+ if (*valid_hooks == 0)
+ return NF_INET_NUMHOOKS;
+
+ h = __builtin_ffs(*valid_hooks) - 1;
+ *valid_hooks ^= (1 << h);
+
+ return h;
+}
+
+static int iterate_entries(struct ipt_entry *entries,
+ unsigned int valid_hooks,
+ unsigned int *hook_entry,
+ unsigned int *underflow,
+ size_t size, iterate_entries_cb_t cb,
+ void *user_data)
+{
+ unsigned int offset, h, hook;
+ int builtin, err;
+ struct ipt_entry *entry;
+
+ h = next_hook_entry_index(&valid_hooks);
+ hook = h;
+
+ for (offset = 0, entry = entries; offset < size;
+ offset += entry->next_offset) {
+ builtin = -1;
+ entry = (void *)entries + offset;
+
+ /*
+ * Updating builtin, hook and h is very tricky.
+ * The rules are:
+ * - builtin is only set to the current hook number
+ * if the current entry is the hook entry (aka chain
+ * head). And only for builtin chains, never for
+ * the user chains.
+ * - hook is the current hook number. If we
+ * look at user chains it needs to be NF_INET_NETNUMHOOKS.
+ * - h is the next hook entry. Thous we need to be carefully
+ * not to access the table when h is NF_INET_NETNUMHOOKS.
+ */
+ if (h < NF_INET_NUMHOOKS && hook_entry[h] == offset) {
+ builtin = h;
+ hook = h;
+ }
+
+ if (h == NF_INET_NUMHOOKS)
+ hook = h;
+
+ if (h < NF_INET_NUMHOOKS && underflow[h] <= offset)
+ h = next_hook_entry_index(&valid_hooks);
+
+ err = cb(entry, builtin, hook, size, offset, user_data);
+ if (err < 0)
+ return err;
+ }
+
+ return 0;
+}
+
+static int print_entry(struct ipt_entry *entry, int builtin, unsigned int hook,
+ size_t size, unsigned int offset,
+ void *user_data)
+{
+ iterate_entries_cb_t cb = user_data;
+
+ DBG("entry %p hook %u offset %u size %u packets %"PRIu64" bytes %"PRIu64,
+ entry, hook, offset, (unsigned int) entry->next_offset,
+ (uint64_t) entry->counters.pcnt, (uint64_t) entry->counters.bcnt);
+
+ return cb(entry, builtin, hook, size, offset, NULL);
+}
+
+static int target_to_verdict(const char *target_name)
+{
+ if (!g_strcmp0(target_name, LABEL_ACCEPT))
+ return -NF_ACCEPT - 1;
+
+ if (!g_strcmp0(target_name, LABEL_DROP))
+ return -NF_DROP - 1;
+
+ if (!g_strcmp0(target_name, LABEL_QUEUE))
+ return -NF_QUEUE - 1;
+
+ if (!g_strcmp0(target_name, LABEL_RETURN))
+ return XT_RETURN;
+
+ return 0;
+}
+
+static bool is_builtin_target(const char *target_name)
+{
+ if (!g_strcmp0(target_name, LABEL_ACCEPT) ||
+ !g_strcmp0(target_name, LABEL_DROP) ||
+ !g_strcmp0(target_name, LABEL_QUEUE) ||
+ !g_strcmp0(target_name, LABEL_RETURN))
+ return true;
+
+ return false;
+}
+
+static bool is_jump(struct connman_iptables_entry *e)
+{
+ struct xt_entry_target *target;
+
+ target = ipt_get_target(e->entry);
+
+ if (!g_strcmp0(target->u.user.name, IPT_STANDARD_TARGET)) {
+ struct xt_standard_target *t;
+
+ t = (struct xt_standard_target *)target;
+
+ switch (t->verdict) {
+ case XT_RETURN:
+ case -NF_ACCEPT - 1:
+ case -NF_DROP - 1:
+ case -NF_QUEUE - 1:
+ case -NF_STOP - 1:
+ return false;
+
+ default:
+ return true;
+ }
+ }
+
+ return false;
+}
+
+static bool is_fallthrough(struct connman_iptables_entry *e)
+{
+ struct xt_entry_target *target;
+
+ target = ipt_get_target(e->entry);
+ if (!g_strcmp0(target->u.user.name, IPT_STANDARD_TARGET)) {
+ struct xt_standard_target *t;
+
+ t = (struct xt_standard_target *)target;
+ if (t->verdict == 0)
+ return true;
+ }
+ return false;
+}
+
+static bool is_chain(struct connman_iptables *table,
+ struct connman_iptables_entry *e)
+{
+ struct ipt_entry *entry;
+ struct xt_entry_target *target;
+
+ entry = e->entry;
+ if (e->builtin >= 0)
+ return true;
+
+ target = ipt_get_target(entry);
+ if (!g_strcmp0(target->u.user.name, IPT_ERROR_TARGET))
+ return true;
+
+ return false;
+}
+
+static GList *find_chain_head(struct connman_iptables *table,
+ const char *chain_name)
+{
+ GList *list;
+ struct connman_iptables_entry *head;
+ struct ipt_entry *entry;
+ struct xt_entry_target *target;
+ int builtin;
+
+ for (list = table->entries; list; list = list->next) {
+ head = list->data;
+ entry = head->entry;
+
+ /* Buit-in chain */
+ builtin = head->builtin;
+ if (builtin >= 0 && !g_strcmp0(hooknames[builtin], chain_name))
+ break;
+
+ /* User defined chain */
+ target = ipt_get_target(entry);
+ if (!g_strcmp0(target->u.user.name, IPT_ERROR_TARGET) &&
+ !g_strcmp0((char *)target->data, chain_name))
+ break;
+ }
+
+ return list;
+}
+
+static GList *find_chain_tail(struct connman_iptables *table,
+ const char *chain_name)
+{
+ struct connman_iptables_entry *tail;
+ GList *chain_head, *list;
+
+ chain_head = find_chain_head(table, chain_name);
+ if (!chain_head)
+ return NULL;
+
+ /* Then we look for the next chain */
+ for (list = chain_head->next; list; list = list->next) {
+ tail = list->data;
+
+ if (is_chain(table, tail))
+ return list;
+ }
+
+ /* Nothing found, we return the table end */
+ return g_list_last(table->entries);
+}
+
+
+static void update_offsets(struct connman_iptables *table)
+{
+ GList *list, *prev;
+ struct connman_iptables_entry *entry, *prev_entry;
+
+ for (list = table->entries; list; list = list->next) {
+ entry = list->data;
+
+ if (list == table->entries) {
+ entry->offset = 0;
+
+ continue;
+ }
+
+ prev = list->prev;
+ prev_entry = prev->data;
+
+ entry->offset = prev_entry->offset +
+ prev_entry->entry->next_offset;
+ }
+}
+
+static void update_targets_reference(struct connman_iptables *table,
+ struct connman_iptables_entry *entry_before,
+ struct connman_iptables_entry *modified_entry,
+ bool is_removing)
+{
+ struct connman_iptables_entry *tmp;
+ struct xt_standard_target *t;
+ GList *list;
+ int offset;
+
+ offset = modified_entry->entry->next_offset;
+
+ for (list = table->entries; list; list = list->next) {
+ tmp = list->data;
+
+ if (!is_jump(tmp))
+ continue;
+
+ t = (struct xt_standard_target *)ipt_get_target(tmp->entry);
+
+ if (is_removing) {
+ if (t->verdict >= entry_before->offset)
+ t->verdict -= offset;
+ } else {
+ if (t->verdict > entry_before->offset)
+ t->verdict += offset;
+ }
+ }
+
+ if (is_fallthrough(modified_entry)) {
+ t = (struct xt_standard_target *)
+ ipt_get_target(modified_entry->entry);
+
+ t->verdict = entry_before->offset +
+ modified_entry->entry->target_offset +
+ ALIGN(sizeof(struct xt_standard_target));
+ t->target.u.target_size =
+ ALIGN(sizeof(struct xt_standard_target));
+ }
+}
+
+static int iptables_add_entry(struct connman_iptables *table,
+ struct ipt_entry *entry, GList *before,
+ int builtin, int counter_idx)
+{
+ struct connman_iptables_entry *e, *entry_before;
+
+ if (!table)
+ return -1;
+
+ e = g_try_malloc0(sizeof(struct connman_iptables_entry));
+ if (!e)
+ return -1;
+
+ e->entry = entry;
+ e->builtin = builtin;
+ e->counter_idx = counter_idx;
+
+ table->entries = g_list_insert_before(table->entries, before, e);
+ table->num_entries++;
+ table->size += entry->next_offset;
+
+ if (!before) {
+ e->offset = table->size - entry->next_offset;
+
+ return 0;
+ }
+
+ entry_before = before->data;
+
+ /*
+ * We've just appended/insterted a new entry. All references
+ * should be bumped accordingly.
+ */
+ update_targets_reference(table, entry_before, e, false);
+
+ update_offsets(table);
+
+ return 0;
+}
+
+static int remove_table_entry(struct connman_iptables *table,
+ struct connman_iptables_entry *entry)
+{
+ int removed = 0;
+
+ table->num_entries--;
+ table->size -= entry->entry->next_offset;
+ removed = entry->entry->next_offset;
+
+ table->entries = g_list_remove(table->entries, entry);
+
+ g_free(entry->entry);
+ g_free(entry);
+
+ return removed;
+}
+
+static void delete_update_hooks(struct connman_iptables *table,
+ int builtin, GList *chain_head,
+ int removed)
+{
+ struct connman_iptables_entry *e;
+ GList *list;
+
+ e = chain_head->data;
+ e->builtin = builtin;
+
+ table->underflow[builtin] -= removed;
+
+ for (list = chain_head->next; list; list = list->next) {
+ e = list->data;
+
+ if (e->builtin < 0)
+ continue;
+
+ table->hook_entry[e->builtin] -= removed;
+ table->underflow[e->builtin] -= removed;
+ }
+}
+
+static int iptables_flush_chain(struct connman_iptables *table,
+ const char *name)
+{
+ GList *chain_head, *chain_tail, *list, *next;
+ struct connman_iptables_entry *entry;
+ int builtin, removed = 0;
+
+ DBG("table %s chain %s", table->name, name);
+
+ chain_head = find_chain_head(table, name);
+ if (!chain_head)
+ return -EINVAL;
+
+ chain_tail = find_chain_tail(table, name);
+ if (!chain_tail)
+ return -EINVAL;
+
+ entry = chain_head->data;
+ builtin = entry->builtin;
+
+ if (builtin >= 0)
+ list = chain_head;
+ else
+ list = chain_head->next;
+
+ if (list == chain_tail->prev)
+ return 0;
+
+ while (list != chain_tail->prev) {
+ entry = list->data;
+ next = g_list_next(list);
+
+ removed += remove_table_entry(table, entry);
+
+ list = next;
+ }
+
+ if (builtin >= 0)
+ delete_update_hooks(table, builtin, chain_tail->prev, removed);
+
+ update_offsets(table);
+
+ return 0;
+}
+
+static int iptables_add_chain(struct connman_iptables *table,
+ const char *name)
+{
+ GList *last;
+ struct ipt_entry *entry_head;
+ struct ipt_entry *entry_return;
+ struct error_target *error;
+ struct ipt_standard_target *standard;
+ u_int16_t entry_head_size, entry_return_size;
+
+ DBG("table %s chain %s", table->name, name);
+
+ last = g_list_last(table->entries);
+
+ /*
+ * An empty chain is composed of:
+ * - A head entry, with no match and an error target.
+ * The error target data is the chain name.
+ * - A tail entry, with no match and a standard target.
+ * The standard target verdict is XT_RETURN (return to the
+ * caller).
+ */
+
+ /* head entry */
+ entry_head_size = ALIGN(sizeof(struct ipt_entry)) +
+ ALIGN(sizeof(struct error_target));
+ entry_head = g_try_malloc0(entry_head_size);
+ if (!entry_head)
+ goto err_head;
+
+ entry_head->target_offset = ALIGN(sizeof(struct ipt_entry));
+ entry_head->next_offset = entry_head_size;
+
+ error = (struct error_target *) entry_head->elems;
+ g_stpcpy(error->t.u.user.name, IPT_ERROR_TARGET);
+ error->t.u.user.target_size = ALIGN(sizeof(struct error_target));
+ g_stpcpy(error->error, name);
+
+ if (iptables_add_entry(table, entry_head, last, -1, -1) < 0)
+ goto err_head;
+
+ /* tail entry */
+ entry_return_size = ALIGN(sizeof(struct ipt_entry))+
+ ALIGN(sizeof(struct ipt_standard_target));
+ entry_return = g_try_malloc0(entry_return_size);
+ if (!entry_return)
+ goto err;
+
+ entry_return->target_offset = ALIGN(sizeof(struct ipt_entry));
+ entry_return->next_offset = entry_return_size;
+
+ standard = (struct ipt_standard_target *) entry_return->elems;
+ standard->target.u.user.target_size =
+ ALIGN(sizeof(struct ipt_standard_target));
+ standard->verdict = XT_RETURN;
+
+ if (iptables_add_entry(table, entry_return, last, -1, -1) < 0)
+ goto err;
+
+ return 0;
+
+err:
+ g_free(entry_return);
+err_head:
+ g_free(entry_head);
+
+ return -ENOMEM;
+}
+
+static int iptables_delete_chain(struct connman_iptables *table,
+ const char *name)
+{
+ struct connman_iptables_entry *entry;
+ GList *chain_head, *chain_tail;
+
+ DBG("table %s chain %s", table->name, name);
+
+ chain_head = find_chain_head(table, name);
+ if (!chain_head)
+ return -EINVAL;
+
+ entry = chain_head->data;
+
+ /* We cannot remove builtin chain */
+ if (entry->builtin >= 0)
+ return -EINVAL;
+
+ chain_tail = find_chain_tail(table, name);
+ if (!chain_tail)
+ return -EINVAL;
+
+ /* Chain must be flushed */
+ if (chain_head->next != chain_tail->prev)
+ return -EINVAL;
+
+ remove_table_entry(table, entry);
+
+ entry = chain_tail->prev->data;
+ remove_table_entry(table, entry);
+
+ update_offsets(table);
+
+ return 0;
+}
+
+static struct ipt_entry *new_rule(struct ipt_ip *ip,
+ const char *target_name, struct xtables_target *xt_t,
+ struct xtables_rule_match *xt_rm)
+{
+ struct xtables_rule_match *tmp_xt_rm;
+ struct ipt_entry *new_entry;
+ size_t match_size, target_size;
+
+ match_size = 0;
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm; tmp_xt_rm = tmp_xt_rm->next)
+ match_size += tmp_xt_rm->match->m->u.match_size;
+
+ if (xt_t)
+ target_size = xt_t->t->u.target_size;
+ else
+ target_size = ALIGN(sizeof(struct xt_standard_target));
+
+ new_entry = g_try_malloc0(ALIGN(sizeof(struct ipt_entry)) +
+ target_size + match_size);
+ if (!new_entry)
+ return NULL;
+
+ memcpy(&new_entry->ip, ip, sizeof(struct ipt_ip));
+
+ new_entry->target_offset = ALIGN(sizeof(struct ipt_entry)) +
+ match_size;
+ new_entry->next_offset = ALIGN(sizeof(struct ipt_entry)) +
+ target_size + match_size;
+
+ match_size = 0;
+ for (tmp_xt_rm = xt_rm; tmp_xt_rm;
+ tmp_xt_rm = tmp_xt_rm->next) {
+ memcpy(new_entry->elems + match_size, tmp_xt_rm->match->m,
+ tmp_xt_rm->match->m->u.match_size);
+ match_size += tmp_xt_rm->match->m->u.match_size;
+ }
+
+ if (xt_t) {
+ struct xt_entry_target *entry_target;
+
+ entry_target = ipt_get_target(new_entry);
+ memcpy(entry_target, xt_t->t, target_size);
+ }
+
+ return new_entry;
+}
+
+static void update_hooks(struct connman_iptables *table, GList *chain_head,
+ struct ipt_entry *entry)
+{
+ GList *list;
+ struct connman_iptables_entry *head, *e;
+ int builtin;
+
+ if (!chain_head)
+ return;
+
+ head = chain_head->data;
+
+ builtin = head->builtin;
+ if (builtin < 0)
+ return;
+
+ table->underflow[builtin] += entry->next_offset;
+
+ for (list = chain_head->next; list; list = list->next) {
+ e = list->data;
+
+ builtin = e->builtin;
+ if (builtin < 0)
+ continue;
+
+ table->hook_entry[builtin] += entry->next_offset;
+ table->underflow[builtin] += entry->next_offset;
+ }
+}
+
+static struct ipt_entry *prepare_rule_inclusion(struct connman_iptables *table,
+ struct ipt_ip *ip, const char *chain_name,
+ const char *target_name,
+ struct xtables_target *xt_t,
+ int *builtin, struct xtables_rule_match *xt_rm,
+ bool insert)
+{
+ GList *chain_tail, *chain_head;
+ struct ipt_entry *new_entry;
+ struct connman_iptables_entry *head;
+
+ chain_head = find_chain_head(table, chain_name);
+ if (!chain_head)
+ return NULL;
+
+ chain_tail = find_chain_tail(table, chain_name);
+ if (!chain_tail)
+ return NULL;
+
+ new_entry = new_rule(ip, target_name, xt_t, xt_rm);
+ if (!new_entry)
+ return NULL;
+
+ update_hooks(table, chain_head, new_entry);
+
+ /*
+ * If the chain is builtin, and does not have any rule,
+ * then the one that we're inserting is becoming the head
+ * and thus needs the builtin flag.
+ */
+ head = chain_head->data;
+ if (head->builtin < 0)
+ *builtin = -1;
+ else if (insert || chain_head == chain_tail->prev) {
+ *builtin = head->builtin;
+ head->builtin = -1;
+ }
+
+ return new_entry;
+}
+
+static int iptables_append_rule(struct connman_iptables *table,
+ struct ipt_ip *ip, const char *chain_name,
+ const char *target_name,
+ struct xtables_target *xt_t,
+ struct xtables_rule_match *xt_rm)
+{
+ struct ipt_entry *new_entry;
+ int builtin = -1, ret;
+ GList *chain_tail;
+
+ DBG("table %s chain %s", table->name, chain_name);
+
+ chain_tail = find_chain_tail(table, chain_name);
+ if (!chain_tail)
+ return -EINVAL;
+
+ new_entry = prepare_rule_inclusion(table, ip, chain_name,
+ target_name, xt_t, &builtin, xt_rm, false);
+ if (!new_entry)
+ return -EINVAL;
+
+ ret = iptables_add_entry(table, new_entry, chain_tail->prev, builtin, -1);
+ if (ret < 0)
+ g_free(new_entry);
+
+ return ret;
+}
+
+static int iptables_insert_rule(struct connman_iptables *table,
+ struct ipt_ip *ip, const char *chain_name,
+ const char *target_name,
+ struct xtables_target *xt_t,
+ struct xtables_rule_match *xt_rm)
+{
+ struct ipt_entry *new_entry;
+ int builtin = -1, ret;
+ GList *chain_head;
+
+ DBG("table %s chain %s", table->name, chain_name);
+
+ chain_head = find_chain_head(table, chain_name);
+ if (!chain_head)
+ return -EINVAL;
+
+ new_entry = prepare_rule_inclusion(table, ip, chain_name,
+ target_name, xt_t, &builtin, xt_rm, true);
+ if (!new_entry)
+ return -EINVAL;
+
+ if (builtin == -1)
+ chain_head = chain_head->next;
+
+ ret = iptables_add_entry(table, new_entry, chain_head, builtin, -1);
+ if (ret < 0)
+ g_free(new_entry);
+
+ return ret;
+}
+
+static bool is_same_ipt_entry(struct ipt_entry *i_e1,
+ struct ipt_entry *i_e2)
+{
+ if (memcmp(&i_e1->ip, &i_e2->ip, sizeof(struct ipt_ip)) != 0)
+ return false;
+
+ if (i_e1->target_offset != i_e2->target_offset)
+ return false;
+
+ if (i_e1->next_offset != i_e2->next_offset)
+ return false;
+
+ return true;
+}
+
+static bool is_same_target(struct xt_entry_target *xt_e_t1,
+ struct xt_entry_target *xt_e_t2)
+{
+ unsigned int i;
+
+ if (!xt_e_t1 || !xt_e_t2)
+ return false;
+
+ if (g_strcmp0(xt_e_t1->u.user.name, "") == 0 &&
+ g_strcmp0(xt_e_t2->u.user.name, "") == 0) {
+ /* fallthrough */
+ return true;
+ } else if (g_strcmp0(xt_e_t1->u.user.name, IPT_STANDARD_TARGET) == 0) {
+ struct xt_standard_target *xt_s_t1;
+ struct xt_standard_target *xt_s_t2;
+
+ xt_s_t1 = (struct xt_standard_target *) xt_e_t1;
+ xt_s_t2 = (struct xt_standard_target *) xt_e_t2;
+
+ if (xt_s_t1->verdict != xt_s_t2->verdict)
+ return false;
+ } else {
+ if (xt_e_t1->u.target_size != xt_e_t2->u.target_size)
+ return false;
+
+ if (g_strcmp0(xt_e_t1->u.user.name, xt_e_t2->u.user.name) != 0)
+ return false;
+
+ for (i = 0; i < xt_e_t1->u.target_size -
+ sizeof(struct xt_standard_target); i++) {
+ if ((xt_e_t1->data[i] ^ xt_e_t2->data[i]) != 0)
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static bool is_same_match(struct xt_entry_match *xt_e_m1,
+ struct xt_entry_match *xt_e_m2)
+{
+ unsigned int i;
+
+ if (!xt_e_m1 || !xt_e_m2)
+ return false;
+
+ if (xt_e_m1->u.match_size != xt_e_m2->u.match_size)
+ return false;
+
+ if (xt_e_m1->u.user.revision != xt_e_m2->u.user.revision)
+ return false;
+
+ if (g_strcmp0(xt_e_m1->u.user.name, xt_e_m2->u.user.name) != 0)
+ return false;
+
+ for (i = 0; i < xt_e_m1->u.match_size - sizeof(struct xt_entry_match);
+ i++) {
+ if ((xt_e_m1->data[i] ^ xt_e_m2->data[i]) != 0)
+ return false;
+ }
+
+ return true;
+}
+
+static GList *find_existing_rule(struct connman_iptables *table,
+ struct ipt_ip *ip, const char *chain_name,
+ const char *target_name,
+ struct xtables_target *xt_t,
+ GList *matches,
+ struct xtables_rule_match *xt_rm)
+{
+ GList *chain_tail, *chain_head, *list;
+ struct xt_entry_target *xt_e_t = NULL;
+ struct xt_entry_match *xt_e_m = NULL;
+ struct connman_iptables_entry *entry;
+ struct ipt_entry *entry_test;
+ int builtin;
+
+ chain_head = find_chain_head(table, chain_name);
+ if (!chain_head)
+ return NULL;
+
+ chain_tail = find_chain_tail(table, chain_name);
+ if (!chain_tail)
+ return NULL;
+
+ if (!xt_t && !matches)
+ return NULL;
+
+ entry_test = new_rule(ip, target_name, xt_t, xt_rm);
+ if (!entry_test)
+ return NULL;
+
+ if (xt_t)
+ xt_e_t = ipt_get_target(entry_test);
+ if (matches)
+ xt_e_m = (struct xt_entry_match *)entry_test->elems;
+
+ entry = chain_head->data;
+ builtin = entry->builtin;
+
+ if (builtin >= 0)
+ list = chain_head;
+ else
+ list = chain_head->next;
+
+ for (; list != chain_tail->prev; list = list->next) {
+ struct connman_iptables_entry *tmp;
+ struct ipt_entry *tmp_e;
+
+ tmp = list->data;
+ tmp_e = tmp->entry;
+
+ if (!is_same_ipt_entry(entry_test, tmp_e))
+ continue;
+
+ if (xt_t) {
+ struct xt_entry_target *tmp_xt_e_t;
+
+ tmp_xt_e_t = ipt_get_target(tmp_e);
+
+ if (!is_same_target(tmp_xt_e_t, xt_e_t))
+ continue;
+ }
+
+ if (matches) {
+ struct xt_entry_match *tmp_xt_e_m;
+
+ tmp_xt_e_m = (struct xt_entry_match *)tmp_e->elems;
+
+ if (!is_same_match(tmp_xt_e_m, xt_e_m))
+ continue;
+ }
+
+ break;
+ }
+
+ g_free(entry_test);
+
+ if (list != chain_tail->prev)
+ return list;
+
+ return NULL;
+}
+
+static int iptables_delete_rule(struct connman_iptables *table,
+ struct ipt_ip *ip, const char *chain_name,
+ const char *target_name,
+ struct xtables_target *xt_t,
+ GList *matches,
+ struct xtables_rule_match *xt_rm)
+{
+ struct connman_iptables_entry *entry;
+ GList *chain_head, *chain_tail, *list;
+ int builtin, removed;
+
+
+ DBG("table %s chain %s", table->name, chain_name);
+
+ removed = 0;
+
+ chain_head = find_chain_head(table, chain_name);
+ if (!chain_head)
+ return -EINVAL;
+
+ chain_tail = find_chain_tail(table, chain_name);
+ if (!chain_tail)
+ return -EINVAL;
+
+ list = find_existing_rule(table, ip, chain_name, target_name,
+ xt_t, matches, xt_rm);
+ if (!list)
+ return -EINVAL;
+
+ entry = chain_head->data;
+ builtin = entry->builtin;
+
+ if (builtin >= 0 && list == chain_head) {
+ /*
+ * We are about to remove the first rule in the
+ * chain. In this case we need to store the builtin
+ * value to the new chain_head.
+ *
+ * Note, for builtin chains, chain_head->next is
+ * always valid. A builtin chain has always a policy
+ * rule at the end.
+ */
+ chain_head = chain_head->next;
+
+ entry = chain_head->data;
+ entry->builtin = builtin;
+ }
+
+ entry = list->data;
+ if (!entry)
+ return -EINVAL;
+
+ /* We have deleted a rule,
+ * all references should be bumped accordingly */
+ if (list->next)
+ update_targets_reference(table, list->next->data,
+ list->data, true);
+
+ removed += remove_table_entry(table, entry);
+
+ if (builtin >= 0)
+ delete_update_hooks(table, builtin, chain_head, removed);
+
+ update_offsets(table);
+
+ return 0;
+}
+
+static int iptables_change_policy(struct connman_iptables *table,
+ const char *chain_name, const char *policy)
+{
+ GList *chain_head, *chain_tail;
+ struct connman_iptables_entry *entry;
+ struct xt_entry_target *target;
+ struct xt_standard_target *t;
+ int verdict;
+
+ DBG("table %s chain %s policy %s", table->name, chain_name, policy);
+
+ verdict = target_to_verdict(policy);
+ switch (verdict) {
+ case -NF_ACCEPT - 1:
+ case -NF_DROP - 1:
+ break;
+ default:
+ return -EINVAL;
+ }
+
+ chain_head = find_chain_head(table, chain_name);
+ if (!chain_head)
+ return -EINVAL;
+
+ entry = chain_head->data;
+ if (entry->builtin < 0)
+ return -EINVAL;
+
+ chain_tail = find_chain_tail(table, chain_name);
+ if (!chain_tail)
+ return -EINVAL;
+
+ entry = chain_tail->prev->data;
+ target = ipt_get_target(entry->entry);
+
+ t = (struct xt_standard_target *)target;
+ if (t->verdict != verdict)
+ entry->counter_idx = -1;
+ t->verdict = verdict;
+
+ return 0;
+}
+
+static struct ipt_replace *iptables_blob(struct connman_iptables *table)
+{
+ struct ipt_replace *r;
+ GList *list;
+ struct connman_iptables_entry *e;
+ unsigned char *entry_index;
+
+ r = g_try_malloc0(sizeof(struct ipt_replace) + table->size);
+ if (!r)
+ return NULL;
+
+ memset(r, 0, sizeof(*r) + table->size);
+
+ r->counters = g_try_malloc0(sizeof(struct xt_counters)
+ * table->old_entries);
+ if (!r->counters) {
+ g_free(r);
+ return NULL;
+ }
+
+ g_stpcpy(r->name, table->info->name);
+ r->num_entries = table->num_entries;
+ r->size = table->size;
+
+ r->num_counters = table->old_entries;
+ r->valid_hooks = table->info->valid_hooks;
+
+ memcpy(r->hook_entry, table->hook_entry, sizeof(table->hook_entry));
+ memcpy(r->underflow, table->underflow, sizeof(table->underflow));
+
+ entry_index = (unsigned char *)r->entries;
+ for (list = table->entries; list; list = list->next) {
+ e = list->data;
+
+ memcpy(entry_index, e->entry, e->entry->next_offset);
+ entry_index += e->entry->next_offset;
+ }
+
+ return r;
+}
+
+static void dump_ip(struct ipt_entry *entry)
+{
+ struct ipt_ip *ip = &entry->ip;
+ char ip_string[INET6_ADDRSTRLEN];
+ char ip_mask[INET6_ADDRSTRLEN];
+
+ if (strlen(ip->iniface))
+ DBG("\tin %s", ip->iniface);
+
+ if (strlen(ip->outiface))
+ DBG("\tout %s", ip->outiface);
+
+ if (inet_ntop(AF_INET, &ip->src, ip_string, INET6_ADDRSTRLEN) &&
+ inet_ntop(AF_INET, &ip->smsk, ip_mask,
+ INET6_ADDRSTRLEN))
+ DBG("\tsrc %s/%s", ip_string, ip_mask);
+
+ if (inet_ntop(AF_INET, &ip->dst, ip_string, INET6_ADDRSTRLEN) &&
+ inet_ntop(AF_INET, &ip->dmsk, ip_mask,
+ INET6_ADDRSTRLEN))
+ DBG("\tdst %s/%s", ip_string, ip_mask);
+}
+
+static void dump_target(struct ipt_entry *entry)
+
+{
+ struct xtables_target *xt_t;
+ struct xt_entry_target *target;
+
+ target = ipt_get_target(entry);
+
+ if (!g_strcmp0(target->u.user.name, IPT_STANDARD_TARGET)) {
+ struct xt_standard_target *t;
+
+ t = (struct xt_standard_target *)target;
+
+ switch (t->verdict) {
+ case XT_RETURN:
+ DBG("\ttarget RETURN");
+ break;
+
+ case -NF_ACCEPT - 1:
+ DBG("\ttarget ACCEPT");
+ break;
+
+ case -NF_DROP - 1:
+ DBG("\ttarget DROP");
+ break;
+
+ case -NF_QUEUE - 1:
+ DBG("\ttarget QUEUE");
+ break;
+
+ case -NF_STOP - 1:
+ DBG("\ttarget STOP");
+ break;
+
+ default:
+ DBG("\tJUMP %u", t->verdict);
+ break;
+ }
+
+ xt_t = xtables_find_target(IPT_STANDARD_TARGET,
+ XTF_LOAD_MUST_SUCCEED);
+
+ if (xt_t->print)
+ xt_t->print(NULL, target, 1);
+ } else {
+ xt_t = xtables_find_target(target->u.user.name, XTF_TRY_LOAD);
+ if (!xt_t) {
+ DBG("\ttarget %s", target->u.user.name);
+ return;
+ }
+
+ if (xt_t->print) {
+ DBG("\ttarget ");
+ xt_t->print(NULL, target, 1);
+ }
+ }
+
+ if (xt_t == xt_t->next)
+ free(xt_t);
+}
+
+static void dump_match(struct ipt_entry *entry)
+{
+ struct xtables_match *xt_m;
+ struct xt_entry_match *match;
+
+ if (entry->elems == (unsigned char *)entry + entry->target_offset)
+ return;
+
+ match = (struct xt_entry_match *) entry->elems;
+
+ if (!strlen(match->u.user.name))
+ return;
+
+ xt_m = xtables_find_match(match->u.user.name, XTF_TRY_LOAD, NULL);
+ if (!xt_m)
+ goto out;
+
+ if (xt_m->print) {
+ DBG("\tmatch ");
+ xt_m->print(NULL, match, 1);
+
+ return;
+ }
+ if (xt_m == xt_m->next)
+ free(xt_m);
+
+out:
+ DBG("\tmatch %s", match->u.user.name);
+
+}
+
+static int dump_entry(struct ipt_entry *entry, int builtin,
+ unsigned int hook, size_t size, unsigned int offset,
+ void *user_data)
+{
+ struct xt_entry_target *target;
+
+ target = ipt_get_target(entry);
+
+ if (offset + entry->next_offset == size) {
+ DBG("\tEnd of CHAIN");
+ return 0;
+ }
+
+ if (!g_strcmp0(target->u.user.name, IPT_ERROR_TARGET)) {
+ DBG("\tUSER CHAIN (%s) match %p target %p",
+ target->data, entry->elems,
+ (char *)entry + entry->target_offset);
+
+ return 0;
+ } else if (builtin >= 0) {
+ DBG("\tCHAIN (%s) match %p target %p",
+ hooknames[builtin], entry->elems,
+ (char *)entry + entry->target_offset);
+ } else {
+ DBG("\tRULE match %p target %p",
+ entry->elems,
+ (char *)entry + entry->target_offset);
+ }
+
+ dump_match(entry);
+ dump_target(entry);
+ dump_ip(entry);
+
+ return 0;
+}
+
+static void dump_table(struct connman_iptables *table)
+{
+ DBG("%s valid_hooks=0x%08x, num_entries=%u, size=%u",
+ table->info->name,
+ table->info->valid_hooks, table->info->num_entries,
+ table->info->size);
+
+ DBG("entry hook: pre/in/fwd/out/post %d/%d/%d/%d/%d",
+ table->info->hook_entry[NF_IP_PRE_ROUTING],
+ table->info->hook_entry[NF_IP_LOCAL_IN],
+ table->info->hook_entry[NF_IP_FORWARD],
+ table->info->hook_entry[NF_IP_LOCAL_OUT],
+ table->info->hook_entry[NF_IP_POST_ROUTING]);
+ DBG("underflow: pre/in/fwd/out/post %d/%d/%d/%d/%d",
+ table->info->underflow[NF_IP_PRE_ROUTING],
+ table->info->underflow[NF_IP_LOCAL_IN],
+ table->info->underflow[NF_IP_FORWARD],
+ table->info->underflow[NF_IP_LOCAL_OUT],
+ table->info->underflow[NF_IP_POST_ROUTING]);
+
+ iterate_entries(table->blob_entries->entrytable,
+ table->info->valid_hooks,
+ table->info->hook_entry,
+ table->info->underflow,
+ table->blob_entries->size,
+ print_entry, dump_entry);
+}
+
+static void dump_ipt_replace(struct ipt_replace *repl)
+{
+ DBG("%s valid_hooks 0x%08x num_entries %u size %u",
+ repl->name, repl->valid_hooks, repl->num_entries,
+ repl->size);
+
+ DBG("entry hook: pre/in/fwd/out/post %d/%d/%d/%d/%d",
+ repl->hook_entry[NF_IP_PRE_ROUTING],
+ repl->hook_entry[NF_IP_LOCAL_IN],
+ repl->hook_entry[NF_IP_FORWARD],
+ repl->hook_entry[NF_IP_LOCAL_OUT],
+ repl->hook_entry[NF_IP_POST_ROUTING]);
+ DBG("underflow: pre/in/fwd/out/post %d/%d/%d/%d/%d",
+ repl->underflow[NF_IP_PRE_ROUTING],
+ repl->underflow[NF_IP_LOCAL_IN],
+ repl->underflow[NF_IP_FORWARD],
+ repl->underflow[NF_IP_LOCAL_OUT],
+ repl->underflow[NF_IP_POST_ROUTING]);
+
+ iterate_entries(repl->entries, repl->valid_hooks,
+ repl->hook_entry, repl->underflow,
+ repl->size, print_entry, dump_entry);
+}
+
+static int iptables_get_entries(struct connman_iptables *table)
+{
+ socklen_t entry_size;
+ int err;
+
+ entry_size = sizeof(struct ipt_get_entries) + table->info->size;
+
+ err = getsockopt(table->ipt_sock, IPPROTO_IP, IPT_SO_GET_ENTRIES,
+ table->blob_entries, &entry_size);
+ if (err < 0)
+ return -errno;
+
+ return 0;
+}
+
+static int iptables_replace(struct connman_iptables *table,
+ struct ipt_replace *r)
+{
+ int err;
+
+ err = setsockopt(table->ipt_sock, IPPROTO_IP, IPT_SO_SET_REPLACE, r,
+ sizeof(*r) + r->size);
+ if (err < 0)
+ return -errno;
+
+ return 0;
+}
+
+static int iptables_add_counters(struct connman_iptables *table,
+ struct xt_counters_info *c)
+{
+ int err;
+
+ err = setsockopt(table->ipt_sock, IPPROTO_IP, IPT_SO_SET_ADD_COUNTERS, c,
+ sizeof(*c) + sizeof(struct xt_counters) * c->num_counters);
+ if (err < 0)
+ return -errno;
+
+ return 0;
+}
+
+static int add_entry(struct ipt_entry *entry, int builtin, unsigned int hook,
+ size_t size, unsigned offset, void *user_data)
+{
+ struct connman_iptables *table = user_data;
+ struct ipt_entry *new_entry;
+
+ new_entry = g_try_malloc0(entry->next_offset);
+ if (!new_entry)
+ return -ENOMEM;
+
+ memcpy(new_entry, entry, entry->next_offset);
+
+ return iptables_add_entry(table, new_entry, NULL, builtin,
+ table->num_entries);
+}
+
+static void table_cleanup(struct connman_iptables *table)
+{
+ GList *list;
+ struct connman_iptables_entry *entry;
+
+ if (!table)
+ return;
+
+ if (table->ipt_sock >= 0)
+ close(table->ipt_sock);
+
+ for (list = table->entries; list; list = list->next) {
+ entry = list->data;
+
+ g_free(entry->entry);
+ g_free(entry);
+ }
+
+ g_list_free(table->entries);
+ g_free(table->name);
+ g_free(table->info);
+ g_free(table->blob_entries);
+ g_free(table);
+}
+
+static struct connman_iptables *iptables_init(const char *table_name)
+{
+ struct connman_iptables *table = NULL;
+ char *module = NULL;
+ socklen_t s;
+
+ DBG("%s", table_name);
+
+ if (xtables_insmod("ip_tables", NULL, TRUE) != 0)
+ DBG("ip_tables module loading gives error but trying anyway");
+
+ module = g_strconcat("iptable_", table_name, NULL);
+ if (!module)
+ return NULL;
+
+ if (xtables_insmod(module, NULL, TRUE) != 0)
+ DBG("%s module loading gives error but trying anyway", module);
+
+ g_free(module);
+
+ table = g_try_new0(struct connman_iptables, 1);
+ if (!table)
+ return NULL;
+
+ table->info = g_try_new0(struct ipt_getinfo, 1);
+ if (!table->info)
+ goto err;
+
+ table->ipt_sock = socket(AF_INET, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
+ if (table->ipt_sock < 0)
+ goto err;
+
+ s = sizeof(*table->info);
+ g_stpcpy(table->info->name, table_name);
+ if (getsockopt(table->ipt_sock, IPPROTO_IP, IPT_SO_GET_INFO,
+ table->info, &s) < 0) {
+ connman_error("iptables support missing error %d (%s)", errno,
+ strerror(errno));
+ goto err;
+ }
+
+ table->blob_entries = g_try_malloc0(sizeof(struct ipt_get_entries) +
+ table->info->size);
+ if (!table->blob_entries)
+ goto err;
+
+ g_stpcpy(table->blob_entries->name, table_name);
+ table->blob_entries->size = table->info->size;
+
+ if (iptables_get_entries(table) < 0)
+ goto err;
+
+ table->num_entries = 0;
+ table->old_entries = table->info->num_entries;
+ table->size = 0;
+
+ memcpy(table->underflow, table->info->underflow,
+ sizeof(table->info->underflow));
+ memcpy(table->hook_entry, table->info->hook_entry,
+ sizeof(table->info->hook_entry));
+
+ iterate_entries(table->blob_entries->entrytable,
+ table->info->valid_hooks, table->info->hook_entry,
+ table->info->underflow, table->blob_entries->size,
+ add_entry, table);
+
+ if (debug_enabled)
+ dump_table(table);
+
+ return table;
+
+err:
+ table_cleanup(table);
+
+ return NULL;
+}
+
+static struct option iptables_opts[] = {
+ {.name = "append", .has_arg = 1, .val = 'A'},
+ {.name = "compare", .has_arg = 1, .val = 'C'},
+ {.name = "delete", .has_arg = 1, .val = 'D'},
+ {.name = "flush-chain", .has_arg = 1, .val = 'F'},
+ {.name = "insert", .has_arg = 1, .val = 'I'},
+ {.name = "list", .has_arg = 2, .val = 'L'},
+ {.name = "new-chain", .has_arg = 1, .val = 'N'},
+ {.name = "policy", .has_arg = 1, .val = 'P'},
+ {.name = "delete-chain", .has_arg = 1, .val = 'X'},
+ {.name = "destination", .has_arg = 1, .val = 'd'},
+ {.name = "in-interface", .has_arg = 1, .val = 'i'},
+ {.name = "jump", .has_arg = 1, .val = 'j'},
+ {.name = "match", .has_arg = 1, .val = 'm'},
+ {.name = "out-interface", .has_arg = 1, .val = 'o'},
+ {.name = "source", .has_arg = 1, .val = 's'},
+ {.name = "table", .has_arg = 1, .val = 't'},
+ {NULL},
+};
+
+struct xtables_globals iptables_globals = {
+ .option_offset = 0,
+ .opts = iptables_opts,
+ .orig_opts = iptables_opts,
+};
+
+static struct xtables_target *prepare_target(struct connman_iptables *table,
+ const char *target_name)
+{
+ struct xtables_target *xt_t = NULL;
+ bool is_builtin, is_user_defined;
+ GList *chain_head = NULL;
+ size_t target_size;
+
+ is_builtin = false;
+ is_user_defined = false;
+
+ if (is_builtin_target(target_name))
+ is_builtin = true;
+ else {
+ chain_head = find_chain_head(table, target_name);
+ if (chain_head && chain_head->next)
+ is_user_defined = true;
+ }
+
+ if (is_builtin || is_user_defined)
+ xt_t = xtables_find_target(IPT_STANDARD_TARGET,
+ XTF_LOAD_MUST_SUCCEED);
+ else
+ xt_t = xtables_find_target(target_name, XTF_TRY_LOAD);
+
+ if (!xt_t)
+ return NULL;
+
+ target_size = ALIGN(sizeof(struct ipt_entry_target)) + xt_t->size;
+
+ xt_t->t = g_try_malloc0(target_size);
+ if (!xt_t->t)
+ return NULL;
+
+ xt_t->t->u.target_size = target_size;
+
+ if (is_builtin || is_user_defined) {
+ struct xt_standard_target *target;
+
+ target = (struct xt_standard_target *)(xt_t->t);
+ g_stpcpy(target->target.u.user.name, IPT_STANDARD_TARGET);
+
+ if (is_builtin)
+ target->verdict = target_to_verdict(target_name);
+ else if (is_user_defined) {
+ struct connman_iptables_entry *target_rule;
+
+ target_rule = chain_head->next->data;
+ target->verdict = target_rule->offset;
+ }
+ } else {
+ g_stpcpy(xt_t->t->u.user.name, target_name);
+ xt_t->t->u.user.revision = xt_t->revision;
+ if (xt_t->init)
+ xt_t->init(xt_t->t);
+ }
+
+ if (xt_t->x6_options)
+ iptables_globals.opts =
+ xtables_options_xfrm(
+ iptables_globals.orig_opts,
+ iptables_globals.opts,
+ xt_t->x6_options,
+ &xt_t->option_offset);
+ else
+ iptables_globals.opts =
+ xtables_merge_options(
+ iptables_globals.orig_opts,
+ iptables_globals.opts,
+ xt_t->extra_opts,
+ &xt_t->option_offset);
+
+ if (!iptables_globals.opts) {
+ g_free(xt_t->t);
+ xt_t = NULL;
+ }
+
+ return xt_t;
+}
+
+static struct xtables_match *prepare_matches(struct connman_iptables *table,
+ struct xtables_rule_match **xt_rm,
+ const char *match_name)
+{
+ struct xtables_match *xt_m;
+ size_t match_size;
+
+ if (!match_name)
+ return NULL;
+
+ xt_m = xtables_find_match(match_name, XTF_LOAD_MUST_SUCCEED, xt_rm);
+ match_size = ALIGN(sizeof(struct ipt_entry_match)) + xt_m->size;
+
+ xt_m->m = g_try_malloc0(match_size);
+ if (!xt_m->m)
+ return NULL;
+
+ xt_m->m->u.match_size = match_size;
+ g_stpcpy(xt_m->m->u.user.name, xt_m->name);
+ xt_m->m->u.user.revision = xt_m->revision;
+
+ if (xt_m->init)
+ xt_m->init(xt_m->m);
+
+ if (xt_m->x6_options)
+ iptables_globals.opts =
+ xtables_options_xfrm(
+ iptables_globals.orig_opts,
+ iptables_globals.opts,
+ xt_m->x6_options,
+ &xt_m->option_offset);
+ else
+ iptables_globals.opts =
+ xtables_merge_options(
+ iptables_globals.orig_opts,
+ iptables_globals.opts,
+ xt_m->extra_opts,
+ &xt_m->option_offset);
+
+ if (!iptables_globals.opts) {
+ g_free(xt_m->m);
+
+ if (xt_m == xt_m->next)
+ free(xt_m);
+
+ xt_m = NULL;
+ }
+
+ return xt_m;
+}
+
+static int parse_ip_and_mask(const char *str, struct in_addr *ip,
+ struct in_addr *mask)
+{
+ char **tokens;
+ uint32_t prefixlength;
+ uint32_t tmp;
+ int err;
+
+ tokens = g_strsplit(str, "/", 2);
+ if (!tokens)
+ return -1;
+
+ if (!inet_pton(AF_INET, tokens[0], ip)) {
+ err = -1;
+ goto out;
+ }
+
+ if (tokens[1]) {
+ prefixlength = strtol(tokens[1], NULL, 10);
+ if (prefixlength > 31) {
+ err = -1;
+ goto out;
+ }
+
+ tmp = ~(0xffffffff >> prefixlength);
+ } else {
+ tmp = 0xffffffff;
+ }
+
+ mask->s_addr = htonl(tmp);
+ ip->s_addr = ip->s_addr & mask->s_addr;
+ err = 0;
+out:
+ g_strfreev(tokens);
+
+ return err;
+}
+
+static struct connman_iptables *get_table(const char *table_name)
+{
+ struct connman_iptables *table;
+
+ if (!table_name)
+ table_name = "filter";
+
+ table = g_hash_table_lookup(table_hash, table_name);
+ if (table)
+ return table;
+
+ table = iptables_init(table_name);
+ if (!table)
+ return NULL;
+
+ table->name = g_strdup(table_name);
+ g_hash_table_replace(table_hash, table->name, table);
+
+ return table;
+}
+
+struct parse_context {
+ int argc;
+ char **argv;
+ struct ipt_ip *ip;
+ struct xtables_target *xt_t;
+ GList *xt_m;
+ struct xtables_rule_match *xt_rm;
+};
+
+static int prepare_getopt_args(const char *str, struct parse_context *ctx)
+{
+ char **tokens;
+ int i;
+
+ tokens = g_strsplit_set(str, " ", -1);
+
+ i = g_strv_length(tokens);
+
+ /* Add space for the argv[0] value */
+ ctx->argc = i + 1;
+
+ /* Don't forget the last NULL entry */
+ ctx->argv = g_try_malloc0((ctx->argc + 1) * sizeof(char *));
+ if (!ctx->argv) {
+ g_strfreev(tokens);
+ return -ENOMEM;
+ }
+
+ /*
+ * getopt_long() jumps over the first token; we need to add some
+ * random argv[0] entry.
+ */
+ ctx->argv[0] = g_strdup("argh");
+ for (i = 1; i < ctx->argc; i++)
+ ctx->argv[i] = tokens[i - 1];
+
+ g_free(tokens);
+
+ return 0;
+}
+
+static int parse_xt_modules(int c, bool invert,
+ struct parse_context *ctx)
+{
+ struct xtables_match *m;
+ struct xtables_rule_match *rm;
+
+ for (rm = ctx->xt_rm; rm; rm = rm->next) {
+ if (rm->completed != 0)
+ continue;
+
+ m = rm->match;
+
+ if (!m->x6_parse && !m->parse)
+ continue;
+
+ if (c < (int) m->option_offset ||
+ c >= (int) m->option_offset
+ + XT_OPTION_OFFSET_SCALE)
+ continue;
+
+ xtables_option_mpcall(c, ctx->argv, invert, m, NULL);
+ }
+
+ if (!ctx->xt_t)
+ return 0;
+
+ if (!ctx->xt_t->x6_parse && !ctx->xt_t->parse)
+ return 0;
+
+ if (c < (int) ctx->xt_t->option_offset ||
+ c >= (int) ctx->xt_t->option_offset
+ + XT_OPTION_OFFSET_SCALE)
+ return 0;
+
+ xtables_option_tpcall(c, ctx->argv, invert, ctx->xt_t, NULL);
+
+ return 0;
+}
+
+static int final_check_xt_modules(struct parse_context *ctx)
+{
+ struct xtables_rule_match *rm;
+
+ for (rm = ctx->xt_rm; rm; rm = rm->next)
+ xtables_option_mfcall(rm->match);
+
+ if (ctx->xt_t)
+ xtables_option_tfcall(ctx->xt_t);
+
+ return 0;
+}
+
+static int parse_rule_spec(struct connman_iptables *table,
+ struct parse_context *ctx)
+{
+ /*
+ * How the parser works:
+ *
+ * - If getopt finds 's', 'd', 'i', 'o'.
+ * just extract the information.
+ * - if '!' is found, set the invert flag to true and
+ * removes the '!' from the optarg string and jumps
+ * back to getopt to reparse the current optarg string.
+ * After reparsing the invert flag is reseted to false.
+ * - If 'm' or 'j' is found then call either
+ * prepare_matches() or prepare_target(). Those function
+ * will modify (extend) the longopts for getopt_long.
+ * That means getopt will change its matching context according
+ * the loaded target.
+ *
+ * Here an example with iptables-test
+ *
+ * argv[0] = ./tools/iptables-test
+ * argv[1] = -t
+ * argv[2] = filter
+ * argv[3] = -A
+ * argv[4] = INPUT
+ * argv[5] = -m
+ * argv[6] = mark
+ * argv[7] = --mark
+ * argv[8] = 999
+ * argv[9] = -j
+ * argv[10] = LOG
+ *
+ * getopt found 'm' then the optarg is "mark" and optind 7
+ * The longopts array containts before hitting the `case 'm'`
+ *
+ * val A has_arg 1 name append
+ * val C has_arg 1 name compare
+ * val D has_arg 1 name delete
+ * val F has_arg 1 name flush-chain
+ * val I has_arg 1 name insert
+ * val L has_arg 2 name list
+ * val N has_arg 1 name new-chain
+ * val P has_arg 1 name policy
+ * val X has_arg 1 name delete-chain
+ * val d has_arg 1 name destination
+ * val i has_arg 1 name in-interface
+ * val j has_arg 1 name jump
+ * val m has_arg 1 name match
+ * val o has_arg 1 name out-interface
+ * val s has_arg 1 name source
+ * val t has_arg 1 name table
+ *
+ * After executing the `case 'm'` block longopts is
+ *
+ * val A has_arg 1 name append
+ * val C has_arg 1 name compare
+ * val D has_arg 1 name delete
+ * val F has_arg 1 name flush-chain
+ * val I has_arg 1 name insert
+ * val L has_arg 2 name list
+ * val N has_arg 1 name new-chain
+ * val P has_arg 1 name policy
+ * val X has_arg 1 name delete-chain
+ * val d has_arg 1 name destination
+ * val i has_arg 1 name in-interface
+ * val j has_arg 1 name jump
+ * val m has_arg 1 name match
+ * val o has_arg 1 name out-interface
+ * val s has_arg 1 name source
+ * val t has_arg 1 name table
+ * val has_arg 1 name mark
+ *
+ * So the 'mark' matcher has added the 'mark' options
+ * and getopt will then return c '256' optarg "999" optind 9
+ * And we will hit the 'default' statement which then
+ * will call the matchers parser (xt_m->parser() or
+ * xtables_option_mpcall() depending on which version
+ * of libxtables is found.
+ */
+ struct xtables_match *xt_m;
+ bool invert = false;
+ int len, c, err;
+
+ ctx->ip = g_try_new0(struct ipt_ip, 1);
+ if (!ctx->ip)
+ return -ENOMEM;
+
+ /*
+ * Tell getopt_long not to generate error messages for unknown
+ * options and also reset optind back to 0.
+ */
+ opterr = 0;
+ optind = 0;
+
+ while ((c = getopt_long(ctx->argc, ctx->argv,
+ "-:d:i:o:s:m:j:",
+ iptables_globals.opts, NULL)) != -1) {
+ switch (c) {
+ case 's':
+ /* Source specification */
+ if (!parse_ip_and_mask(optarg,
+ &ctx->ip->src,
+ &ctx->ip->smsk))
+ break;
+
+ if (invert)
+ ctx->ip->invflags |= IPT_INV_SRCIP;
+
+ break;
+ case 'd':
+ /* Destination specification */
+ if (!parse_ip_and_mask(optarg,
+ &ctx->ip->dst,
+ &ctx->ip->dmsk))
+ break;
+
+ if (invert)
+ ctx->ip->invflags |= IPT_INV_DSTIP;
+ break;
+ case 'i':
+ /* In interface specification */
+ len = strlen(optarg);
+
+ if (len + 1 > IFNAMSIZ)
+ break;
+
+ g_stpcpy(ctx->ip->iniface, optarg);
+ memset(ctx->ip->iniface_mask, 0xff, len + 1);
+
+ if (invert)
+ ctx->ip->invflags |= IPT_INV_VIA_IN;
+
+ break;
+ case 'o':
+ /* Out interface specification */
+ len = strlen(optarg);
+
+ if (len + 1 > IFNAMSIZ)
+ break;
+
+ g_stpcpy(ctx->ip->outiface, optarg);
+ memset(ctx->ip->outiface_mask, 0xff, len + 1);
+
+ if (invert)
+ ctx->ip->invflags |= IPT_INV_VIA_OUT;
+
+ break;
+ case 'm':
+ /* Matches */
+ xt_m = prepare_matches(table, &ctx->xt_rm, optarg);
+ if (!xt_m) {
+ err = -EINVAL;
+ goto out;
+ }
+ ctx->xt_m = g_list_append(ctx->xt_m, xt_m);
+
+ break;
+ case 'j':
+ /* Target */
+ ctx->xt_t = prepare_target(table, optarg);
+ if (!ctx->xt_t) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ break;
+ case 1:
+ if (optarg[0] == '!' && optarg[1] == '\0') {
+ invert = true;
+
+ /* Remove the '!' from the optarg */
+ optarg[0] = '\0';
+
+ /*
+ * And recall getopt_long without reseting
+ * invert.
+ */
+ continue;
+ }
+
+ break;
+ default:
+ err = parse_xt_modules(c, invert, ctx);
+ if (err == 1)
+ continue;
+
+ break;
+ }
+
+ invert = false;
+ }
+
+ err = final_check_xt_modules(ctx);
+
+out:
+ return err;
+}
+
+static void reset_xtables(void)
+{
+ struct xtables_match *xt_m;
+ struct xtables_target *xt_t;
+
+ /*
+ * As side effect parsing a rule sets some global flags
+ * which will be evaluated/verified. Let's reset them
+ * to ensure we can parse more than one rule.
+ *
+ * Clear all flags because the flags are only valid
+ * for one rule.
+ */
+ for (xt_m = xtables_matches; xt_m; xt_m = xt_m->next)
+ xt_m->mflags = 0;
+
+ for (xt_t = xtables_targets; xt_t; xt_t = xt_t->next) {
+ xt_t->tflags = 0;
+ xt_t->used = 0;
+ }
+
+ /*
+ * We need also to free the memory implicitly allocated
+ * during parsing (see xtables_options_xfrm()).
+ * Note xt_params is actually iptables_globals.
+ */
+ if (xt_params->opts != xt_params->orig_opts) {
+ g_free(xt_params->opts);
+ xt_params->opts = xt_params->orig_opts;
+ }
+ xt_params->option_offset = 0;
+}
+
+static void cleanup_parse_context(struct parse_context *ctx)
+{
+ struct xtables_rule_match *rm, *tmp;
+ GList *list;
+
+ g_strfreev(ctx->argv);
+ g_free(ctx->ip);
+ if (ctx->xt_t) {
+ g_free(ctx->xt_t->t);
+ ctx->xt_t->t = NULL;
+ }
+
+ for (list = ctx->xt_m; list; list = list->next) {
+ struct xtables_match *xt_m = list->data;
+
+ g_free(xt_m->m);
+
+ if (xt_m != xt_m->next)
+ continue;
+
+ g_free(xt_m);
+ }
+ g_list_free(ctx->xt_m);
+
+ for (tmp = NULL, rm = ctx->xt_rm; rm; rm = rm->next) {
+ if (tmp)
+ g_free(tmp);
+ tmp = rm;
+ }
+ g_free(tmp);
+
+ g_free(ctx);
+}
+
+int __connman_iptables_dump(const char *table_name)
+{
+ struct connman_iptables *table;
+
+ DBG("-t %s -L", table_name);
+
+ table = get_table(table_name);
+ if (!table)
+ return -EINVAL;
+
+ dump_table(table);
+
+ return 0;
+}
+
+int __connman_iptables_new_chain(const char *table_name,
+ const char *chain)
+{
+ struct connman_iptables *table;
+
+ DBG("-t %s -N %s", table_name, chain);
+
+ table = get_table(table_name);
+ if (!table)
+ return -EINVAL;
+
+ return iptables_add_chain(table, chain);
+}
+
+int __connman_iptables_delete_chain(const char *table_name,
+ const char *chain)
+{
+ struct connman_iptables *table;
+
+ DBG("-t %s -X %s", table_name, chain);
+
+ table = get_table(table_name);
+ if (!table)
+ return -EINVAL;
+
+ return iptables_delete_chain(table, chain);
+}
+
+int __connman_iptables_flush_chain(const char *table_name,
+ const char *chain)
+{
+ struct connman_iptables *table;
+
+ DBG("-t %s -F %s", table_name, chain);
+
+ table = get_table(table_name);
+ if (!table)
+ return -EINVAL;
+
+ return iptables_flush_chain(table, chain);
+}
+
+int __connman_iptables_change_policy(const char *table_name,
+ const char *chain,
+ const char *policy)
+{
+ struct connman_iptables *table;
+
+ DBG("-t %s -F %s", table_name, chain);
+
+ table = get_table(table_name);
+ if (!table)
+ return -EINVAL;
+
+ return iptables_change_policy(table, chain, policy);
+}
+
+int __connman_iptables_append(const char *table_name,
+ const char *chain,
+ const char *rule_spec)
+{
+ struct connman_iptables *table;
+ struct parse_context *ctx;
+ const char *target_name;
+ int err;
+
+ ctx = g_try_new0(struct parse_context, 1);
+ if (!ctx)
+ return -ENOMEM;
+
+ DBG("-t %s -A %s %s", table_name, chain, rule_spec);
+
+ err = prepare_getopt_args(rule_spec, ctx);
+ if (err < 0)
+ goto out;
+
+ table = get_table(table_name);
+ if (!table) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ err = parse_rule_spec(table, ctx);
+ if (err < 0)
+ goto out;
+
+ if (!ctx->xt_t)
+ target_name = NULL;
+ else
+ target_name = ctx->xt_t->name;
+
+ err = iptables_append_rule(table, ctx->ip, chain,
+ target_name, ctx->xt_t, ctx->xt_rm);
+out:
+ cleanup_parse_context(ctx);
+ reset_xtables();
+
+ return err;
+}
+
+int __connman_iptables_insert(const char *table_name,
+ const char *chain,
+ const char *rule_spec)
+{
+ struct connman_iptables *table;
+ struct parse_context *ctx;
+ const char *target_name;
+ int err;
+
+ ctx = g_try_new0(struct parse_context, 1);
+ if (!ctx)
+ return -ENOMEM;
+
+ DBG("-t %s -I %s %s", table_name, chain, rule_spec);
+
+ err = prepare_getopt_args(rule_spec, ctx);
+ if (err < 0)
+ goto out;
+
+ table = get_table(table_name);
+ if (!table) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ err = parse_rule_spec(table, ctx);
+ if (err < 0)
+ goto out;
+
+ if (!ctx->xt_t)
+ target_name = NULL;
+ else
+ target_name = ctx->xt_t->name;
+
+ err = iptables_insert_rule(table, ctx->ip, chain,
+ target_name, ctx->xt_t, ctx->xt_rm);
+out:
+ cleanup_parse_context(ctx);
+ reset_xtables();
+
+ return err;
+}
+
+int __connman_iptables_delete(const char *table_name,
+ const char *chain,
+ const char *rule_spec)
+{
+ struct connman_iptables *table;
+ struct parse_context *ctx;
+ const char *target_name;
+ int err;
+
+ ctx = g_try_new0(struct parse_context, 1);
+ if (!ctx)
+ return -ENOMEM;
+
+ DBG("-t %s -D %s %s", table_name, chain, rule_spec);
+
+ err = prepare_getopt_args(rule_spec, ctx);
+ if (err < 0)
+ goto out;
+
+ table = get_table(table_name);
+ if (!table) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ err = parse_rule_spec(table, ctx);
+ if (err < 0)
+ goto out;
+
+ if (!ctx->xt_t)
+ target_name = NULL;
+ else
+ target_name = ctx->xt_t->name;
+
+ err = iptables_delete_rule(table, ctx->ip, chain,
+ target_name, ctx->xt_t, ctx->xt_m,
+ ctx->xt_rm);
+out:
+ cleanup_parse_context(ctx);
+ reset_xtables();
+
+ return err;
+}
+
+int __connman_iptables_commit(const char *table_name)
+{
+ struct connman_iptables *table;
+ struct ipt_replace *repl;
+ int err;
+ struct xt_counters_info *counters;
+ struct connman_iptables_entry *e;
+ GList *list;
+ unsigned int cnt;
+
+ DBG("%s", table_name);
+
+ table = g_hash_table_lookup(table_hash, table_name);
+ if (!table)
+ return -EINVAL;
+
+ repl = iptables_blob(table);
+ if (!repl)
+ return -ENOMEM;
+
+ if (debug_enabled)
+ dump_ipt_replace(repl);
+
+ err = iptables_replace(table, repl);
+
+ if (err < 0)
+ goto out_free;
+
+ counters = g_try_malloc0(sizeof(*counters) +
+ sizeof(struct xt_counters) * table->num_entries);
+ if (!counters) {
+ err = -ENOMEM;
+ goto out_hash_remove;
+ }
+ g_stpcpy(counters->name, table->info->name);
+ counters->num_counters = table->num_entries;
+ for (list = table->entries, cnt = 0; list; list = list->next, cnt++) {
+ e = list->data;
+ if (e->counter_idx >= 0)
+ counters->counters[cnt] = repl->counters[e->counter_idx];
+ }
+ err = iptables_add_counters(table, counters);
+ g_free(counters);
+
+ if (err < 0)
+ goto out_hash_remove;
+
+ err = 0;
+
+out_hash_remove:
+ g_hash_table_remove(table_hash, table_name);
+out_free:
+ g_free(repl->counters);
+ g_free(repl);
+ return err;
+}
+
+static void remove_table(gpointer user_data)
+{
+ struct connman_iptables *table = user_data;
+
+ table_cleanup(table);
+}
+
+static int iterate_chains_cb(struct ipt_entry *entry, int builtin,
+ unsigned int hook, size_t size,
+ unsigned int offset, void *user_data)
+{
+ struct cb_data *cbd = user_data;
+ connman_iptables_iterate_chains_cb_t cb = cbd->cb;
+ struct xt_entry_target *target;
+
+ if (offset + entry->next_offset == size)
+ return 0;
+
+ target = ipt_get_target(entry);
+
+ if (!g_strcmp0(target->u.user.name, IPT_ERROR_TARGET))
+ (*cb)((const char *)target->data, cbd->user_data);
+ else if (builtin >= 0)
+ (*cb)(hooknames[builtin], cbd->user_data);
+
+ return 0;
+}
+
+int __connman_iptables_iterate_chains(const char *table_name,
+ connman_iptables_iterate_chains_cb_t cb,
+ void *user_data)
+{
+ struct cb_data *cbd = cb_data_new(cb, user_data);
+ struct connman_iptables *table;
+
+ table = get_table(table_name);
+ if (!table)
+ return -EINVAL;
+
+ iterate_entries(table->blob_entries->entrytable,
+ table->info->valid_hooks,
+ table->info->hook_entry,
+ table->info->underflow,
+ table->blob_entries->size,
+ iterate_chains_cb, cbd);
+
+ g_free(cbd);
+
+ return 0;
+}
+
+int __connman_iptables_init(void)
+{
+ DBG("");
+
+ if (getenv("CONNMAN_IPTABLES_DEBUG"))
+ debug_enabled = true;
+
+ table_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_table);
+
+ xtables_init_all(&iptables_globals, NFPROTO_IPV4);
+
+ return 0;
+}
+
+void __connman_iptables_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(table_hash);
+}
diff --git a/src/ipv6pd.c b/src/ipv6pd.c
new file mode 100644
index 0000000..0d221f0
--- /dev/null
+++ b/src/ipv6pd.c
@@ -0,0 +1,385 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdio.h>
+
+#include "connman.h"
+
+#include <gdhcp/gdhcp.h>
+
+#define DEFAULT_ROUTER_LIFETIME 180 /* secs */
+#define DEFAULT_RA_INTERVAL 120 /* secs */
+
+static int bridge_index = -1;
+static guint timer_uplink;
+static guint timer_ra;
+static char *default_interface;
+static GSList *prefixes;
+static GHashTable *timer_hash;
+static void *rs_context;
+
+static int setup_prefix_delegation(struct connman_service *service);
+static void dhcpv6_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status, gpointer data);
+
+static int enable_ipv6_forward(bool enable)
+{
+ FILE *f;
+
+ f = fopen("/proc/sys/net/ipv6/ip_forward", "r+");
+ if (!f)
+ return -errno;
+
+ if (enable)
+ fprintf(f, "1");
+ else
+ fprintf(f, "0");
+
+ fclose(f);
+
+ return 0;
+}
+
+static gboolean send_ra(gpointer data)
+{
+ __connman_inet_ipv6_send_ra(bridge_index, NULL, prefixes,
+ DEFAULT_ROUTER_LIFETIME);
+
+ return TRUE;
+}
+
+static void start_ra(int ifindex, GSList *prefix)
+{
+ if (prefixes)
+ g_slist_free_full(prefixes, g_free);
+
+ prefixes = g_dhcpv6_copy_prefixes(prefix);
+
+ enable_ipv6_forward(true);
+
+ if (timer_ra > 0)
+ g_source_remove(timer_ra);
+
+ send_ra(NULL);
+
+ timer_ra = g_timeout_add_seconds(DEFAULT_RA_INTERVAL, send_ra, NULL);
+}
+
+static void stop_ra(int ifindex)
+{
+ __connman_inet_ipv6_send_ra(ifindex, NULL, prefixes, 0);
+
+ if (timer_ra > 0) {
+ g_source_remove(timer_ra);
+ timer_ra = 0;
+ }
+
+ enable_ipv6_forward(false);
+
+ if (prefixes) {
+ g_slist_free_full(prefixes, g_free);
+ prefixes = NULL;
+ }
+}
+
+static void rs_received(struct nd_router_solicit *reply,
+ unsigned int length, void *user_data)
+{
+ GDHCPIAPrefix *prefix;
+ GSList *list;
+
+ if (!prefixes)
+ return;
+
+ DBG("");
+
+ for (list = prefixes; list; list = list->next) {
+ prefix = list->data;
+
+ prefix->valid -= time(NULL) - prefix->expire;
+ prefix->preferred -= time(NULL) - prefix->expire;
+ }
+
+ __connman_inet_ipv6_send_ra(bridge_index, NULL, prefixes,
+ DEFAULT_ROUTER_LIFETIME);
+}
+
+static gboolean do_setup(gpointer data)
+{
+ int ret;
+
+ timer_uplink = 0;
+
+ if (!default_interface)
+ DBG("No uplink connection, retrying prefix delegation");
+
+ ret = setup_prefix_delegation(__connman_service_get_default());
+ if (ret < 0 && ret != -EINPROGRESS)
+ return TRUE; /* delegation error, try again */
+
+ return FALSE;
+}
+
+static void dhcpv6_renew_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status,
+ gpointer data)
+{
+ DBG("network %p status %d data %p", network, status, data);
+
+ if (status == CONNMAN_DHCPV6_STATUS_SUCCEED)
+ dhcpv6_callback(network, status, data);
+ else
+ setup_prefix_delegation(__connman_service_get_default());
+}
+
+static void cleanup(void)
+{
+ if (timer_uplink != 0) {
+ g_source_remove(timer_uplink);
+ timer_uplink = 0;
+ }
+
+ if (timer_hash) {
+ g_hash_table_destroy(timer_hash);
+ timer_hash = NULL;
+ }
+
+ if (prefixes) {
+ g_slist_free_full(prefixes, g_free);
+ prefixes = NULL;
+ }
+}
+
+static void dhcpv6_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status, gpointer data)
+{
+ GSList *prefix_list = data;
+
+ DBG("network %p status %d data %p", network, status, data);
+
+ if (status == CONNMAN_DHCPV6_STATUS_FAIL) {
+ DBG("Prefix delegation request failed");
+ cleanup();
+ return;
+ }
+
+ if (!prefix_list) {
+ DBG("No prefixes, retrying");
+ if (timer_uplink == 0)
+ timer_uplink = g_timeout_add_seconds(10, do_setup,
+ NULL);
+ return;
+ }
+
+ /*
+ * After we have got a list of prefixes, we can start to send router
+ * advertisements (RA) to tethering interface.
+ */
+ start_ra(bridge_index, prefix_list);
+
+ if (__connman_dhcpv6_start_pd_renew(network,
+ dhcpv6_renew_callback) == -ETIMEDOUT)
+ dhcpv6_renew_callback(network, CONNMAN_DHCPV6_STATUS_FAIL,
+ NULL);
+}
+
+static int setup_prefix_delegation(struct connman_service *service)
+{
+ struct connman_ipconfig *ipconfig;
+ char *interface;
+ int err = 0, ifindex;
+
+ if (!service) {
+ /*
+ * We do not have uplink connection. We just wait until
+ * default interface is updated.
+ */
+ return -EINPROGRESS;
+ }
+
+ interface = connman_service_get_interface(service);
+
+ DBG("interface %s bridge_index %d", interface, bridge_index);
+
+ if (default_interface) {
+ stop_ra(bridge_index);
+
+ ifindex = connman_inet_ifindex(default_interface);
+ __connman_dhcpv6_stop_pd(ifindex);
+ }
+
+ g_free(default_interface);
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (!__connman_ipconfig_ipv6_is_enabled(ipconfig)) {
+ g_free(interface);
+ default_interface = NULL;
+ return -EPFNOSUPPORT;
+ }
+
+ default_interface = interface;
+
+ if (default_interface) {
+ ifindex = connman_inet_ifindex(default_interface);
+
+ /*
+ * Try to get a IPv6 prefix so we can start to advertise it.
+ */
+ err = __connman_dhcpv6_start_pd(ifindex, prefixes,
+ dhcpv6_callback);
+ if (err < 0)
+ DBG("prefix delegation %d/%s", err, strerror(-err));
+ }
+
+ return err;
+}
+
+static void cleanup_timer(gpointer user_data)
+{
+ guint timer = GPOINTER_TO_UINT(user_data);
+
+ g_source_remove(timer);
+}
+
+static void update_default_interface(struct connman_service *service)
+{
+ setup_prefix_delegation(service);
+}
+
+static void update_ipconfig(struct connman_service *service,
+ struct connman_ipconfig *ipconfig)
+{
+ if (!service || service != __connman_service_get_default())
+ return;
+
+ if (ipconfig != __connman_service_get_ip6config(service))
+ return;
+
+ if (!__connman_ipconfig_ipv6_is_enabled(ipconfig)) {
+ if (default_interface) {
+ int ifindex;
+
+ ifindex = connman_inet_ifindex(default_interface);
+ __connman_dhcpv6_stop_pd(ifindex);
+
+ g_free(default_interface);
+ default_interface = NULL;
+ }
+
+ DBG("No IPv6 support for interface index %d",
+ __connman_ipconfig_get_index(ipconfig));
+ return;
+ }
+
+ /*
+ * Did we had PD activated already? If not, then start it.
+ */
+ if (!default_interface) {
+ DBG("IPv6 ipconfig %p changed for interface index %d", ipconfig,
+ __connman_ipconfig_get_index(ipconfig));
+
+ setup_prefix_delegation(service);
+ }
+}
+
+static struct connman_notifier pd_notifier = {
+ .name = "IPv6 prefix delegation",
+ .default_changed = update_default_interface,
+ .ipconfig_changed = update_ipconfig,
+};
+
+int __connman_ipv6pd_setup(const char *bridge)
+{
+ struct connman_service *service;
+ int err;
+
+ if (!connman_inet_is_ipv6_supported())
+ return -EPFNOSUPPORT;
+
+ if (bridge_index >= 0) {
+ DBG("Prefix delegation already running");
+ return -EALREADY;
+ }
+
+ err = connman_notifier_register(&pd_notifier);
+ if (err < 0)
+ return err;
+
+ bridge_index = connman_inet_ifindex(bridge);
+
+ timer_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, cleanup_timer);
+
+ err = __connman_inet_ipv6_start_recv_rs(bridge_index, rs_received,
+ NULL, &rs_context);
+ if (err < 0)
+ DBG("Cannot receive router solicitation %d/%s",
+ err, strerror(-err));
+
+ service = __connman_service_get_default();
+ if (service) {
+ /*
+ * We have an uplink connection already, try to use it.
+ */
+ return setup_prefix_delegation(service);
+ }
+
+ /*
+ * The prefix delegation is started after have got the uplink
+ * connection up i.e., when the default service is setup in which
+ * case the update_default_interface() will be called.
+ */
+ return -EINPROGRESS;
+}
+
+void __connman_ipv6pd_cleanup(void)
+{
+ int ifindex;
+
+ if (!connman_inet_is_ipv6_supported())
+ return;
+
+ connman_notifier_unregister(&pd_notifier);
+
+ __connman_inet_ipv6_stop_recv_rs(rs_context);
+ rs_context = NULL;
+
+ cleanup();
+
+ stop_ra(bridge_index);
+
+ if (default_interface) {
+ ifindex = connman_inet_ifindex(default_interface);
+ __connman_dhcpv6_stop_pd(ifindex);
+ g_free(default_interface);
+ default_interface = NULL;
+ }
+
+ bridge_index = -1;
+}
diff --git a/src/log.c b/src/log.c
new file mode 100644
index 0000000..6927c8f
--- /dev/null
+++ b/src/log.c
@@ -0,0 +1,409 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <syslog.h>
+#include <execinfo.h>
+#include <dlfcn.h>
+#include <fcntl.h>
+
+#include "connman.h"
+
+static const char *program_exec;
+static const char *program_path;
+
+#define MAX_FRAME_DEPTH 99
+#define CRASH_DUMP_FILE "/tmp/connmand.log"
+
+#if CONNMAN_DEBUG
+unsigned int trace_depth = 0;
+static const char * trace_tabs = "\t\t\t\t" "\t\t\t\t" "\t\t\t\t" "\t\t\t\t" "\t\t\t\t";
+char trace_tabbuf[24] = { 0 };
+
+void connman_create_indent(unsigned int depth, char *buffer)
+{
+ if (buffer == NULL)
+ return;
+
+ if (depth > 22) {
+ depth = 22;
+ }
+
+ if (depth == 0) {
+ buffer[0] = 0;
+ } else {
+ strncpy(buffer, trace_tabs, depth);
+ buffer[depth] = 0;
+ }
+}
+#endif
+
+void connman_assert_handler(const char *name, const char *predicate, const char *message, const char *file, unsigned int line, void *value, int terminate)
+{
+ connman_debug("assertion: %s%s%s, %s file: %s, line: %d: value: %p\n",
+ name != NULL ? name : "",
+ name != NULL ? ": " : "",
+ predicate,
+ message != NULL ? message : "",
+ file,
+ line,
+ value);
+
+ if (terminate) {
+ abort();
+ }
+}
+
+/**
+ * connman_info:
+ * @format: format string
+ * @Varargs: list of arguments
+ *
+ * Output general information
+ */
+void connman_info(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+
+ vsyslog(LOG_INFO, format, ap);
+
+ va_end(ap);
+}
+
+/**
+ * connman_warn:
+ * @format: format string
+ * @Varargs: list of arguments
+ *
+ * Output warning messages
+ */
+void connman_warn(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+
+ vsyslog(LOG_WARNING, format, ap);
+
+ va_end(ap);
+}
+
+/**
+ * connman_error:
+ * @format: format string
+ * @varargs: list of arguments
+ *
+ * Output error messages
+ */
+void connman_error(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+
+ vsyslog(LOG_ERR, format, ap);
+
+ va_end(ap);
+}
+
+/**
+ * connman_debug:
+ * @format: format string
+ * @varargs: list of arguments
+ *
+ * Output debug message
+ */
+void connman_debug(const char *format, ...)
+{
+ va_list ap;
+
+ va_start(ap, format);
+
+ vsyslog(LOG_DEBUG, format, ap);
+
+ va_end(ap);
+}
+
+static void print_backtrace(unsigned int offset)
+{
+ void *frames[MAX_FRAME_DEPTH];
+ size_t n_ptrs;
+ unsigned int i;
+ int outfd[2], infd[2];
+ int pathlen;
+ pid_t pid;
+
+ if (!program_exec)
+ return;
+
+ pathlen = strlen(program_path);
+
+#ifndef USE_ADDR2LINE
+
+ int fd = open(CRASH_DUMP_FILE, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
+
+ if(fd != -1)
+ {
+ n_ptrs = backtrace(frames, G_N_ELEMENTS(frames));
+ backtrace_symbols_fd(frames, n_ptrs, fd);
+ }
+
+ _exit(EXIT_FAILURE);
+
+#else
+ if (n_ptrs < offset)
+ return;
+
+ if (pipe(outfd) < 0)
+ return;
+
+ if (pipe(infd) < 0) {
+ close(outfd[0]);
+ close(outfd[1]);
+ return;
+ }
+
+ pid = fork();
+ if (pid < 0) {
+ close(outfd[0]);
+ close(outfd[1]);
+ close(infd[0]);
+ close(infd[1]);
+ return;
+ }
+
+ if (pid == 0) {
+ close(outfd[1]);
+ close(infd[0]);
+
+ dup2(outfd[0], STDIN_FILENO);
+ dup2(infd[1], STDOUT_FILENO);
+
+ execlp("addr2line", "-C", "-f", "-e", program_exec, NULL);
+
+ exit(EXIT_FAILURE);
+ }
+
+ close(outfd[0]);
+ close(infd[1]);
+
+ connman_error("++++++++ backtrace ++++++++");
+
+ for (i = offset; i < n_ptrs - 1; i++) {
+ Dl_info info;
+ char addr[20], buf[PATH_MAX * 2];
+ int len, written;
+ char *ptr, *pos;
+
+ dladdr(frames[i], &info);
+
+ len = snprintf(addr, sizeof(addr), "%p\n", frames[i]);
+ if (len < 0)
+ break;
+
+ if (outfd[1] >= 0)
+ {
+ written = write(outfd[1], addr, len);
+ if (written < 0)
+ break;
+
+ len = read(infd[0], buf, sizeof(buf) - 1);
+ if (len < 0)
+ break;
+ else if (len == 0)
+ {
+ // if we got nothing, that means we got EOF, which means the read end was closed
+ // so close the FD and set it to invalid so we know to not to bother with further
+ // symbolication
+ close(outfd[1]);
+ outfd[1] = -1;
+ }
+ }
+ else
+ {
+ len = 0;
+ }
+
+ buf[len] = '\0';
+
+ pos = strchr(buf, '\n');
+ if (pos != NULL)
+ {
+ *pos++ = '\0';
+ }
+
+ if ((len == 0) || (strcmp(buf, "??") == 0)) {
+ connman_error("#%-2u %p in %s", i - offset,
+ frames[i], info.dli_fname);
+ continue;
+ }
+
+ ptr = strchr(pos, '\n');
+ *ptr++ = '\0';
+
+ if (strncmp(pos, program_path, pathlen) == 0)
+ pos += pathlen + 1;
+
+ connman_error("#%-2u %p in %s() at %s", i - offset,
+ frames[i], buf, pos);
+ }
+
+ connman_error("+++++++++++++++++++++++++++");
+
+ kill(pid, SIGTERM);
+
+ if (outfd[1] >= 0)
+ {
+ close(outfd[1]);
+ }
+ close(infd[0]);
+#endif
+}
+
+static void signal_handler(int signo)
+{
+ connman_error("Aborting (signal %d) [%s]", signo, program_exec);
+
+ print_backtrace(2);
+
+ exit(EXIT_FAILURE);
+}
+
+static void signal_setup(sighandler_t handler)
+{
+ struct sigaction sa;
+ sigset_t mask;
+
+ sigemptyset(&mask);
+ sa.sa_handler = handler;
+ sa.sa_mask = mask;
+ sa.sa_flags = 0;
+ sigaction(SIGBUS, &sa, NULL);
+ sigaction(SIGILL, &sa, NULL);
+ sigaction(SIGFPE, &sa, NULL);
+ sigaction(SIGSEGV, &sa, NULL);
+ sigaction(SIGABRT, &sa, NULL);
+ sigaction(SIGPIPE, &sa, NULL);
+}
+
+extern struct connman_debug_desc __start___debug[];
+extern struct connman_debug_desc __stop___debug[];
+
+static gchar **enabled = NULL;
+
+static bool is_enabled(struct connman_debug_desc *desc)
+{
+ int i;
+
+ if (!enabled)
+ return false;
+
+ for (i = 0; enabled[i]; i++) {
+ if (desc->name && g_pattern_match_simple(enabled[i],
+ desc->name))
+ return true;
+ if (desc->file && g_pattern_match_simple(enabled[i],
+ desc->file))
+ return true;
+ }
+
+ return false;
+}
+
+void __connman_log_enable(struct connman_debug_desc *start,
+ struct connman_debug_desc *stop)
+{
+ struct connman_debug_desc *desc;
+ const char *name = NULL, *file = NULL;
+
+ if (!start || !stop)
+ return;
+
+ for (desc = start; desc < stop; desc++) {
+ if (desc->flags & CONNMAN_DEBUG_FLAG_ALIAS) {
+ file = desc->file;
+ name = desc->name;
+ continue;
+ }
+
+ if (file || name) {
+ if (g_strcmp0(desc->file, file) == 0) {
+ if (!desc->name)
+ desc->name = name;
+ } else
+ file = NULL;
+ }
+
+ if (is_enabled(desc))
+ desc->flags |= CONNMAN_DEBUG_FLAG_PRINT;
+ }
+}
+
+int __connman_log_init(const char *program, const char *debug,
+ gboolean detach, gboolean backtrace,
+ const char *program_name, const char *program_version)
+{
+ static char path[PATH_MAX];
+ int option = LOG_NDELAY | LOG_PID;
+
+ program_exec = program;
+ program_path = getcwd(path, sizeof(path));
+
+ if (debug)
+ enabled = g_strsplit_set(debug, ":, ", 0);
+
+ __connman_log_enable(__start___debug, __stop___debug);
+
+ if (!detach)
+ option |= LOG_PERROR;
+
+ if (backtrace)
+ signal_setup(signal_handler);
+
+ openlog(basename(program), option, LOG_DAEMON);
+
+ syslog(LOG_INFO, "%s version %s", program_name, program_version);
+
+ return 0;
+}
+
+void __connman_log_cleanup(gboolean backtrace)
+{
+ syslog(LOG_INFO, "Exit");
+
+ closelog();
+
+ if (backtrace)
+ signal_setup(SIG_DFL);
+
+ g_strfreev(enabled);
+}
diff --git a/src/machine.c b/src/machine.c
new file mode 100644
index 0000000..14ea366
--- /dev/null
+++ b/src/machine.c
@@ -0,0 +1,125 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <gdbus.h>
+
+#include "connman.h"
+
+#define DEFAULT_MACHINE_TYPE "laptop"
+
+#define HOSTNAMED_SERVICE "org.freedesktop.hostname1"
+#define HOSTNAMED_INTERFACE HOSTNAMED_SERVICE
+#define HOSTNAMED_PATH "/org/freedesktop/hostname1"
+
+static GDBusClient *hostnamed_client = NULL;
+static GDBusProxy *hostnamed_proxy = NULL;
+static char *machine_type = NULL;
+
+const char *connman_machine_get_type(void)
+{
+ if (machine_type)
+ return machine_type;
+
+ return DEFAULT_MACHINE_TYPE;
+}
+
+static void machine_property_changed(GDBusProxy *proxy, const char *name,
+ DBusMessageIter *iter, void *user_data)
+{
+ DBG("Property %s", name);
+
+ if (g_str_equal(name, "Chassis")) {
+ const char *str;
+
+ if (!iter) {
+ g_dbus_proxy_refresh_property(proxy, name);
+ return;
+ }
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_STRING)
+ return;
+
+ dbus_message_iter_get_basic(iter, &str);
+ g_free(machine_type);
+ machine_type = g_strdup(str);
+
+ DBG("Machine type set to %s", machine_type);
+ }
+}
+
+int __connman_machine_init(void)
+{
+ DBusConnection *connection;
+ int err = -EIO;
+
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+
+ hostnamed_client = g_dbus_client_new(connection, HOSTNAMED_SERVICE,
+ HOSTNAMED_PATH);
+ if (!hostnamed_client)
+ goto error;
+
+ hostnamed_proxy = g_dbus_proxy_new(hostnamed_client, HOSTNAMED_PATH,
+ HOSTNAMED_INTERFACE);
+ if (!hostnamed_proxy)
+ goto error;
+
+ g_dbus_proxy_set_property_watch(hostnamed_proxy,
+ machine_property_changed, NULL);
+
+ dbus_connection_unref(connection);
+
+ return 0;
+error:
+ if (hostnamed_client) {
+ g_dbus_client_unref(hostnamed_client);
+ hostnamed_client = NULL;
+ }
+
+ dbus_connection_unref(connection);
+
+ return err;
+}
+
+void __connman_machine_cleanup(void)
+{
+ DBG("");
+
+ if (hostnamed_proxy) {
+ g_dbus_proxy_unref(hostnamed_proxy);
+ hostnamed_proxy = NULL;
+ }
+
+ if (hostnamed_client) {
+ g_dbus_client_unref(hostnamed_client);
+ hostnamed_client = NULL;
+ }
+
+ g_free(machine_type);
+ machine_type = NULL;
+}
diff --git a/src/main.c b/src/main.c
new file mode 100644
index 0000000..58ef1ef
--- /dev/null
+++ b/src/main.c
@@ -0,0 +1,844 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/signalfd.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <net/if.h>
+#include <netdb.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+#define DEFAULT_INPUT_REQUEST_TIMEOUT (120 * 1000)
+#define DEFAULT_BROWSER_LAUNCH_TIMEOUT (300 * 1000)
+
+#define MAINFILE "main.conf"
+#define CONFIGMAINFILE CONFIGDIR "/" MAINFILE
+
+static char *default_auto_connect[] = {
+ "wifi",
+ "ethernet",
+ NULL
+};
+
+static char *default_blacklist[] = {
+ "vmnet",
+ "vboxnet",
+ "virbr",
+ "ifb",
+ NULL
+};
+
+static struct {
+ bool bg_scan;
+ char **pref_timeservers;
+ unsigned int *auto_connect;
+ unsigned int *preferred_techs;
+ char **fallback_nameservers;
+ unsigned int timeout_inputreq;
+ unsigned int timeout_browserlaunch;
+ char **blacklisted_interfaces;
+ bool allow_hostname_updates;
+ bool single_tech;
+ char **tethering_technologies;
+ bool persistent_tethering_mode;
+ bool enable_6to4;
+ bool always_use_fallback_nameservers;
+ char **time_updates;
+} connman_settings = {
+ .bg_scan = true,
+ .pref_timeservers = NULL,
+ .auto_connect = NULL,
+ .preferred_techs = NULL,
+ .fallback_nameservers = NULL,
+ .timeout_inputreq = DEFAULT_INPUT_REQUEST_TIMEOUT,
+ .timeout_browserlaunch = DEFAULT_BROWSER_LAUNCH_TIMEOUT,
+ .blacklisted_interfaces = NULL,
+ .allow_hostname_updates = true,
+ .single_tech = false,
+ .tethering_technologies = NULL,
+ .persistent_tethering_mode = false,
+ .enable_6to4 = false,
+ .always_use_fallback_nameservers = false,
+ .time_updates = NULL,
+};
+
+#define CONF_BG_SCAN "BackgroundScanning"
+#define CONF_PREF_TIMESERVERS "FallbackTimeservers"
+#define CONF_AUTO_CONNECT "DefaultAutoConnectTechnologies"
+#define CONF_PREFERRED_TECHS "PreferredTechnologies"
+#define CONF_FALLBACK_NAMESERVERS "FallbackNameservers"
+#define CONF_TIMEOUT_INPUTREQ "InputRequestTimeout"
+#define CONF_TIMEOUT_BROWSERLAUNCH "BrowserLaunchTimeout"
+#define CONF_BLACKLISTED_INTERFACES "NetworkInterfaceBlacklist"
+#define CONF_ALLOW_HOSTNAME_UPDATES "AllowHostnameUpdates"
+#define CONF_SINGLE_TECH "SingleConnectedTechnology"
+#define CONF_TETHERING_TECHNOLOGIES "TetheringTechnologies"
+#define CONF_PERSISTENT_TETHERING_MODE "PersistentTetheringMode"
+#define CONF_ENABLE_6TO4 "Enable6to4"
+#define CONF_ALWAYS_USE_FALLBACK_NAMESERVERS "AlwaysUseFallbackNameservers"
+#define CONF_TIME_UPDATES "TimeUpdates"
+
+static const char *supported_options[] = {
+ CONF_BG_SCAN,
+ CONF_PREF_TIMESERVERS,
+ CONF_AUTO_CONNECT,
+ CONF_PREFERRED_TECHS,
+ CONF_FALLBACK_NAMESERVERS,
+ CONF_TIMEOUT_INPUTREQ,
+ CONF_TIMEOUT_BROWSERLAUNCH,
+ CONF_BLACKLISTED_INTERFACES,
+ CONF_ALLOW_HOSTNAME_UPDATES,
+ CONF_SINGLE_TECH,
+ CONF_TETHERING_TECHNOLOGIES,
+ CONF_PERSISTENT_TETHERING_MODE,
+ CONF_ENABLE_6TO4,
+ CONF_ALWAYS_USE_FALLBACK_NAMESERVERS,
+ CONF_TIME_UPDATES,
+ NULL
+};
+
+static GKeyFile *load_config(const char *file)
+{
+ GError *err = NULL;
+ GKeyFile *keyfile;
+
+ keyfile = g_key_file_new();
+
+ g_key_file_set_list_separator(keyfile, ',');
+
+ if (!g_key_file_load_from_file(keyfile, file, 0, &err)) {
+ if (err->code != G_FILE_ERROR_NOENT) {
+ connman_error("Parsing %s failed: %s", file,
+ err->message);
+ }
+
+ g_error_free(err);
+ g_key_file_free(keyfile);
+ return NULL;
+ }
+
+ return keyfile;
+}
+
+static uint *parse_service_types(char **str_list, gsize len)
+{
+ unsigned int *type_list;
+ int i, j;
+ enum connman_service_type type;
+
+ type_list = g_try_new0(unsigned int, len + 1);
+ if (!type_list)
+ return NULL;
+
+ i = 0;
+ j = 0;
+ while (str_list[i]) {
+ type = __connman_service_string2type(str_list[i]);
+
+ if (type != CONNMAN_SERVICE_TYPE_UNKNOWN) {
+ type_list[j] = type;
+ j += 1;
+ }
+ i += 1;
+ }
+
+ type_list[j] = CONNMAN_SERVICE_TYPE_UNKNOWN;
+
+ return type_list;
+}
+
+static char **parse_fallback_nameservers(char **nameservers, gsize len)
+{
+ char **servers;
+ int i, j;
+
+ servers = g_try_new0(char *, len + 1);
+ if (!servers)
+ return NULL;
+
+ i = 0;
+ j = 0;
+ while (nameservers[i]) {
+ if (connman_inet_check_ipaddress(nameservers[i]) > 0) {
+ servers[j] = g_strdup(nameservers[i]);
+ j += 1;
+ }
+ i += 1;
+ }
+
+ return servers;
+}
+
+static void check_config(GKeyFile *config)
+{
+ char **keys;
+ int j;
+
+ if (!config)
+ return;
+
+ keys = g_key_file_get_groups(config, NULL);
+
+ for (j = 0; keys && keys[j]; j++) {
+ if (g_strcmp0(keys[j], "General") != 0)
+ connman_warn("Unknown group %s in %s",
+ keys[j], MAINFILE);
+ }
+
+ g_strfreev(keys);
+
+ keys = g_key_file_get_keys(config, "General", NULL, NULL);
+
+ for (j = 0; keys && keys[j]; j++) {
+ bool found;
+ int i;
+
+ found = false;
+ for (i = 0; supported_options[i]; i++) {
+ if (g_strcmp0(keys[j], supported_options[i]) == 0) {
+ found = true;
+ break;
+ }
+ }
+ if (!found && !supported_options[i])
+ connman_warn("Unknown option %s in %s",
+ keys[j], MAINFILE);
+ }
+
+ g_strfreev(keys);
+}
+
+static void parse_config(GKeyFile *config)
+{
+ GError *error = NULL;
+ bool boolean;
+ char **timeservers;
+ char **interfaces;
+ char **str_list;
+ char **tethering;
+ gsize len;
+ int timeout;
+ char **time_updates;
+
+ if (!config) {
+ connman_settings.auto_connect =
+ parse_service_types(default_auto_connect, 3);
+ connman_settings.blacklisted_interfaces =
+ g_strdupv(default_blacklist);
+ return;
+ }
+
+ DBG("parsing %s", MAINFILE);
+
+ boolean = g_key_file_get_boolean(config, "General",
+ CONF_BG_SCAN, &error);
+ if (!error)
+ connman_settings.bg_scan = boolean;
+
+ g_clear_error(&error);
+
+ timeservers = __connman_config_get_string_list(config, "General",
+ CONF_PREF_TIMESERVERS, NULL, &error);
+ if (!error)
+ connman_settings.pref_timeservers = timeservers;
+
+ g_clear_error(&error);
+
+ str_list = __connman_config_get_string_list(config, "General",
+ CONF_AUTO_CONNECT, &len, &error);
+
+ if (!error)
+ connman_settings.auto_connect =
+ parse_service_types(str_list, len);
+ else
+ connman_settings.auto_connect =
+ parse_service_types(default_auto_connect, 3);
+
+ g_strfreev(str_list);
+
+ g_clear_error(&error);
+
+ str_list = __connman_config_get_string_list(config, "General",
+ CONF_PREFERRED_TECHS, &len, &error);
+
+ if (!error)
+ connman_settings.preferred_techs =
+ parse_service_types(str_list, len);
+
+ g_strfreev(str_list);
+
+ g_clear_error(&error);
+
+ str_list = __connman_config_get_string_list(config, "General",
+ CONF_FALLBACK_NAMESERVERS, &len, &error);
+
+ if (!error)
+ connman_settings.fallback_nameservers =
+ parse_fallback_nameservers(str_list, len);
+
+ g_strfreev(str_list);
+
+ g_clear_error(&error);
+
+ timeout = g_key_file_get_integer(config, "General",
+ CONF_TIMEOUT_INPUTREQ, &error);
+ if (!error && timeout >= 0)
+ connman_settings.timeout_inputreq = timeout * 1000;
+
+ g_clear_error(&error);
+
+ timeout = g_key_file_get_integer(config, "General",
+ CONF_TIMEOUT_BROWSERLAUNCH, &error);
+ if (!error && timeout >= 0)
+ connman_settings.timeout_browserlaunch = timeout * 1000;
+
+ g_clear_error(&error);
+
+ interfaces = __connman_config_get_string_list(config, "General",
+ CONF_BLACKLISTED_INTERFACES, &len, &error);
+
+ if (!error)
+ connman_settings.blacklisted_interfaces = interfaces;
+ else
+ connman_settings.blacklisted_interfaces =
+ g_strdupv(default_blacklist);
+
+ g_clear_error(&error);
+
+ boolean = __connman_config_get_bool(config, "General",
+ CONF_ALLOW_HOSTNAME_UPDATES,
+ &error);
+ if (!error)
+ connman_settings.allow_hostname_updates = boolean;
+
+ g_clear_error(&error);
+
+ boolean = __connman_config_get_bool(config, "General",
+ CONF_SINGLE_TECH, &error);
+ if (!error)
+ connman_settings.single_tech = boolean;
+
+ g_clear_error(&error);
+
+ tethering = __connman_config_get_string_list(config, "General",
+ CONF_TETHERING_TECHNOLOGIES, &len, &error);
+
+ if (!error)
+ connman_settings.tethering_technologies = tethering;
+
+ g_clear_error(&error);
+
+ boolean = __connman_config_get_bool(config, "General",
+ CONF_PERSISTENT_TETHERING_MODE,
+ &error);
+ if (!error)
+ connman_settings.persistent_tethering_mode = boolean;
+
+ g_clear_error(&error);
+
+ boolean = __connman_config_get_bool(config, "General",
+ CONF_ENABLE_6TO4, &error);
+ if (!error)
+ connman_settings.enable_6to4 = boolean;
+
+ g_clear_error(&error);
+
+ boolean = __connman_config_get_bool(config, "General",
+ CONF_ALWAYS_USE_FALLBACK_NAMESERVERS, &error);
+ if (!error)
+ connman_settings.always_use_fallback_nameservers = boolean;
+
+ g_clear_error(&error);
+
+ time_updates = __connman_config_get_string_list(config, "General",
+ CONF_TIME_UPDATES, &len, &error);
+
+ if (!error) {
+ connman_settings.time_updates = time_updates;
+ } else {
+ }
+
+ g_clear_error(&error);
+
+}
+
+static int config_init(const char *file, bool rlimits)
+{
+ GKeyFile *config;
+ int err = 0;
+
+ config = load_config(file);
+ check_config(config);
+
+ if (rlimits) {
+ err = __connman_rlimits_init(file);
+ if (err < 0)
+ goto done;
+ }
+
+ parse_config(config);
+
+done:
+ if (config)
+ g_key_file_free(config);
+
+ return err;
+}
+
+static GMainLoop *main_loop = NULL;
+
+static unsigned int __terminated = 0;
+
+static gboolean signal_handler(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct signalfd_siginfo si;
+ ssize_t result;
+ int fd;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP))
+ return FALSE;
+
+ fd = g_io_channel_unix_get_fd(channel);
+
+ result = read(fd, &si, sizeof(si));
+ if (result != sizeof(si))
+ return FALSE;
+
+ switch (si.ssi_signo) {
+ case SIGINT:
+ case SIGTERM:
+ if (__terminated == 0) {
+ connman_info("Terminating");
+ g_main_loop_quit(main_loop);
+ }
+
+ __terminated = 1;
+ break;
+ }
+
+ return TRUE;
+}
+
+static guint setup_signalfd(void)
+{
+ GIOChannel *channel;
+ guint source;
+ sigset_t mask;
+ int fd;
+
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGINT);
+ sigaddset(&mask, SIGTERM);
+
+ if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0) {
+ perror("Failed to set signal mask");
+ return 0;
+ }
+
+ fd = signalfd(-1, &mask, 0);
+ if (fd < 0) {
+ perror("Failed to create signal descriptor");
+ return 0;
+ }
+
+ channel = g_io_channel_unix_new(fd);
+
+ g_io_channel_set_close_on_unref(channel, TRUE);
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ source = g_io_add_watch(channel,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ signal_handler, NULL);
+
+ g_io_channel_unref(channel);
+
+ return source;
+}
+
+static void disconnect_callback(DBusConnection *conn, void *user_data)
+{
+ connman_error("D-Bus disconnect");
+
+ g_main_loop_quit(main_loop);
+}
+
+static gchar *option_config = NULL;
+static gchar *option_debug = NULL;
+static gchar *option_device = NULL;
+static gchar *option_pidfile = NULL;
+static gchar *option_plugin = NULL;
+static gchar *option_nodevice = NULL;
+static gchar *option_noplugin = NULL;
+static gchar *option_wifi = NULL;
+static gboolean option_detach = TRUE;
+static gboolean option_dnsproxy = TRUE;
+static gboolean option_backtrace = TRUE;
+static gboolean option_version = FALSE;
+static gboolean option_rlimits = TRUE;
+
+static bool parse_debug(const char *key, const char *value,
+ gpointer user_data, GError **error)
+{
+ if (value)
+ option_debug = g_strdup(value);
+ else
+ option_debug = g_strdup("*");
+
+ return true;
+}
+
+static GOptionEntry options[] = {
+ { "config", 'c', 0, G_OPTION_ARG_STRING, &option_config,
+ "Load the specified configuration file "
+ "instead of " CONFIGMAINFILE, "FILE" },
+ { "debug", 'd', G_OPTION_FLAG_OPTIONAL_ARG,
+ G_OPTION_ARG_CALLBACK, parse_debug,
+ "Specify debug options to enable", "DEBUG" },
+ { "device", 'i', 0, G_OPTION_ARG_STRING, &option_device,
+ "Specify networking device or interface", "DEV" },
+ { "nodevice", 'I', 0, G_OPTION_ARG_STRING, &option_nodevice,
+ "Specify networking interface to ignore", "DEV" },
+ { "plugin", 'p', 0, G_OPTION_ARG_STRING, &option_plugin,
+ "Specify plugins to load", "NAME,..." },
+ { "noplugin", 'P', 0, G_OPTION_ARG_STRING, &option_noplugin,
+ "Specify plugins not to load", "NAME,..." },
+ { "wifi", 'W', 0, G_OPTION_ARG_STRING, &option_wifi,
+ "Specify driver for WiFi/Supplicant", "NAME" },
+ { "nodaemon", 'n', G_OPTION_FLAG_REVERSE,
+ G_OPTION_ARG_NONE, &option_detach,
+ "Don't fork daemon to background" },
+ { "nodnsproxy", 'r', G_OPTION_FLAG_REVERSE,
+ G_OPTION_ARG_NONE, &option_dnsproxy,
+ "Don't enable DNS Proxy" },
+ { "nobacktrace", 0, G_OPTION_FLAG_REVERSE,
+ G_OPTION_ARG_NONE, &option_backtrace,
+ "Don't print out backtrace information" },
+ { "norlimits", 0, G_OPTION_FLAG_REVERSE,
+ G_OPTION_ARG_NONE, &option_rlimits,
+ "Don't enforce resource limits" },
+ { "pidfile", 0, 0, G_OPTION_ARG_STRING, &option_pidfile,
+ "Path to PID file", "PIDFILE" },
+ { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
+ "Show version information and exit" },
+ { NULL },
+};
+
+const char *connman_option_get_string(const char *key)
+{
+ if (g_strcmp0(key, "wifi") == 0) {
+ if (!option_wifi)
+ return "nl80211,wext";
+ else
+ return option_wifi;
+ }
+
+ return NULL;
+}
+
+bool connman_setting_get_bool(const char *key)
+{
+ if (g_str_equal(key, CONF_BG_SCAN))
+ return connman_settings.bg_scan;
+
+ if (g_str_equal(key, CONF_ALLOW_HOSTNAME_UPDATES))
+ return connman_settings.allow_hostname_updates;
+
+ if (g_str_equal(key, CONF_SINGLE_TECH))
+ return connman_settings.single_tech;
+
+ if (g_str_equal(key, CONF_PERSISTENT_TETHERING_MODE))
+ return connman_settings.persistent_tethering_mode;
+
+ if (g_str_equal(key, CONF_ENABLE_6TO4))
+ return connman_settings.enable_6to4;
+
+ if (g_str_equal(key, CONF_ALWAYS_USE_FALLBACK_NAMESERVERS))
+ return connman_settings.always_use_fallback_nameservers;
+
+ return false;
+}
+
+char **connman_setting_get_string_list(const char *key)
+{
+ if (g_str_equal(key, CONF_PREF_TIMESERVERS))
+ return connman_settings.pref_timeservers;
+
+ if (g_str_equal(key, CONF_FALLBACK_NAMESERVERS))
+ return connman_settings.fallback_nameservers;
+
+ if (g_str_equal(key, CONF_BLACKLISTED_INTERFACES))
+ return connman_settings.blacklisted_interfaces;
+
+ if (g_str_equal(key, CONF_TETHERING_TECHNOLOGIES))
+ return connman_settings.tethering_technologies;
+
+ if (g_str_equal(key, CONF_TIME_UPDATES))
+ return connman_settings.time_updates;
+
+ return NULL;
+}
+
+unsigned int *connman_setting_get_uint_list(const char *key)
+{
+ if (g_str_equal(key, CONF_AUTO_CONNECT))
+ return connman_settings.auto_connect;
+
+ if (g_str_equal(key, CONF_PREFERRED_TECHS))
+ return connman_settings.preferred_techs;
+
+ return NULL;
+}
+
+unsigned int connman_timeout_input_request(void)
+{
+ return connman_settings.timeout_inputreq;
+}
+
+unsigned int connman_timeout_browser_launch(void)
+{
+ return connman_settings.timeout_browserlaunch;
+}
+
+static void connman_daemon_init(const char *pidfile)
+{
+ FILE *file;
+
+ if (daemon(0, 0)) {
+ perror("Can't start daemon");
+ exit(EXIT_FAILURE);
+ }
+
+ if (pidfile != NULL) {
+ file = fopen(pidfile, "w");
+ if (file != NULL) {
+ fprintf(file, "%u\n", getpid());
+ fclose(file);
+ }
+ }
+}
+
+static void connman_daemon_cleanup(const char *pidfile)
+{
+ if (pidfile != NULL) {
+ unlink(pidfile);
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ DBusConnection *conn;
+ DBusError err;
+ guint signal;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ exit(1);
+ }
+
+ g_option_context_free(context);
+
+ if (option_version) {
+ printf("%s\n", VERSION);
+ exit(0);
+ }
+
+ if (option_detach) {
+ connman_daemon_init(option_pidfile);
+ }
+
+ if (mkdir(STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
+ S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
+ if (errno != EEXIST)
+ perror("Failed to create storage directory");
+ }
+
+ umask(0077);
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ signal = setup_signalfd();
+
+ dbus_error_init(&err);
+
+ conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, CONNMAN_SERVICE, &err);
+ if (!conn) {
+ if (dbus_error_is_set(&err)) {
+ fprintf(stderr, "%s\n", err.message);
+ dbus_error_free(&err);
+ } else
+ fprintf(stderr, "Can't register with system bus\n");
+ exit(1);
+ }
+
+ g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
+
+ __connman_log_init(argv[0], option_debug, option_detach,
+ option_backtrace, "Connection Manager", VERSION);
+
+ __connman_dbus_init(conn);
+
+ if (!option_config)
+ config_init(CONFIGMAINFILE, option_rlimits);
+ else
+ config_init(option_config, option_rlimits);
+
+ __connman_util_init();
+ __connman_inotify_init();
+ __connman_technology_init();
+ __connman_notifier_init();
+ __connman_agent_init();
+ __connman_service_init();
+ __connman_peer_service_init();
+ __connman_peer_init();
+ __connman_provider_init();
+ __connman_network_init();
+ __connman_config_init();
+ __connman_device_init(option_device, option_nodevice);
+
+ __connman_ippool_init();
+ __connman_iptables_init();
+ __connman_firewall_init();
+ __connman_nat_init();
+ __connman_tethering_init();
+ __connman_counter_init();
+ __connman_manager_init();
+ __connman_stats_init();
+ __connman_clock_init();
+
+ __connman_ipconfig_init();
+ __connman_rtnl_init();
+ __connman_task_init();
+ __connman_proxy_init();
+ __connman_detect_init();
+ __connman_session_init();
+ __connman_timeserver_init();
+ __connman_connection_init();
+
+ __connman_plugin_init(option_plugin, option_noplugin);
+ __connman_resolver_init(option_dnsproxy);
+
+ __connman_rtnl_start();
+ __connman_dhcp_init();
+ __connman_dhcpv6_init();
+ __connman_wpad_init();
+ __connman_wispr_init();
+ __connman_rfkill_init();
+ __connman_machine_init();
+
+ g_free(option_config);
+ g_free(option_device);
+ g_free(option_plugin);
+ g_free(option_nodevice);
+ g_free(option_noplugin);
+
+ g_main_loop_run(main_loop);
+
+ g_source_remove(signal);
+
+ __connman_machine_cleanup();
+ __connman_rfkill_cleanup();
+ __connman_wispr_cleanup();
+ __connman_wpad_cleanup();
+ __connman_dhcpv6_cleanup();
+ __connman_session_cleanup();
+ __connman_plugin_cleanup();
+ __connman_provider_cleanup();
+ __connman_connection_cleanup();
+ __connman_timeserver_cleanup();
+ __connman_detect_cleanup();
+ __connman_proxy_cleanup();
+ __connman_task_cleanup();
+ __connman_rtnl_cleanup();
+ __connman_resolver_cleanup();
+
+ __connman_clock_cleanup();
+ __connman_stats_cleanup();
+ __connman_config_cleanup();
+ __connman_manager_cleanup();
+ __connman_counter_cleanup();
+ __connman_tethering_cleanup();
+ __connman_nat_cleanup();
+ __connman_firewall_cleanup();
+ __connman_iptables_cleanup();
+ __connman_peer_service_cleanup();
+ __connman_peer_cleanup();
+ __connman_ippool_cleanup();
+ __connman_device_cleanup();
+ __connman_network_cleanup();
+ __connman_dhcp_cleanup();
+ __connman_service_cleanup();
+ __connman_agent_cleanup();
+ __connman_ipconfig_cleanup();
+ __connman_notifier_cleanup();
+ __connman_technology_cleanup();
+ __connman_inotify_cleanup();
+
+ __connman_util_cleanup();
+ __connman_dbus_cleanup();
+
+ __connman_log_cleanup(option_backtrace);
+
+ dbus_connection_unref(conn);
+
+ g_main_loop_unref(main_loop);
+
+ if (connman_settings.pref_timeservers)
+ g_strfreev(connman_settings.pref_timeservers);
+
+ g_free(connman_settings.auto_connect);
+ g_free(connman_settings.preferred_techs);
+ g_strfreev(connman_settings.fallback_nameservers);
+ g_strfreev(connman_settings.blacklisted_interfaces);
+ g_strfreev(connman_settings.tethering_technologies);
+ g_strfreev(connman_settings.time_updates);
+
+ connman_daemon_cleanup(option_pidfile);
+
+ g_free(option_pidfile);
+ g_free(option_debug);
+ g_free(option_wifi);
+
+ return 0;
+}
diff --git a/src/main.conf b/src/main.conf
new file mode 100644
index 0000000..2f5ea3f
--- /dev/null
+++ b/src/main.conf
@@ -0,0 +1,142 @@
+# This file is part of Connection Manager.
+#
+# Connection Manager is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License version
+# 2 as published by the Free Software Foundation.
+#
+# Connection Manager is distributed in the hope that it will be
+# useful, but WITHOUT ANY WARRANTY; without even the implied warranty
+# of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
+# USA
+
+[General]
+
+# Set input request timeout. Default is 120 seconds
+# The request for inputs like passphrase will timeout
+# after certain amount of time. Use this setting to
+# increase the value in case of different user
+# interface designs.
+# InputRequestTimeout = 120
+
+# Set browser launch timeout. Default is 300 seconds
+# The request for launching a browser for portal pages
+# will timeout after certain amount of time. Use this
+# setting to increase the value in case of different
+# user interface designs.
+# BrowserLaunchTimeout = 300
+
+# Enable background scanning. Default is true.
+# Background scanning will start every 5 minutes unless
+# the scan list is empty. In that case, a simple backoff
+# mechanism starting from 10s up to 5 minutes will run.
+# BackgroundScanning = true
+
+# List of Fallback timeservers separated by ",".
+# These timeservers are used for NTP sync when there are
+# no timeserver set by the user or by the service.
+# These can contain mixed combination of fully qualified
+# domain names, IPv4 and IPv6 addresses.
+# FallbackTimeservers =
+
+# TimeUpdates mode
+# One of: "manual" or "auto"
+# "manual" disables NTP
+# "auto" enables NTP
+# default is "auto"
+# TimeUpdates =
+
+# List of fallback nameservers separated by "," used if no
+# nameservers are otherwise provided by the service. The
+# nameserver entries must be in numeric format, host
+# names are ignored.
+# FallbackNameservers =
+
+# Always use fallback name servers even though the name
+# servers are provided by the service. i.e from DHCP reply.
+# AlwaysUseFallbackNameservers = true
+
+# List of technologies that are marked autoconnectable
+# by default, separated by commas ",". The default value
+# for this entry when empty is ethernet,wifi,cellular.
+# Services that are automatically connected must have been
+# set up and saved to storage beforehand.
+# DefaultAutoConnectTechnologies =
+
+# List of preferred technologies from the most preferred
+# one to the least preferred one separated by commas ",".
+# Services of the listed technology type will be tried one
+# by one in the order given, until one of them gets connected
+# or they are all tried. A service of a preferred technology
+# type in state 'ready' will get the default route when
+# compared to another preferred type further down the list
+# with state 'ready' or with a non-preferred type; a service
+# of a preferred technology type in state 'online' will get
+# the default route when compared to either a non-preferred
+# type or a preferred type further down in the list.
+# PreferredTechnologies =
+
+# List of blacklisted network interfaces separated by ",".
+# Found interfaces will be compared to the list and will
+# not be handled by connman, if their first characters
+# match any of the list entries. Default value is
+# vmnet,vboxnet,virbr,ifb.
+# NetworkInterfaceBlacklist = vmnet,vboxnet,virbr,ifb
+
+# Allow connman to change the system hostname. This can
+# happen for example if we receive DHCP hostname option.
+# Default value is true.
+# AllowHostnameUpdates = true
+
+# Keep only a single connected technology at any time. When a new
+# service is connected by the user or a better one is found according
+# to PreferredTechnologies, the new service is kept connected and all
+# the other previously connected services are disconnected. With this
+# setting it does not matter whether the previously connected services
+# are in 'online' or 'ready' states, the newly connected service is
+# the only one that will be kept connected. A service connected by the
+# user will be used until going out of network coverage. With this
+# setting enabled applications will notice more network breaks than
+# normal. Default value is false.
+# SingleConnectedTechnology = false
+
+# List of technologies for which tethering is allowed separated by ",".
+# The default value is wifi,bluetooth,gadget. Only those technologies
+# listed here are used for tethering. If ethernet tethering is desired,
+# then ethernet should be added to the list. The technologies listed here
+# have to support tethering, currently tethering is implemented for wifi,
+# bluetooth, gadget and ethernet.
+# NOTE that if ethernet tethering is enabled, then a DHCP server is
+# started on all ethernet interfaces. Tethered ethernet should
+# never be connected to corporate or home network as it will disrupt
+# normal operation of these networks. Due to this ethernet is not
+# tethered by default. Do not activate ethernet tethering unless you
+# really know what you are doing.
+# TetheringTechnologies = wifi,bluetooth,gadget
+
+# Restore earlier tethering status when returning from offline mode,
+# re-enabling a technology, and after restarts and reboots.
+# Default value is false.
+# PersistentTetheringMode = false
+
+# Automatically enable Anycast 6to4 if possible. This is not recommended, as
+# the use of 6to4 will generally lead to a severe degradation of connection
+# quality. See RFC6343. Default value is false (as recommended by RFC6343
+# section 4.1).
+# Enable6to4 = false
+[rlimits]
+
+# Connection Manager resource limits. See setrlimit(2) for more information.
+
+rlimit-as=5242880
+rlimit-core=0
+rlimit-data=3145728
+#rlimit-fsize=0
+rlimit-nofile=768
+rlimit-stack=262144
+rlimit-nproc=3
+rlimit-memlock=0
diff --git a/src/manager.c b/src/manager.c
new file mode 100644
index 0000000..d15ce20
--- /dev/null
+++ b/src/manager.c
@@ -0,0 +1,616 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <gdbus.h>
+
+#include <connman/agent.h>
+
+#include "connman.h"
+
+static bool connman_state_idle;
+static dbus_bool_t sessionmode;
+
+static DBusMessage *get_properties(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ DBusMessageIter array, dict;
+ dbus_bool_t offlinemode;
+ const char *str;
+
+ DBG("conn %p", conn);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &array);
+
+ connman_dbus_dict_open(&array, &dict);
+
+ str = __connman_notifier_get_state();
+ connman_dbus_dict_append_basic(&dict, "State",
+ DBUS_TYPE_STRING, &str);
+
+ offlinemode = __connman_technology_get_offlinemode();
+ connman_dbus_dict_append_basic(&dict, "OfflineMode",
+ DBUS_TYPE_BOOLEAN, &offlinemode);
+
+ connman_dbus_dict_append_basic(&dict, "SessionMode",
+ DBUS_TYPE_BOOLEAN,
+ &sessionmode);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ return reply;
+}
+
+static DBusMessage *set_property(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessageIter iter, value;
+ const char *name;
+ int type;
+
+ DBG("conn %p", conn);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ if (g_str_equal(name, "OfflineMode")) {
+ dbus_bool_t offlinemode;
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &offlinemode);
+
+ __connman_technology_set_offlinemode(offlinemode);
+ } else if (g_str_equal(name, "SessionMode")) {
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &sessionmode);
+
+ } else
+ return __connman_error_invalid_property(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static void append_technology_structs(DBusMessageIter *iter, void *user_data)
+{
+ __connman_technology_list_struct(iter);
+}
+
+static DBusMessage *get_technologies(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+
+ DBG("");
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ __connman_dbus_append_objpath_dict_array(reply,
+ append_technology_structs, NULL);
+
+ return reply;
+}
+
+static DBusMessage *remove_provider(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = __connman_provider_remove_by_path(path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusConnection *connection = NULL;
+
+static void idle_state(bool idle)
+{
+
+ DBG("idle %d", idle);
+
+ connman_state_idle = idle;
+
+ if (!connman_state_idle)
+ return;
+}
+
+static struct connman_notifier technology_notifier = {
+ .name = "manager",
+ .priority = CONNMAN_NOTIFIER_PRIORITY_HIGH,
+ .idle_state = idle_state,
+};
+
+static void append_service_structs(DBusMessageIter *iter, void *user_data)
+{
+ __connman_service_list_struct(iter);
+}
+
+static DBusMessage *get_services(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ __connman_dbus_append_objpath_dict_array(reply,
+ append_service_structs, NULL);
+
+ return reply;
+}
+
+static void append_peer_structs(DBusMessageIter *iter, void *user_data)
+{
+ __connman_peer_list_struct(iter);
+}
+
+static DBusMessage *get_peers(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ __connman_dbus_append_objpath_dict_array(reply,
+ append_peer_structs, NULL);
+ return reply;
+}
+
+static DBusMessage *connect_provider(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ int err;
+
+ DBG("conn %p", conn);
+
+ err = __connman_provider_create_and_connect(msg);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return NULL;
+}
+
+static DBusMessage *register_agent(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender, *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = connman_agent_register(sender, path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *unregister_agent(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender, *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = connman_agent_unregister(sender, path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *register_counter(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender, *path;
+ unsigned int accuracy, period;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_UINT32, &accuracy,
+ DBUS_TYPE_UINT32, &period,
+ DBUS_TYPE_INVALID);
+
+ /* FIXME: add handling of accuracy parameter */
+
+ err = __connman_counter_register(sender, path, period);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *unregister_counter(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender, *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = __connman_counter_unregister(sender, path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *create_session(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ int err;
+
+ DBG("conn %p", conn);
+
+ err = __connman_session_create(msg);
+ if (err < 0) {
+ if (err == -EINPROGRESS)
+ return NULL;
+
+ return __connman_error_failed(msg, -err);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *destroy_session(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ int err;
+
+ DBG("conn %p", conn);
+
+ err = __connman_session_destroy(msg);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *request_private_network(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ err = __connman_private_network_request(msg, sender);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return NULL;
+}
+
+static DBusMessage *release_private_network(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = __connman_private_network_release(path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static int parse_peers_service_specs(DBusMessageIter *array,
+ const unsigned char **spec, int *spec_len,
+ const unsigned char **query, int *query_len,
+ int *version)
+{
+ *spec = *query = NULL;
+ *spec_len = *query_len = *version = 0;
+
+ while (dbus_message_iter_get_arg_type(array) ==
+ DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, inter, value;
+ const char *key;
+
+ dbus_message_iter_recurse(array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+
+ dbus_message_iter_recurse(&entry, &inter);
+
+ if (!g_strcmp0(key, "BonjourResponse")) {
+ dbus_message_iter_recurse(&inter, &value);
+ dbus_message_iter_get_fixed_array(&value,
+ spec, spec_len);
+ } else if (!g_strcmp0(key, "BonjourQuery")) {
+ dbus_message_iter_recurse(&inter, &value);
+ dbus_message_iter_get_fixed_array(&value,
+ query, query_len);
+ } else if (!g_strcmp0(key, "UpnpService")) {
+ dbus_message_iter_get_basic(&inter, spec);
+ *spec_len = strlen((const char *)*spec)+1;
+ } else if (!g_strcmp0(key, "UpnpVersion")) {
+ dbus_message_iter_get_basic(&inter, version);
+ } else if (!g_strcmp0(key, "WiFiDisplayIEs")) {
+ if (*spec || *query)
+ return -EINVAL;
+
+ dbus_message_iter_recurse(&inter, &value);
+ dbus_message_iter_get_fixed_array(&value,
+ spec, spec_len);
+ } else
+ return -EINVAL;
+
+ dbus_message_iter_next(array);
+ }
+
+ if ((*query && !*spec && !*version) ||
+ (!*spec && !*query) || (!*spec && *version))
+ return -EINVAL;
+
+ return 0;
+}
+
+static DBusMessage *register_peer_service(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const unsigned char *spec, *query;
+ DBusMessageIter iter, array;
+ int spec_len, query_len;
+ dbus_bool_t master;
+ const char *owner;
+ int version;
+ int ret;
+
+ DBG("");
+
+ owner = dbus_message_get_sender(msg);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ ret = parse_peers_service_specs(&array, &spec, &spec_len,
+ &query, &query_len, &version);
+ if (ret)
+ goto error;
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_get_basic(&iter, &master);
+
+ ret = __connman_peer_service_register(owner, msg, spec, spec_len,
+ query, query_len, version,master);
+ if (!ret)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ if (ret == -EINPROGRESS)
+ return NULL;
+error:
+ return __connman_error_failed(msg, -ret);
+}
+
+static DBusMessage *unregister_peer_service(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const unsigned char *spec, *query;
+ DBusMessageIter iter, array;
+ int spec_len, query_len;
+ const char *owner;
+ int version;
+ int ret;
+
+ DBG("");
+
+ owner = dbus_message_get_sender(msg);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ ret = parse_peers_service_specs(&array, &spec, &spec_len,
+ &query, &query_len, &version);
+ if (ret)
+ goto error;
+
+ ret = __connman_peer_service_unregister(owner, spec, spec_len,
+ query, query_len, version);
+ if (!ret)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+error:
+ return __connman_error_failed(msg, -ret);
+
+}
+
+static const GDBusMethodTable manager_methods[] = {
+ { GDBUS_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ get_properties) },
+ { GDBUS_ASYNC_METHOD("SetProperty",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+ NULL, set_property) },
+ { GDBUS_METHOD("GetTechnologies",
+ NULL, GDBUS_ARGS({ "technologies", "a(oa{sv})" }),
+ get_technologies) },
+ { GDBUS_DEPRECATED_METHOD("RemoveProvider",
+ GDBUS_ARGS({ "provider", "o" }), NULL,
+ remove_provider) },
+ { GDBUS_METHOD("GetServices",
+ NULL, GDBUS_ARGS({ "services", "a(oa{sv})" }),
+ get_services) },
+ { GDBUS_METHOD("GetPeers",
+ NULL, GDBUS_ARGS({ "peers", "a(oa{sv})" }),
+ get_peers) },
+ { GDBUS_DEPRECATED_ASYNC_METHOD("ConnectProvider",
+ GDBUS_ARGS({ "provider", "a{sv}" }),
+ GDBUS_ARGS({ "path", "o" }),
+ connect_provider) },
+ { GDBUS_METHOD("RegisterAgent",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ register_agent) },
+ { GDBUS_METHOD("UnregisterAgent",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ unregister_agent) },
+ { GDBUS_METHOD("RegisterCounter",
+ GDBUS_ARGS({ "path", "o" }, { "accuracy", "u" },
+ { "period", "u" }),
+ NULL, register_counter) },
+ { GDBUS_METHOD("UnregisterCounter",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ unregister_counter) },
+ { GDBUS_ASYNC_METHOD("CreateSession",
+ GDBUS_ARGS({ "settings", "a{sv}" },
+ { "notifier", "o" }),
+ GDBUS_ARGS({ "session", "o" }),
+ create_session) },
+ { GDBUS_METHOD("DestroySession",
+ GDBUS_ARGS({ "session", "o" }), NULL,
+ destroy_session) },
+ { GDBUS_ASYNC_METHOD("RequestPrivateNetwork",
+ NULL, GDBUS_ARGS({ "path", "o" },
+ { "settings", "a{sv}" },
+ { "socket", "h" }),
+ request_private_network) },
+ { GDBUS_METHOD("ReleasePrivateNetwork",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ release_private_network) },
+ { GDBUS_ASYNC_METHOD("RegisterPeerService",
+ GDBUS_ARGS({ "specification", "a{sv}" },
+ { "master", "b" }), NULL,
+ register_peer_service) },
+ { GDBUS_METHOD("UnregisterPeerService",
+ GDBUS_ARGS({ "specification", "a{sv}" }), NULL,
+ unregister_peer_service) },
+ { },
+};
+
+static const GDBusSignalTable manager_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { GDBUS_SIGNAL("TechnologyAdded",
+ GDBUS_ARGS({ "path", "o" },
+ { "properties", "a{sv}" })) },
+ { GDBUS_SIGNAL("TechnologyRemoved",
+ GDBUS_ARGS({ "path", "o" })) },
+ { GDBUS_SIGNAL("ServicesChanged",
+ GDBUS_ARGS({ "changed", "a(oa{sv})" },
+ { "removed", "ao" })) },
+ { GDBUS_SIGNAL("PeersChanged",
+ GDBUS_ARGS({ "changed", "a(oa{sv})" },
+ { "removed", "ao" })) },
+ { },
+};
+
+int __connman_manager_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ if (connman_notifier_register(&technology_notifier) < 0)
+ connman_error("Failed to register technology notifier");
+
+ g_dbus_register_interface(connection, CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE,
+ manager_methods,
+ manager_signals, NULL, NULL, NULL);
+
+ connman_state_idle = true;
+
+ return 0;
+}
+
+void __connman_manager_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ connman_notifier_unregister(&technology_notifier);
+
+ g_dbus_unregister_interface(connection, CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE);
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/nat.c b/src/nat.c
new file mode 100644
index 0000000..063f085
--- /dev/null
+++ b/src/nat.c
@@ -0,0 +1,226 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+
+#include "connman.h"
+
+static char *default_interface;
+static GHashTable *nat_hash;
+
+struct connman_nat {
+ char *address;
+ unsigned char prefixlen;
+ struct firewall_context *fw;
+
+ char *interface;
+};
+
+static int enable_ip_forward(bool enable)
+{
+ FILE *f;
+
+ f = fopen("/proc/sys/net/ipv4/ip_forward", "r+");
+ if (!f)
+ return -errno;
+
+ if (enable)
+ fprintf(f, "1");
+ else
+ fprintf(f, "0");
+
+ fclose(f);
+
+ return 0;
+}
+
+static int enable_nat(struct connman_nat *nat)
+{
+ char *cmd;
+ int err;
+
+ g_free(nat->interface);
+ nat->interface = g_strdup(default_interface);
+
+ if (!nat->interface)
+ return 0;
+
+ /* Enable masquerading */
+ cmd = g_strdup_printf("-s %s/%d -o %s -j MASQUERADE",
+ nat->address,
+ nat->prefixlen,
+ nat->interface);
+
+ err = __connman_firewall_add_rule(nat->fw, "nat",
+ "POSTROUTING", cmd);
+ g_free(cmd);
+ if (err < 0)
+ return err;
+
+ return __connman_firewall_enable(nat->fw);
+}
+
+static void disable_nat(struct connman_nat *nat)
+{
+ if (!nat->interface)
+ return;
+
+ /* Disable masquerading */
+ __connman_firewall_disable(nat->fw);
+}
+
+int __connman_nat_enable(const char *name, const char *address,
+ unsigned char prefixlen)
+{
+ struct connman_nat *nat;
+ int err;
+
+ if (g_hash_table_size(nat_hash) == 0) {
+ err = enable_ip_forward(true);
+ if (err < 0)
+ return err;
+ }
+
+ nat = g_try_new0(struct connman_nat, 1);
+ if (!nat)
+ goto err;
+
+ nat->fw = __connman_firewall_create();
+ if (!nat->fw)
+ goto err;
+
+ nat->address = g_strdup(address);
+ nat->prefixlen = prefixlen;
+
+ g_hash_table_replace(nat_hash, g_strdup(name), nat);
+
+ return enable_nat(nat);
+
+err:
+ if (nat) {
+ if (nat->fw)
+ __connman_firewall_destroy(nat->fw);
+ g_free(nat);
+ }
+
+ if (g_hash_table_size(nat_hash) == 0)
+ enable_ip_forward(false);
+
+ return -ENOMEM;
+}
+
+void __connman_nat_disable(const char *name)
+{
+ struct connman_nat *nat;
+
+ nat = g_hash_table_lookup(nat_hash, name);
+ if (!nat)
+ return;
+
+ disable_nat(nat);
+
+ g_hash_table_remove(nat_hash, name);
+
+ if (g_hash_table_size(nat_hash) == 0)
+ enable_ip_forward(false);
+}
+
+static void update_default_interface(struct connman_service *service)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ char *interface;
+ int err;
+
+ interface = connman_service_get_interface(service);
+
+ DBG("interface %s", interface);
+
+ g_free(default_interface);
+ default_interface = interface;
+
+ g_hash_table_iter_init(&iter, nat_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ const char *name = key;
+ struct connman_nat *nat = value;
+
+ disable_nat(nat);
+ err = enable_nat(nat);
+ if (err < 0)
+ DBG("Failed to enable nat for %s", name);
+ }
+}
+
+static void shutdown_nat(gpointer key, gpointer value, gpointer user_data)
+{
+ const char *name = key;
+
+ __connman_nat_disable(name);
+}
+
+static void cleanup_nat(gpointer data)
+{
+ struct connman_nat *nat = data;
+
+ __connman_firewall_destroy(nat->fw);
+ g_free(nat->address);
+ g_free(nat->interface);
+ g_free(nat);
+}
+
+static struct connman_notifier nat_notifier = {
+ .name = "nat",
+ .default_changed = update_default_interface,
+};
+
+int __connman_nat_init(void)
+{
+ int err;
+
+ DBG("");
+
+ err = connman_notifier_register(&nat_notifier);
+ if (err < 0)
+ return err;
+
+ nat_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, cleanup_nat);
+
+ return 0;
+}
+
+void __connman_nat_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_foreach(nat_hash, shutdown_nat, NULL);
+ g_hash_table_destroy(nat_hash);
+ nat_hash = NULL;
+
+ connman_notifier_unregister(&nat_notifier);
+}
diff --git a/src/net.connman.service.in b/src/net.connman.service.in
new file mode 100644
index 0000000..f7f6a7c
--- /dev/null
+++ b/src/net.connman.service.in
@@ -0,0 +1,5 @@
+[D-BUS Service]
+Name=net.connman
+Exec=@sbindir@/connmand -n
+User=root
+SystemdService=connman.service
diff --git a/src/network.c b/src/network.c
new file mode 100644
index 0000000..bd27294
--- /dev/null
+++ b/src/network.c
@@ -0,0 +1,2148 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#include "connman.h"
+
+/*
+ * How many times to send RS with the purpose of
+ * refreshing RDNSS entries before they actually expire.
+ * With a value of 1, one RS will be sent, with no retries.
+ */
+#define RS_REFRESH_COUNT 1
+
+/*
+ * Value in seconds to wait for RA after RS was sent.
+ * After this time elapsed, we can send another RS.
+ */
+#define RS_REFRESH_TIMEOUT 3
+
+static GSList *network_list = NULL;
+static GSList *driver_list = NULL;
+
+struct connman_network {
+ int refcount;
+ enum connman_network_type type;
+ bool available;
+ bool connected;
+ bool roaming;
+ bool connectable;
+ uint8_t strength;
+ uint16_t frequency;
+ char *identifier;
+ char *name;
+ char *node;
+ char *group;
+ char *path;
+ int index;
+ int router_solicit_count;
+ int router_solicit_refresh_count;
+
+ struct connman_network_driver *driver;
+ void *driver_data;
+
+ bool connecting;
+ bool associating;
+
+ struct connman_device *device;
+
+ struct {
+ void *ssid;
+ int ssid_len;
+ char *mode;
+ unsigned short channel;
+ char *security;
+ char *passphrase;
+ char *eap;
+ char *identity;
+ char *agent_identity;
+ char *ca_cert_path;
+ char *client_cert_path;
+ char *private_key_path;
+ char *private_key_passphrase;
+ char *phase2_auth;
+ bool wps;
+ bool use_wps;
+ char *pin_wps;
+ } wifi;
+
+ struct {
+ bool joining_permitted;
+ char *parent_address;
+ uint64_t xpan_id;
+ } lowpan;
+
+};
+
+static const char *type2string(enum connman_network_type type)
+{
+ switch (type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ break;
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ return "ethernet";
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ return "gadget";
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ return "wifi";
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ return "bluetooth";
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ return "cellular";
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ return "lowpan";
+ }
+
+ return NULL;
+}
+
+static bool match_driver(struct connman_network *network,
+ struct connman_network_driver *driver)
+{
+ if (network->type == driver->type ||
+ driver->type == CONNMAN_NETWORK_TYPE_UNKNOWN)
+ return true;
+
+ return false;
+}
+
+static void set_configuration(struct connman_network *network,
+ enum connman_ipconfig_type type)
+{
+ struct connman_service *service;
+
+ DBG("network %p", network);
+
+ if (!network->device)
+ return;
+
+ __connman_device_set_network(network->device, network);
+
+ connman_device_set_disconnected(network->device, false);
+
+ service = connman_service_lookup_from_network(network);
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_CONFIGURATION,
+ type);
+}
+
+static void dhcp_success(struct connman_network *network)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig_ipv4;
+ int err;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ goto err;
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+
+ DBG("lease acquired for ipconfig %p", ipconfig_ipv4);
+
+ if (!ipconfig_ipv4)
+ return;
+
+ err = __connman_ipconfig_address_add(ipconfig_ipv4);
+ if (err < 0)
+ goto err;
+
+ err = __connman_ipconfig_gateway_add(ipconfig_ipv4);
+ if (err < 0)
+ goto err;
+
+ return;
+
+err:
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
+}
+
+static void dhcp_failure(struct connman_network *network)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig_ipv4;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return;
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+
+ DBG("lease lost for ipconfig %p", ipconfig_ipv4);
+
+ if (!ipconfig_ipv4)
+ return;
+
+ __connman_ipconfig_address_remove(ipconfig_ipv4);
+ __connman_ipconfig_gateway_remove(ipconfig_ipv4);
+}
+
+static void dhcp_callback(struct connman_ipconfig *ipconfig,
+ struct connman_network *network,
+ bool success, gpointer data)
+{
+ network->connecting = false;
+
+ if (success)
+ dhcp_success(network);
+ else
+ dhcp_failure(network);
+}
+
+static int set_connected_manual(struct connman_network *network)
+{
+ int err = 0;
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+
+ DBG("network %p", network);
+
+ network->connecting = false;
+
+ service = connman_service_lookup_from_network(network);
+
+ ipconfig = __connman_service_get_ip4config(service);
+
+ if (!__connman_ipconfig_get_local(ipconfig))
+ __connman_service_read_ip4config(service);
+
+ err = __connman_ipconfig_address_add(ipconfig);
+ if (err < 0)
+ goto err;
+
+ err = __connman_ipconfig_gateway_add(ipconfig);
+ if (err < 0)
+ goto err;
+
+err:
+ return err;
+}
+
+static int set_connected_dhcp(struct connman_network *network)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig_ipv4;
+ int err;
+
+ DBG("network %p", network);
+
+ service = connman_service_lookup_from_network(network);
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+
+ err = __connman_dhcp_start(ipconfig_ipv4, network,
+ dhcp_callback, NULL);
+ if (err < 0) {
+ connman_error("Can not request DHCP lease");
+ return err;
+ }
+
+ return 0;
+}
+
+static int manual_ipv6_set(struct connman_network *network,
+ struct connman_ipconfig *ipconfig_ipv6)
+{
+ struct connman_service *service;
+ int err;
+
+ DBG("network %p ipv6 %p", network, ipconfig_ipv6);
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+
+ if (!__connman_ipconfig_get_local(ipconfig_ipv6))
+ __connman_service_read_ip6config(service);
+
+ __connman_ipconfig_enable_ipv6(ipconfig_ipv6);
+
+ err = __connman_ipconfig_address_add(ipconfig_ipv6);
+ if (err < 0) {
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
+ return err;
+ }
+
+ err = __connman_ipconfig_gateway_add(ipconfig_ipv6);
+ if (err < 0)
+ return err;
+
+ __connman_connection_gateway_activate(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ __connman_device_set_network(network->device, network);
+
+ connman_device_set_disconnected(network->device, false);
+
+ connman_network_set_associating(network, false);
+
+ network->connecting = false;
+
+ return 0;
+}
+
+static void stop_dhcpv6(struct connman_network *network)
+{
+ network->connecting = false;
+
+ __connman_dhcpv6_stop(network);
+}
+
+static void dhcpv6_release_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status,
+ gpointer data)
+{
+ DBG("status %d", status);
+
+ stop_dhcpv6(network);
+}
+
+static void release_dhcpv6(struct connman_network *network)
+{
+ __connman_dhcpv6_start_release(network, dhcpv6_release_callback);
+ stop_dhcpv6(network);
+}
+
+static void dhcpv6_info_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status,
+ gpointer data)
+{
+ DBG("status %d", status);
+
+ stop_dhcpv6(network);
+}
+
+static int dhcpv6_set_addresses(struct connman_network *network)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig_ipv6;
+ int err = -EINVAL;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ goto err;
+
+ network->connecting = false;
+
+ ipconfig_ipv6 = __connman_service_get_ip6config(service);
+ err = __connman_ipconfig_address_add(ipconfig_ipv6);
+ if (err < 0)
+ goto err;
+
+ return 0;
+
+err:
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
+ return err;
+}
+
+static void autoconf_ipv6_set(struct connman_network *network);
+static void dhcpv6_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status, gpointer data);
+
+/*
+ * Have a separate callback for renew so that we do not do autoconf
+ * in wrong phase as the dhcpv6_callback() is also called when doing
+ * DHCPv6 solicitation.
+ */
+static void dhcpv6_renew_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status,
+ gpointer data)
+{
+ switch (status) {
+ case CONNMAN_DHCPV6_STATUS_SUCCEED:
+ dhcpv6_callback(network, status, data);
+ break;
+ case CONNMAN_DHCPV6_STATUS_FAIL:
+ case CONNMAN_DHCPV6_STATUS_RESTART:
+ stop_dhcpv6(network);
+
+ /* restart and do solicit again. */
+ autoconf_ipv6_set(network);
+ break;
+ }
+}
+
+static void dhcpv6_callback(struct connman_network *network,
+ enum __connman_dhcpv6_status status, gpointer data)
+{
+ DBG("status %d", status);
+
+ /* Start the renew process if necessary */
+ if (status == CONNMAN_DHCPV6_STATUS_SUCCEED) {
+
+ if (dhcpv6_set_addresses(network) < 0) {
+ stop_dhcpv6(network);
+ return;
+ }
+
+ if (__connman_dhcpv6_start_renew(network,
+ dhcpv6_renew_callback) == -ETIMEDOUT)
+ dhcpv6_renew_callback(network,
+ CONNMAN_DHCPV6_STATUS_FAIL,
+ data);
+
+ } else if (status == CONNMAN_DHCPV6_STATUS_RESTART) {
+ stop_dhcpv6(network);
+ autoconf_ipv6_set(network);
+ } else
+ stop_dhcpv6(network);
+}
+
+static void check_dhcpv6(struct nd_router_advert *reply,
+ unsigned int length, void *user_data)
+{
+ struct connman_network *network = user_data;
+ struct connman_service *service;
+ GSList *prefixes;
+
+ DBG("reply %p", reply);
+
+ if (!reply) {
+ /*
+ * Router solicitation message seem to get lost easily so
+ * try to send it again.
+ */
+ if (network->router_solicit_count > 0) {
+ DBG("re-send router solicitation %d",
+ network->router_solicit_count);
+ network->router_solicit_count--;
+ __connman_inet_ipv6_send_rs(network->index, 1,
+ check_dhcpv6, network);
+ return;
+ }
+ connman_network_unref(network);
+ return;
+ }
+
+ network->router_solicit_count = 0;
+
+ /*
+ * If we were disconnected while waiting router advertisement,
+ * we just quit and do not start DHCPv6
+ */
+ if (!network->connected) {
+ connman_network_unref(network);
+ return;
+ }
+
+ prefixes = __connman_inet_ipv6_get_prefixes(reply, length);
+
+ /*
+ * If IPv6 config is missing from service, then create it.
+ * The ipconfig might be missing if we got a rtnl message
+ * that disabled IPv6 config and thus removed it. This
+ * can happen if we are switching from one service to
+ * another in the same interface. The only way to get IPv6
+ * config back is to re-create it here.
+ */
+ service = connman_service_lookup_from_network(network);
+ if (service) {
+ connman_service_create_ip6config(service, network->index);
+
+ connman_network_set_associating(network, false);
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_CONFIGURATION,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ }
+
+ /*
+ * We do stateful/stateless DHCPv6 if router advertisement says so.
+ */
+ if (reply->nd_ra_flags_reserved & ND_RA_FLAG_MANAGED) {
+ __connman_dhcpv6_start(network, prefixes, dhcpv6_callback);
+ } else {
+ if (reply->nd_ra_flags_reserved & ND_RA_FLAG_OTHER)
+ __connman_dhcpv6_start_info(network,
+ dhcpv6_info_callback);
+
+ g_slist_free_full(prefixes, g_free);
+ network->connecting = false;
+ }
+
+ connman_network_unref(network);
+}
+
+static void receive_refresh_rs_reply(struct nd_router_advert *reply,
+ unsigned int length, void *user_data)
+{
+ struct connman_network *network = user_data;
+
+ DBG("reply %p", reply);
+
+ if (!reply) {
+ /*
+ * Router solicitation message seem to get lost easily so
+ * try to send it again.
+ */
+ if (network->router_solicit_refresh_count > 1) {
+ network->router_solicit_refresh_count--;
+ DBG("re-send router solicitation %d",
+ network->router_solicit_refresh_count);
+ __connman_inet_ipv6_send_rs(network->index,
+ RS_REFRESH_TIMEOUT,
+ receive_refresh_rs_reply,
+ network);
+ return;
+ }
+ }
+
+ /* RS refresh not in progress anymore */
+ network->router_solicit_refresh_count = 0;
+
+ connman_network_unref(network);
+ return;
+}
+
+int __connman_network_refresh_rs_ipv6(struct connman_network *network,
+ int index)
+{
+ int ret = 0;
+
+ DBG("network %p index %d", network, index);
+
+ /* Send only one RS for all RDNSS entries which are about to expire */
+ if (network->router_solicit_refresh_count > 0) {
+ DBG("RS refresh already started");
+ return 0;
+ }
+
+ network->router_solicit_refresh_count = RS_REFRESH_COUNT;
+
+ connman_network_ref(network);
+
+ ret = __connman_inet_ipv6_send_rs(index, RS_REFRESH_TIMEOUT,
+ receive_refresh_rs_reply, network);
+ return ret;
+}
+
+static void autoconf_ipv6_set(struct connman_network *network)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+ int index;
+
+ DBG("network %p", network);
+
+ if (network->router_solicit_count > 0) {
+ /*
+ * The autoconfiguration is already pending and we have sent
+ * router solicitation messages and are now waiting answers.
+ * There is no need to continue any further.
+ */
+ DBG("autoconfiguration already started");
+ return;
+ }
+
+ __connman_device_set_network(network->device, network);
+
+ connman_device_set_disconnected(network->device, false);
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return;
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (!ipconfig)
+ return;
+
+ __connman_ipconfig_enable_ipv6(ipconfig);
+
+ __connman_ipconfig_address_remove(ipconfig);
+
+ index = __connman_ipconfig_get_index(ipconfig);
+
+ connman_network_ref(network);
+
+ /* Try to get stateless DHCPv6 information, RFC 3736 */
+ network->router_solicit_count = 3;
+ __connman_inet_ipv6_send_rs(index, 1, check_dhcpv6, network);
+}
+
+static void set_connected(struct connman_network *network)
+{
+ struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
+ struct connman_service *service;
+
+ if (network->connected)
+ return;
+
+ connman_network_set_associating(network, false);
+
+ network->connected = true;
+
+ service = connman_service_lookup_from_network(network);
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+ ipconfig_ipv6 = __connman_service_get_ip6config(service);
+
+ DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
+ ipconfig_ipv6);
+
+ __connman_network_enable_ipconfig(network, ipconfig_ipv4);
+ __connman_network_enable_ipconfig(network, ipconfig_ipv6);
+}
+
+static void set_disconnected(struct connman_network *network)
+{
+ struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
+ enum connman_ipconfig_method ipv4_method, ipv6_method;
+ enum connman_service_state state;
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+ ipconfig_ipv6 = __connman_service_get_ip6config(service);
+
+ DBG("service %p ipv4 %p ipv6 %p", service, ipconfig_ipv4,
+ ipconfig_ipv6);
+
+ ipv4_method = __connman_ipconfig_get_method(ipconfig_ipv4);
+ ipv6_method = __connman_ipconfig_get_method(ipconfig_ipv6);
+
+ DBG("method ipv4 %d ipv6 %d", ipv4_method, ipv6_method);
+
+ /*
+ * Resetting solicit count here will prevent the RS resend loop
+ * from sending packets in check_dhcpv6()
+ */
+ network->router_solicit_count = 0;
+
+ __connman_device_set_network(network->device, NULL);
+
+ if (network->connected) {
+ switch (ipv6_method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ release_dhcpv6(network);
+ break;
+ }
+
+ switch (ipv4_method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ break;
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ __connman_dhcp_stop(ipconfig_ipv4);
+ break;
+ }
+ }
+
+ /*
+ * We only set the disconnect state if we were not in idle
+ * or in failure. It does not make sense to go to disconnect
+ * state if we were not connected.
+ */
+ state = __connman_service_ipconfig_get_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ if (state != CONNMAN_SERVICE_STATE_IDLE &&
+ state != CONNMAN_SERVICE_STATE_FAILURE)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_DISCONNECT,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ state = __connman_service_ipconfig_get_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ if (state != CONNMAN_SERVICE_STATE_IDLE &&
+ state != CONNMAN_SERVICE_STATE_FAILURE)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_DISCONNECT,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ if (network->connected) {
+ __connman_connection_gateway_remove(service,
+ CONNMAN_IPCONFIG_TYPE_ALL);
+
+ __connman_ipconfig_address_unset(ipconfig_ipv4);
+ __connman_ipconfig_address_unset(ipconfig_ipv6);
+
+ /*
+ * Special handling for IPv6 autoconfigured address.
+ * The simplest way to remove autoconfigured routes is to
+ * disable IPv6 temporarily so that kernel will do the cleanup
+ * automagically.
+ */
+ if (ipv6_method == CONNMAN_IPCONFIG_METHOD_AUTO) {
+ __connman_ipconfig_disable_ipv6(ipconfig_ipv6);
+ __connman_ipconfig_enable_ipv6(ipconfig_ipv6);
+ }
+ }
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_IDLE,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_IDLE,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ network->connecting = false;
+ network->connected = false;
+
+ connman_network_set_associating(network, false);
+}
+
+
+
+static int network_probe(struct connman_network *network)
+{
+ GSList *list;
+ struct connman_network_driver *driver = NULL;
+
+ DBG("network %p name %s", network, network->name);
+
+ if (network->driver)
+ return -EALREADY;
+
+ for (list = driver_list; list; list = list->next) {
+ driver = list->data;
+
+ if (!match_driver(network, driver)) {
+ driver = NULL;
+ continue;
+ }
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (driver->probe(network) == 0)
+ break;
+
+ driver = NULL;
+ }
+
+ if (!driver)
+ return -ENODEV;
+
+ if (!network->group)
+ return -EINVAL;
+
+ switch (network->type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ return 0;
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ network->driver = driver;
+ if (!__connman_service_create_from_network(network)) {
+ network->driver = NULL;
+ return -EINVAL;
+ }
+ }
+
+ return 0;
+}
+
+static void network_remove(struct connman_network *network)
+{
+ DBG("network %p name %s", network, network->name);
+
+ if (!network->driver)
+ return;
+
+ if (network->connected)
+ set_disconnected(network);
+
+ switch (network->type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ break;
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ if (network->group) {
+ __connman_service_remove_from_network(network);
+
+ g_free(network->group);
+ network->group = NULL;
+ }
+ break;
+ }
+
+ if (network->driver->remove)
+ network->driver->remove(network);
+
+ network->driver = NULL;
+}
+
+static void network_change(struct connman_network *network)
+{
+ DBG("network %p name %s", network, network->name);
+
+ if (!network->connected)
+ return;
+
+ connman_device_set_disconnected(network->device, true);
+
+ if (network->driver && network->driver->disconnect) {
+ network->driver->disconnect(network, FALSE);
+ return;
+ }
+
+ network->connected = false;
+}
+
+static void probe_driver(struct connman_network_driver *driver)
+{
+ GSList *list;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ for (list = network_list; list; list = list->next) {
+ struct connman_network *network = list->data;
+
+ if (network->driver)
+ continue;
+
+ if (driver->type != network->type)
+ continue;
+
+ if (driver->probe(network) < 0)
+ continue;
+
+ network->driver = driver;
+ }
+}
+
+static void remove_driver(struct connman_network_driver *driver)
+{
+ GSList *list;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ for (list = network_list; list; list = list->next) {
+ struct connman_network *network = list->data;
+
+ if (network->driver == driver)
+ network_remove(network);
+ }
+}
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_network_driver *driver1 = a;
+ const struct connman_network_driver *driver2 = b;
+
+ return driver2->priority - driver1->priority;
+}
+
+int connman_network_set_connectable(struct connman_network *network, bool connectable)
+{
+ network->connectable = connectable;
+ return 0;
+}
+
+bool connman_network_get_connectable(struct connman_network *network)
+{
+ return network->connectable;
+}
+
+/**
+ * connman_network_driver_register:
+ * @driver: network driver definition
+ *
+ * Register a new network driver
+ *
+ * Returns: %0 on success
+ */
+int connman_network_driver_register(struct connman_network_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+
+ probe_driver(driver);
+
+ return 0;
+}
+
+/**
+ * connman_network_driver_unregister:
+ * @driver: network driver definition
+ *
+ * Remove a previously registered network driver
+ */
+void connman_network_driver_unregister(struct connman_network_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_remove(driver_list, driver);
+
+ remove_driver(driver);
+}
+
+static void network_destruct(struct connman_network *network)
+{
+ DBG("network %p name %s", network, network->name);
+
+ g_free(network->wifi.ssid);
+ g_free(network->wifi.mode);
+ g_free(network->wifi.security);
+ g_free(network->wifi.passphrase);
+ g_free(network->wifi.eap);
+ g_free(network->wifi.identity);
+ g_free(network->wifi.agent_identity);
+ g_free(network->wifi.ca_cert_path);
+ g_free(network->wifi.client_cert_path);
+ g_free(network->wifi.private_key_path);
+ g_free(network->wifi.private_key_passphrase);
+ g_free(network->wifi.phase2_auth);
+ g_free(network->wifi.pin_wps);
+
+ g_free(network->path);
+ g_free(network->group);
+ g_free(network->node);
+ g_free(network->name);
+ g_free(network->identifier);
+
+ network->device = NULL;
+
+ g_free(network);
+}
+
+/**
+ * connman_network_create:
+ * @identifier: network identifier (for example an unqiue name)
+ *
+ * Allocate a new network and assign the #identifier to it.
+ *
+ * Returns: a newly-allocated #connman_network structure
+ */
+struct connman_network *connman_network_create(const char *identifier,
+ enum connman_network_type type)
+{
+ struct connman_network *network;
+ char *ident;
+
+ DBG("identifier %s type %d", identifier, type);
+
+ network = g_try_new0(struct connman_network, 1);
+ if (!network)
+ return NULL;
+
+ DBG("network %p", network);
+
+ network->refcount = 1;
+
+ ident = g_strdup(identifier);
+
+ if (!ident) {
+ g_free(network);
+ return NULL;
+ }
+
+ network->type = type;
+ network->identifier = ident;
+
+ network_list = g_slist_prepend(network_list, network);
+
+ return network;
+}
+
+/**
+ * connman_network_ref:
+ * @network: network structure
+ *
+ * Increase reference counter of network
+ */
+struct connman_network *
+connman_network_ref_debug(struct connman_network *network,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
+ network->refcount + 1, file, line, caller);
+
+ __sync_fetch_and_add(&network->refcount, 1);
+
+ return network;
+}
+
+/**
+ * connman_network_unref:
+ * @network: network structure
+ *
+ * Decrease reference counter of network
+ */
+void connman_network_unref_debug(struct connman_network *network,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p name %s ref %d by %s:%d:%s()", network, network->name,
+ network->refcount - 1, file, line, caller);
+
+ if (__sync_fetch_and_sub(&network->refcount, 1) != 1)
+ return;
+
+ network_list = g_slist_remove(network_list, network);
+
+ network_destruct(network);
+}
+
+const char *__connman_network_get_type(struct connman_network *network)
+{
+ return type2string(network->type);
+}
+
+/**
+ * connman_network_get_type:
+ * @network: network structure
+ *
+ * Get type of network
+ */
+enum connman_network_type connman_network_get_type(
+ struct connman_network *network)
+{
+ return network->type;
+}
+
+/**
+ * connman_network_get_identifier:
+ * @network: network structure
+ *
+ * Get identifier of network
+ */
+const char *connman_network_get_identifier(struct connman_network *network)
+{
+ return network->identifier;
+}
+
+/**
+ * connman_network_set_index:
+ * @network: network structure
+ * @index: index number
+ *
+ * Set index number of network
+ */
+void connman_network_set_index(struct connman_network *network, int index)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ goto done;
+
+ ipconfig = __connman_service_get_ip4config(service);
+ if (ipconfig) {
+ /* If index changed, the index of ipconfig must be reset. */
+ __connman_ipconfig_set_index(ipconfig, index);
+ DBG("index %d service %p ip4config %p", network->index,
+ service, ipconfig);
+ }
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (ipconfig) {
+ __connman_ipconfig_set_index(ipconfig, index);
+
+ DBG("index %d service %p ip6config %p", network->index,
+ service, ipconfig);
+ }
+
+done:
+ network->index = index;
+}
+
+/**
+ * connman_network_get_index:
+ * @network: network structure
+ *
+ * Get index number of network
+ */
+int connman_network_get_index(struct connman_network *network)
+{
+ return network->index;
+}
+
+/**
+ * connman_network_set_group:
+ * @network: network structure
+ * @group: group name
+ *
+ * Set group name for automatic clustering
+ */
+void connman_network_set_group(struct connman_network *network,
+ const char *group)
+{
+ switch (network->type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ return;
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ break;
+ }
+
+ if (g_strcmp0(network->group, group) == 0) {
+ if (group)
+ __connman_service_update_from_network(network);
+ return;
+ }
+
+ if (network->group) {
+ __connman_service_remove_from_network(network);
+
+ g_free(network->group);
+ }
+
+ network->group = g_strdup(group);
+
+ if (network->group)
+ network_probe(network);
+}
+
+/**
+ * connman_network_get_group:
+ * @network: network structure
+ *
+ * Get group name for automatic clustering
+ */
+const char *connman_network_get_group(struct connman_network *network)
+{
+ return network->group;
+}
+
+const char *__connman_network_get_ident(struct connman_network *network)
+{
+ if (!network->device)
+ return NULL;
+
+ return connman_device_get_ident(network->device);
+}
+
+bool __connman_network_get_weakness(struct connman_network *network)
+{
+ switch (network->type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ break;
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ if (network->strength > 0 && network->strength < 20)
+ return true;
+ break;
+ }
+
+ return false;
+}
+
+bool connman_network_get_connecting(struct connman_network *network)
+{
+ return network->connecting;
+}
+
+/**
+ * connman_network_set_available:
+ * @network: network structure
+ * @available: availability state
+ *
+ * Change availability state of network (in range)
+ */
+int connman_network_set_available(struct connman_network *network,
+ bool available)
+{
+ DBG("network %p available %d", network, available);
+
+ if (network->available == available)
+ return -EALREADY;
+
+ network->available = available;
+
+ return 0;
+}
+
+/**
+ * connman_network_get_available:
+ * @network: network structure
+ *
+ * Get network available setting
+ */
+bool connman_network_get_available(struct connman_network *network)
+{
+ return network->available;
+}
+
+/**
+ * connman_network_set_associating:
+ * @network: network structure
+ * @associating: associating state
+ *
+ * Change associating state of network
+ */
+int connman_network_set_associating(struct connman_network *network,
+ bool associating)
+{
+ DBG("network %p associating %d", network, associating);
+
+ if (network->associating == associating)
+ return -EALREADY;
+
+ network->associating = associating;
+
+ if (associating) {
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_ASSOCIATION,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_ASSOCIATION,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ }
+
+ return 0;
+}
+
+static void set_associate_error(struct connman_network *network)
+{
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ __connman_service_indicate_error(service,
+ CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
+}
+
+static void set_configure_error(struct connman_network *network)
+{
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ __connman_service_indicate_error(service,
+ CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
+}
+
+static void set_invalid_key_error(struct connman_network *network)
+{
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ __connman_service_indicate_error(service,
+ CONNMAN_SERVICE_ERROR_INVALID_KEY);
+}
+
+static void set_connect_error(struct connman_network *network)
+{
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ __connman_service_indicate_error(service,
+ CONNMAN_SERVICE_ERROR_CONNECT_FAILED);
+}
+
+void connman_network_set_ipv4_method(struct connman_network *network,
+ enum connman_ipconfig_method method)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return;
+
+ ipconfig = __connman_service_get_ip4config(service);
+ if (!ipconfig)
+ return;
+
+ __connman_ipconfig_set_method(ipconfig, method);
+}
+
+void connman_network_set_ipv6_method(struct connman_network *network,
+ enum connman_ipconfig_method method)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return;
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (!ipconfig)
+ return;
+
+ __connman_ipconfig_set_method(ipconfig, method);
+}
+
+void connman_network_set_error(struct connman_network *network,
+ enum connman_network_error error)
+{
+ DBG("network %p error %d", network, error);
+
+ network->connecting = false;
+ network->associating = false;
+
+ switch (error) {
+ case CONNMAN_NETWORK_ERROR_UNKNOWN:
+ return;
+ case CONNMAN_NETWORK_ERROR_ASSOCIATE_FAIL:
+ set_associate_error(network);
+ break;
+ case CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL:
+ set_configure_error(network);
+ break;
+ case CONNMAN_NETWORK_ERROR_INVALID_KEY:
+ set_invalid_key_error(network);
+ break;
+ case CONNMAN_NETWORK_ERROR_CONNECT_FAIL:
+ set_connect_error(network);
+ break;
+ }
+
+ network_change(network);
+}
+
+/**
+ * connman_network_set_connected:
+ * @network: network structure
+ * @connected: connected state
+ *
+ * Change connected state of network
+ */
+int connman_network_set_connected(struct connman_network *network,
+ bool connected)
+{
+ DBG("network %p connected %d/%d connecting %d associating %d",
+ network, network->connected, connected, network->connecting,
+ network->associating);
+
+ if ((network->connecting || network->associating) &&
+ !connected) {
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_CONNECT_FAIL);
+ if (__connman_network_disconnect(network, FALSE) == 0)
+ return 0;
+ }
+
+ if (network->connected == connected)
+ return -EALREADY;
+
+ if (!connected)
+ set_disconnected(network);
+ else
+ set_connected(network);
+
+ return 0;
+}
+
+/**
+ * connman_network_get_connected:
+ * @network: network structure
+ *
+ * Get network connection status
+ */
+bool connman_network_get_connected(struct connman_network *network)
+{
+ return network->connected;
+}
+
+/**
+ * connman_network_get_associating:
+ * @network: network structure
+ *
+ * Get network associating status
+ */
+bool connman_network_get_associating(struct connman_network *network)
+{
+ return network->associating;
+}
+
+void connman_network_clear_hidden(void *user_data)
+{
+ if (!user_data)
+ return;
+
+ DBG("user_data %p", user_data);
+
+ /*
+ * Hidden service does not have a connect timeout so
+ * we do not need to remove it. We can just return
+ * error to the caller telling that we could not find
+ * any network that we could connect to.
+ */
+ connman_dbus_reply_pending(user_data, EIO, NULL);
+}
+
+int connman_network_connect_hidden(struct connman_network *network,
+ char *identity, char *passphrase, void *user_data)
+{
+ int err = 0;
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ DBG("network %p service %p user_data %p", network, service, user_data);
+
+ if (!service)
+ return -EINVAL;
+
+ if (identity)
+ __connman_service_set_agent_identity(service, identity);
+
+ if (passphrase)
+ err = __connman_service_set_passphrase(service, passphrase);
+
+ if (err == -ENOKEY) {
+ __connman_service_indicate_error(service,
+ CONNMAN_SERVICE_ERROR_INVALID_KEY);
+ goto out;
+ } else {
+ __connman_service_set_hidden(service);
+ __connman_service_set_hidden_data(service, user_data);
+ return __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_USER);
+ }
+
+out:
+ __connman_service_return_error(service, -err, user_data);
+ return err;
+}
+
+/**
+ * __connman_network_connect:
+ * @network: network structure
+ *
+ * Connect network
+ */
+int __connman_network_connect(struct connman_network *network)
+{
+ int err;
+
+ DBG("network %p", network);
+
+ if (network->connected)
+ return -EISCONN;
+
+ if (network->connecting || network->associating)
+ return -EALREADY;
+
+ if (!network->driver) {
+ DBG("network %p assert network->driver == NULL", network);
+ return -EUNATCH;
+ }
+
+ if (!network->driver->connect)
+ return -ENOSYS;
+
+ if (!network->device) {
+ DBG("network %p assert network->device == NULL", network);
+ return -ENODEV;
+ }
+
+ network->connecting = true;
+
+ __connman_device_disconnect(network->device);
+
+ connman_info("Requesting connection to network \"%s\" "
+ "identifier \"%s\".", network->name, network->identifier);
+
+ err = network->driver->connect(network);
+ if (err < 0) {
+ if (err == -EINPROGRESS)
+ connman_network_set_associating(network, true);
+ else
+ network->connecting = false;
+
+ return err;
+ }
+
+ set_connected(network);
+
+ return err;
+}
+
+int
+connman_network_needs_input(struct connman_network *network)
+{
+ struct connman_service *service;
+ int err = -EINVAL;
+
+ if(!network->connecting && !network->associating)
+ goto bail;
+
+ service = connman_service_lookup_from_network(network);
+ if (service == NULL)
+ goto bail;
+
+ network->connecting = FALSE;
+ network->associating = FALSE;
+
+ err = __connman_service_needs_input(service);
+
+bail:
+ return err;
+}
+
+
+/**
+ * __connman_network_disconnect:
+ * @network: network structure
+ *
+ * Disconnect network
+ */
+int __connman_network_disconnect(struct connman_network *network, bool user_initiated)
+{
+ int err = 0;
+
+ DBG("network %p", network);
+
+ if (!network->connected && !network->connecting &&
+ !network->associating)
+ return -ENOTCONN;
+
+ if (!network->driver)
+ return -EUNATCH;
+
+ network->connecting = false;
+
+ if (network->driver->disconnect)
+ err = network->driver->disconnect(network, user_initiated);
+
+ connman_info("Requesting disconnection from network \"%s\" "
+ "identifier \"%s\".", network->name, network->identifier);
+
+ if (err != -EINPROGRESS)
+ set_disconnected(network);
+
+ return err;
+}
+
+int __connman_network_clear_ipconfig(struct connman_network *network,
+ struct connman_ipconfig *ipconfig)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig_ipv4;
+ enum connman_ipconfig_method method;
+ enum connman_ipconfig_type type;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+ method = __connman_ipconfig_get_method(ipconfig);
+ type = __connman_ipconfig_get_config_type(ipconfig);
+
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ return -EINVAL;
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ release_dhcpv6(network);
+ break;
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ __connman_ipconfig_address_remove(ipconfig);
+ break;
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ __connman_dhcp_stop(ipconfig_ipv4);
+ break;
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_CONFIGURATION,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_CONFIGURATION,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ return 0;
+}
+
+int __connman_network_enable_ipconfig(struct connman_network *network,
+ struct connman_ipconfig *ipconfig)
+{
+ int r = 0;
+ enum connman_ipconfig_type type;
+ enum connman_ipconfig_method method;
+
+ if (!network || !ipconfig)
+ return -EINVAL;
+
+ type = __connman_ipconfig_get_config_type(ipconfig);
+
+ switch (type) {
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ return -ENOSYS;
+
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ set_configuration(network, type);
+
+ method = __connman_ipconfig_get_method(ipconfig);
+
+ DBG("ipv6 ipconfig method %d", method);
+
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ __connman_ipconfig_disable_ipv6(ipconfig);
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ autoconf_ipv6_set(network);
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ r = manual_ipv6_set(network, ipconfig);
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ r = -ENOSYS;
+ break;
+ }
+
+ break;
+
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ set_configuration(network, type);
+
+ method = __connman_ipconfig_get_method(ipconfig);
+
+ DBG("ipv4 ipconfig method %d", method);
+
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ r = -ENOSYS;
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ r = set_connected_manual(network);
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ r = set_connected_dhcp(network);
+ break;
+ }
+
+ break;
+ }
+
+ if (r < 0)
+ connman_network_set_error(network,
+ CONNMAN_NETWORK_ERROR_CONFIGURE_FAIL);
+
+ return r;
+}
+
+int connman_network_set_ipaddress(struct connman_network *network,
+ struct connman_ipaddress *ipaddress)
+{
+ struct connman_service *service;
+ struct connman_ipconfig *ipconfig = NULL;
+
+ DBG("network %p", network);
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+
+ ipconfig = __connman_service_get_ipconfig(service, ipaddress->family);
+ if (!ipconfig)
+ return -EINVAL;
+
+ __connman_ipconfig_set_local(ipconfig, ipaddress->local);
+ __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
+ __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
+ __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
+ __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
+
+ return 0;
+}
+
+int connman_network_set_nameservers(struct connman_network *network,
+ const char *nameservers)
+{
+ struct connman_service *service;
+ char **nameservers_array;
+ int i;
+
+ DBG("network %p nameservers %s", network, nameservers);
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+
+ __connman_service_nameserver_clear(service);
+
+ if (!nameservers)
+ return 0;
+
+ nameservers_array = g_strsplit(nameservers, " ", 0);
+
+ for (i = 0; nameservers_array[i]; i++) {
+ __connman_service_nameserver_append(service,
+ nameservers_array[i], false);
+ }
+
+ g_strfreev(nameservers_array);
+
+ return 0;
+}
+
+int connman_network_set_domain(struct connman_network *network,
+ const char *domain)
+{
+ struct connman_service *service;
+
+ DBG("network %p domain %s", network, domain);
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return -EINVAL;
+
+ __connman_service_set_domainname(service, domain);
+
+ return 0;
+}
+
+/**
+ * connman_network_set_name:
+ * @network: network structure
+ * @name: name value
+ *
+ * Set display name value for network
+ */
+int connman_network_set_name(struct connman_network *network,
+ const char *name)
+{
+ DBG("network %p name %s", network, name);
+
+ g_free(network->name);
+ network->name = g_strdup(name);
+
+ return 0;
+}
+
+/**
+ * connman_network_set_strength:
+ * @network: network structure
+ * @strength: strength value
+ *
+ * Set signal strength value for network
+ */
+
+int connman_network_set_strength(struct connman_network *network,
+ uint8_t strength)
+{
+ DBG("network %p strengh %d", network, strength);
+
+ network->strength = strength;
+
+ return 0;
+}
+
+uint8_t connman_network_get_strength(struct connman_network *network)
+{
+ return network->strength;
+}
+
+int connman_network_set_frequency(struct connman_network *network,
+ uint16_t frequency)
+{
+ DBG("network %p frequency %d", network, frequency);
+
+ network->frequency = frequency;
+
+ return 0;
+}
+
+uint16_t connman_network_get_frequency(struct connman_network *network)
+{
+ return network->frequency;
+}
+
+int connman_network_set_wifi_channel(struct connman_network *network,
+ uint16_t channel)
+{
+ DBG("network %p wifi channel %d", network, channel);
+
+ network->wifi.channel = channel;
+
+ return 0;
+}
+
+uint16_t connman_network_get_wifi_channel(struct connman_network *network)
+{
+ return network->wifi.channel;
+}
+
+int connman_network_set_lowpan_xpan_id(struct connman_network *network, uint64_t xpan_id)
+{
+ DBG("network %p lowpan xpan ID 0x%016llX", network, xpan_id);
+
+ network->lowpan.xpan_id = xpan_id;
+
+ return 0;
+}
+
+uint64_t connman_network_get_lowpan_xpan_id(struct connman_network *network)
+{
+ return network->lowpan.xpan_id;
+}
+/**
+ * connman_network_set_string:
+ * @network: network structure
+ * @key: unique identifier
+ * @value: string value
+ *
+ * Set string value for specific key
+ */
+int connman_network_set_string(struct connman_network *network,
+ const char *key, const char *value)
+{
+ DBG("network %p key %s value %s", network, key, value);
+
+ if (g_strcmp0(key, "Name") == 0)
+ return connman_network_set_name(network, value);
+
+ if (g_str_equal(key, "Path")) {
+ g_free(network->path);
+ network->path = g_strdup(value);
+ } else if (g_str_equal(key, "Node")) {
+ g_free(network->node);
+ network->node = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.Mode")) {
+ g_free(network->wifi.mode);
+ network->wifi.mode = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.Security")) {
+ g_free(network->wifi.security);
+ network->wifi.security = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.Passphrase")) {
+ g_free(network->wifi.passphrase);
+ network->wifi.passphrase = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.EAP")) {
+ g_free(network->wifi.eap);
+ network->wifi.eap = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.Identity")) {
+ g_free(network->wifi.identity);
+ network->wifi.identity = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.AgentIdentity")) {
+ g_free(network->wifi.agent_identity);
+ network->wifi.agent_identity = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.CACertFile")) {
+ g_free(network->wifi.ca_cert_path);
+ network->wifi.ca_cert_path = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.ClientCertFile")) {
+ g_free(network->wifi.client_cert_path);
+ network->wifi.client_cert_path = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.PrivateKeyFile")) {
+ g_free(network->wifi.private_key_path);
+ network->wifi.private_key_path = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase")) {
+ g_free(network->wifi.private_key_passphrase);
+ network->wifi.private_key_passphrase = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.Phase2")) {
+ g_free(network->wifi.phase2_auth);
+ network->wifi.phase2_auth = g_strdup(value);
+ } else if (g_str_equal(key, "WiFi.PinWPS")) {
+ g_free(network->wifi.pin_wps);
+ network->wifi.pin_wps = g_strdup(value);
+ } else if (g_str_equal(key, "LoWPAN.ParentAddress")) {
+ g_free(network->lowpan.parent_address);
+ network->lowpan.parent_address = g_strdup(value);
+ } else {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * connman_network_get_string:
+ * @network: network structure
+ * @key: unique identifier
+ *
+ * Get string value for specific key
+ */
+const char *connman_network_get_string(struct connman_network *network,
+ const char *key)
+{
+ DBG("network %p key %s", network, key);
+
+ if (g_str_equal(key, "Path"))
+ return network->path;
+ else if (g_str_equal(key, "Name"))
+ return network->name;
+ else if (g_str_equal(key, "Node"))
+ return network->node;
+ else if (g_str_equal(key, "WiFi.Mode"))
+ return network->wifi.mode;
+ else if (g_str_equal(key, "WiFi.Security"))
+ return network->wifi.security;
+ else if (g_str_equal(key, "WiFi.Passphrase"))
+ return network->wifi.passphrase;
+ else if (g_str_equal(key, "WiFi.EAP"))
+ return network->wifi.eap;
+ else if (g_str_equal(key, "WiFi.Identity"))
+ return network->wifi.identity;
+ else if (g_str_equal(key, "WiFi.AgentIdentity"))
+ return network->wifi.agent_identity;
+ else if (g_str_equal(key, "WiFi.CACertFile"))
+ return network->wifi.ca_cert_path;
+ else if (g_str_equal(key, "WiFi.ClientCertFile"))
+ return network->wifi.client_cert_path;
+ else if (g_str_equal(key, "WiFi.PrivateKeyFile"))
+ return network->wifi.private_key_path;
+ else if (g_str_equal(key, "WiFi.PrivateKeyPassphrase"))
+ return network->wifi.private_key_passphrase;
+ else if (g_str_equal(key, "WiFi.Phase2"))
+ return network->wifi.phase2_auth;
+ else if (g_str_equal(key, "WiFi.PinWPS"))
+ return network->wifi.pin_wps;
+ else if (g_str_equal(key, "LoWPAN.ParentAddress"))
+ return network->lowpan.parent_address;
+
+ return NULL;
+}
+
+/**
+ * connman_network_set_bool:
+ * @network: network structure
+ * @key: unique identifier
+ * @value: boolean value
+ *
+ * Set boolean value for specific key
+ */
+int connman_network_set_bool(struct connman_network *network,
+ const char *key, bool value)
+{
+ DBG("network %p key %s value %d", network, key, value);
+
+ if (g_strcmp0(key, "Roaming") == 0)
+ network->roaming = value;
+ else if (g_strcmp0(key, "WiFi.WPS") == 0)
+ network->wifi.wps = value;
+ else if (g_strcmp0(key, "WiFi.UseWPS") == 0)
+ network->wifi.use_wps = value;
+ else if (g_strcmp0(key, "LoWPAN.PermitJoining") == 0)
+ network->lowpan.joining_permitted = value;
+
+ return -EINVAL;
+}
+
+/**
+ * connman_network_get_bool:
+ * @network: network structure
+ * @key: unique identifier
+ *
+ * Get boolean value for specific key
+ */
+bool connman_network_get_bool(struct connman_network *network,
+ const char *key)
+{
+ DBG("network %p key %s", network, key);
+
+ if (g_str_equal(key, "Roaming"))
+ return network->roaming;
+ else if (g_str_equal(key, "WiFi.WPS"))
+ return network->wifi.wps;
+ else if (g_str_equal(key, "WiFi.UseWPS"))
+ return network->wifi.use_wps;
+ else if (g_str_equal(key, "LoWPAN.PermitJoining") == TRUE)
+ return network->lowpan.joining_permitted;
+
+ return false;
+}
+
+/**
+ * connman_network_set_blob:
+ * @network: network structure
+ * @key: unique identifier
+ * @data: blob data
+ * @size: blob size
+ *
+ * Set binary blob value for specific key
+ */
+int connman_network_set_blob(struct connman_network *network,
+ const char *key, const void *data, unsigned int size)
+{
+ DBG("network %p key %s size %d", network, key, size);
+
+ if (g_str_equal(key, "WiFi.SSID")) {
+ g_free(network->wifi.ssid);
+ network->wifi.ssid = g_try_malloc(size);
+ if (network->wifi.ssid) {
+ memcpy(network->wifi.ssid, data, size);
+ network->wifi.ssid_len = size;
+ } else
+ network->wifi.ssid_len = 0;
+ } else {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+/**
+ * connman_network_get_blob:
+ * @network: network structure
+ * @key: unique identifier
+ * @size: pointer to blob size
+ *
+ * Get binary blob value for specific key
+ */
+const void *connman_network_get_blob(struct connman_network *network,
+ const char *key, unsigned int *size)
+{
+ DBG("network %p key %s", network, key);
+
+ if (g_str_equal(key, "WiFi.SSID")) {
+ if (size)
+ *size = network->wifi.ssid_len;
+ return network->wifi.ssid;
+ }
+
+ return NULL;
+}
+
+void __connman_network_set_device(struct connman_network *network,
+ struct connman_device *device)
+{
+ if (network->device == device)
+ return;
+
+ if (network->device)
+ network_remove(network);
+
+ network->device = device;
+
+ if (network->device)
+ network_probe(network);
+}
+
+/**
+ * connman_network_get_device:
+ * @network: network structure
+ *
+ * Get parent device of network
+ */
+struct connman_device *connman_network_get_device(struct connman_network *network)
+{
+ return network->device;
+}
+
+/**
+ * connman_network_get_data:
+ * @network: network structure
+ *
+ * Get private network data pointer
+ */
+void *connman_network_get_data(struct connman_network *network)
+{
+ return network->driver_data;
+}
+
+/**
+ * connman_network_set_data:
+ * @network: network structure
+ * @data: data pointer
+ *
+ * Set private network data pointer
+ */
+void connman_network_set_data(struct connman_network *network, void *data)
+{
+ network->driver_data = data;
+}
+
+void connman_network_update(struct connman_network *network)
+{
+ DBG("");
+ switch (network->type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ return;
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ break;
+ }
+
+ if (network->group)
+ __connman_service_update_from_network(network);
+}
+
+int __connman_network_init(void)
+{
+ DBG("");
+
+ return 0;
+}
+
+void __connman_network_cleanup(void)
+{
+ DBG("");
+}
diff --git a/src/notifier.c b/src/notifier.c
new file mode 100644
index 0000000..9ddd987
--- /dev/null
+++ b/src/notifier.c
@@ -0,0 +1,408 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+static DBusConnection *connection = NULL;
+
+static GSList *notifier_list = NULL;
+static GHashTable *service_hash = NULL;
+
+static const char *notifier_state;
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_notifier *notifier1 = a;
+ const struct connman_notifier *notifier2 = b;
+
+ return notifier2->priority - notifier1->priority;
+}
+
+/**
+ * connman_notifier_register:
+ * @notifier: notifier module
+ *
+ * Register a new notifier module
+ *
+ * Returns: %0 on success
+ */
+int connman_notifier_register(struct connman_notifier *notifier)
+{
+ DBG("notifier %p name %s", notifier, notifier->name);
+
+ notifier_list = g_slist_insert_sorted(notifier_list, notifier,
+ compare_priority);
+
+ return 0;
+}
+
+/**
+ * connman_notifier_unregister:
+ * @notifier: notifier module
+ *
+ * Remove a previously registered notifier module
+ */
+void connman_notifier_unregister(struct connman_notifier *notifier)
+{
+ DBG("notifier %p name %s", notifier, notifier->name);
+
+ notifier_list = g_slist_remove(notifier_list, notifier);
+}
+
+static int connected[MAX_CONNMAN_SERVICE_TYPES];
+static int online[MAX_CONNMAN_SERVICE_TYPES];
+
+static bool notifier_is_online(void)
+{
+ unsigned int i;
+
+ __sync_synchronize();
+ for (i = 0; i < MAX_CONNMAN_SERVICE_TYPES; i++) {
+ if (online[i] > 0)
+ return true;
+ }
+
+ return false;
+}
+
+bool __connman_notifier_is_connected(void)
+{
+ unsigned int i;
+
+ __sync_synchronize();
+ for (i = 0; i < MAX_CONNMAN_SERVICE_TYPES; i++) {
+ if (connected[i] > 0)
+ return true;
+ }
+
+ return false;
+}
+
+static const char *evaluate_notifier_state(void)
+{
+ if (notifier_is_online())
+ return "online";
+
+ if (__connman_notifier_is_connected())
+ return "ready";
+
+ if (__connman_technology_get_offlinemode())
+ return "offline";
+
+ return "idle";
+}
+
+const char *__connman_notifier_get_state(void)
+{
+ return notifier_state;
+}
+
+static void state_changed(void)
+{
+ const char *state;
+
+ state = evaluate_notifier_state();
+
+ if (g_strcmp0(state, notifier_state) == 0)
+ return;
+
+ notifier_state = state;
+
+ connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "State",
+ DBUS_TYPE_STRING, ¬ifier_state);
+}
+
+void __connman_notifier_connect(enum connman_service_type type)
+{
+ DBG("type %d", type);
+
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ return;
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ }
+
+ if (__sync_fetch_and_add(&connected[type], 1) == 0) {
+ __connman_technology_set_connected(type, true);
+ state_changed();
+ }
+}
+
+void __connman_notifier_enter_online(enum connman_service_type type)
+{
+ DBG("type %d", type);
+
+ if (__sync_fetch_and_add(&online[type], 1) == 0)
+ state_changed();
+}
+
+void __connman_notifier_leave_online(enum connman_service_type type)
+{
+ DBG("type %d", type);
+
+ if (__sync_fetch_and_sub(&online[type], 1) == 1)
+ state_changed();
+}
+
+void __connman_notifier_disconnect(enum connman_service_type type)
+{
+ DBG("type %d", type);
+
+ __sync_synchronize();
+ if (connected[type] == 0) {
+ connman_error("notifier disconnect underflow");
+ return;
+ }
+
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ return;
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ }
+
+ if (__sync_fetch_and_sub(&connected[type], 1) != 1)
+ return;
+
+ __connman_technology_set_connected(type, false);
+ state_changed();
+}
+
+void __connman_notifier_default_changed(struct connman_service *service)
+{
+ GSList *list;
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->default_changed)
+ notifier->default_changed(service);
+ }
+}
+
+void __connman_notifier_service_add(struct connman_service *service,
+ const char *name)
+{
+ GSList *list;
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->service_add)
+ notifier->service_add(service, name);
+ }
+}
+
+void __connman_notifier_service_remove(struct connman_service *service)
+{
+ GSList *list;
+
+ if (g_hash_table_lookup(service_hash, service)) {
+ /*
+ * This is a tempory check for consistency. It can be
+ * removed when there are no reports for the following
+ * error message.
+ */
+ connman_error("Service state machine inconsistency detected.");
+
+ g_hash_table_remove(service_hash, service);
+ }
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->service_remove)
+ notifier->service_remove(service);
+ }
+}
+
+void __connman_notifier_proxy_changed(struct connman_service *service)
+{
+ GSList *list;
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->proxy_changed)
+ notifier->proxy_changed(service);
+ }
+}
+
+static void offlinemode_changed(dbus_bool_t enabled)
+{
+ DBG("enabled %d", enabled);
+
+ connman_dbus_property_changed_basic(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "OfflineMode",
+ DBUS_TYPE_BOOLEAN, &enabled);
+}
+
+void __connman_notifier_offlinemode(bool enabled)
+{
+ GSList *list;
+
+ DBG("enabled %d", enabled);
+
+ offlinemode_changed(enabled);
+ state_changed();
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->offline_mode)
+ notifier->offline_mode(enabled);
+ }
+}
+
+static void notify_idle_state(bool idle)
+{
+ GSList *list;
+
+ DBG("idle %d", idle);
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->idle_state)
+ notifier->idle_state(idle);
+ }
+}
+
+void __connman_notifier_service_state_changed(struct connman_service *service,
+ enum connman_service_state state)
+{
+ GSList *list;
+ unsigned int old_size;
+ bool found;
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->service_state_changed)
+ notifier->service_state_changed(service, state);
+ }
+
+ old_size = g_hash_table_size(service_hash);
+ found = g_hash_table_lookup(service_hash, service);
+
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ if (!found)
+ break;
+
+ g_hash_table_remove(service_hash, service);
+ if (old_size == 1)
+ notify_idle_state(true);
+
+ break;
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ if (found)
+ break;
+
+ g_hash_table_insert(service_hash, service, service);
+ if (old_size == 0)
+ notify_idle_state(false);
+
+ break;
+ }
+}
+
+void __connman_notifier_ipconfig_changed(struct connman_service *service,
+ struct connman_ipconfig *ipconfig)
+{
+ GSList *list;
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->ipconfig_changed)
+ notifier->ipconfig_changed(service, ipconfig);
+ }
+}
+
+void __connman_notifier_sleep_event(void *identifier, bool canSleep, time_t valid_until)
+{
+ GSList *list;
+
+ for (list = notifier_list; list; list = list->next) {
+ struct connman_notifier *notifier = list->data;
+
+ if (notifier->sleep_event)
+ notifier->sleep_event(identifier, canSleep, valid_until);
+ }
+}
+
+
+int __connman_notifier_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+
+ service_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, NULL);
+
+ notifier_state = evaluate_notifier_state();
+
+ return 0;
+}
+
+void __connman_notifier_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(service_hash);
+ service_hash = NULL;
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/ntp.c b/src/ntp.c
new file mode 100644
index 0000000..eb2d25b
--- /dev/null
+++ b/src/ntp.c
@@ -0,0 +1,654 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/time.h>
+#include <sys/timex.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+
+#include <glib.h>
+
+#include <gdhcp/timer.h>
+
+#include "connman.h"
+#undef DBG /* temp debug for SAPPHIRE-13875 */
+#define DBG(msg, ...) connman_info("ntp: " msg, ##__VA_ARGS__)
+
+// fail-safe for non-linux builds
+#ifndef CLOCK_BOOTTIME
+#define CLOCK_BOOTTIME CLOCK_REALTIME
+#endif
+
+struct ntp_short {
+ uint16_t seconds;
+ uint16_t fraction;
+} __attribute__ ((packed));
+
+struct ntp_time {
+ uint32_t seconds;
+ uint32_t fraction;
+} __attribute__ ((packed));
+
+struct ntp_msg {
+ uint8_t flags; /* Mode, version and leap indicator */
+ uint8_t stratum; /* Stratum details */
+ int8_t poll; /* Maximum interval in log2 seconds */
+ int8_t precision; /* Clock precision in log2 seconds */
+ struct ntp_short rootdelay; /* Root delay */
+ struct ntp_short rootdisp; /* Root dispersion */
+ uint32_t refid; /* Reference ID */
+ struct ntp_time reftime; /* Reference timestamp */
+ struct ntp_time orgtime; /* Origin timestamp */
+ struct ntp_time rectime; /* Receive timestamp */
+ struct ntp_time xmttime; /* Transmit timestamp */
+} __attribute__ ((packed));
+
+#define OFFSET_1900_1970 2208988800UL /* 1970 - 1900 in seconds */
+
+#define STEPTIME_MIN_OFFSET 0.4
+
+#define LOGTOD(a) ((a) < 0 ? 1. / (1L << -(a)) : 1L << (int)(a))
+#define NSEC_PER_SEC ((uint64_t)1000000000ULL)
+#ifndef ADJ_SETOFFSET
+#define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
+#endif
+
+#define NTP_SEND_TIMEOUT 2
+#define NTP_SEND_RETRIES 3
+
+#define NTP_FLAG_LI_SHIFT 6
+#define NTP_FLAG_LI_MASK 0x3
+#define NTP_FLAG_LI_NOWARNING 0x0
+#define NTP_FLAG_LI_ADDSECOND 0x1
+#define NTP_FLAG_LI_DELSECOND 0x2
+#define NTP_FLAG_LI_NOTINSYNC 0x3
+
+#define NTP_FLAG_VN_SHIFT 3
+#define NTP_FLAG_VN_MASK 0x7
+
+#define NTP_FLAG_MD_SHIFT 0
+#define NTP_FLAG_MD_MASK 0x7
+#define NTP_FLAG_MD_UNSPEC 0
+#define NTP_FLAG_MD_ACTIVE 1
+#define NTP_FLAG_MD_PASSIVE 2
+#define NTP_FLAG_MD_CLIENT 3
+#define NTP_FLAG_MD_SERVER 4
+#define NTP_FLAG_MD_BROADCAST 5
+#define NTP_FLAG_MD_CONTROL 6
+#define NTP_FLAG_MD_PRIVATE 7
+
+#define NTP_FLAG_VN_VER3 3
+#define NTP_FLAG_VN_VER4 4
+
+#define NTP_FLAGS_ENCODE(li, vn, md) ((uint8_t)( \
+ (((li) & NTP_FLAG_LI_MASK) << NTP_FLAG_LI_SHIFT) | \
+ (((vn) & NTP_FLAG_VN_MASK) << NTP_FLAG_VN_SHIFT) | \
+ (((md) & NTP_FLAG_MD_MASK) << NTP_FLAG_MD_SHIFT)))
+
+#define NTP_FLAGS_LI_DECODE(flags) ((uint8_t)(((flags) >> NTP_FLAG_LI_SHIFT) & NTP_FLAG_LI_MASK))
+#define NTP_FLAGS_VN_DECODE(flags) ((uint8_t)(((flags) >> NTP_FLAG_VN_SHIFT) & NTP_FLAG_VN_MASK))
+#define NTP_FLAGS_MD_DECODE(flags) ((uint8_t)(((flags) >> NTP_FLAG_MD_SHIFT) & NTP_FLAG_MD_MASK))
+
+#define NTP_PRECISION_S 0
+#define NTP_PRECISION_DS -3
+#define NTP_PRECISION_CS -6
+#define NTP_PRECISION_MS -9
+#define NTP_PRECISION_US -19
+#define NTP_PRECISION_NS -29
+
+#define NTP_MINPOLL 4 /* 2^4 = 16 seconds */
+#define NTP_MAXPOLL 17 /* 2^17 = 36.4 hours */
+#define NTP_MINPOLL_DEFAULT 6 /* 2^6 = 64 seconds */
+#define NTP_MAXPOLL_DEFAULT 10 /* 2^10 = 1024 seconds */
+
+static guint channel_watch = 0;
+static struct timespec mtx_time;
+static int transmit_fd = 0;
+
+static char *timeserver = NULL;
+static struct sockaddr_storage timeserver_addr;
+static gint poll_id = 0;
+static gint timeout_id = 0;
+static guint retries = 0;
+static bool ntp_can_sleep = true;
+
+static void send_packet(int fd, const char *server, uint32_t timeout, int family);
+
+static void next_server(void)
+{
+ if (timeserver) {
+ g_free(timeserver);
+ timeserver = NULL;
+ }
+
+ __connman_timeserver_sync_next();
+}
+
+static gboolean send_timeout(gpointer user_data)
+{
+ uint32_t timeout = GPOINTER_TO_UINT(user_data);
+
+ DBG("send timeout %u (retries %d)", timeout, retries);
+
+ if (retries++ == NTP_SEND_RETRIES)
+ next_server();
+ else
+ send_packet(transmit_fd, timeserver, timeout << 1, timeserver_addr.ss_family);
+
+ return FALSE;
+}
+
+static void send_packet(int fd, const char *server, uint32_t timeout, int family)
+{
+ struct ntp_msg msg;
+ struct sockaddr_in in4addr;
+ struct sockaddr_in6 in6addr;
+ struct sockaddr * addr;
+ struct timeval transmit_timeval;
+ ssize_t len;
+ int size;
+ unsigned char * addrptr;
+
+ /*
+ * At some point, we could specify the actual system precision with:
+ *
+ * clock_getres(CLOCK_REALTIME, &ts);
+ * msg.precision = (int)log2(ts.tv_sec + (ts.tv_nsec * 1.0e-9));
+ */
+ memset(&msg, 0, sizeof(msg));
+ msg.flags = NTP_FLAGS_ENCODE(NTP_FLAG_LI_NOTINSYNC, NTP_FLAG_VN_VER4,
+ NTP_FLAG_MD_CLIENT);
+ msg.poll = NTP_MAXPOLL_DEFAULT;
+ msg.precision = NTP_PRECISION_S;
+
+ if (family == AF_INET) {
+ memset(&in4addr, 0, sizeof(in4addr));
+ in4addr.sin_family = AF_INET;
+ in4addr.sin_port = htons(123);
+ size = sizeof(in4addr);
+ addrptr = (unsigned char *)&in4addr.sin_addr.s_addr;
+ addr = (struct sockaddr *)&in4addr;
+ } else if (family == AF_INET6){
+ memset(&in6addr, 0, sizeof(in6addr));
+ in6addr.sin6_family = AF_INET6;
+ in6addr.sin6_port = htons(123);
+ size = sizeof(in6addr);
+ addrptr = in6addr.sin6_addr.__in6_u.__u6_addr8;
+ addr = (struct sockaddr *)&in6addr;
+ } else {
+ DBG("wrong family type");
+ return;
+ }
+ if (inet_pton(family, server, addrptr) == 0)
+ {
+ DBG("cannot convert ip address string");
+ return;
+ }
+
+ if (ntp_can_sleep) {
+ ntp_can_sleep = false;
+ __connman_notifier_sleep_event(&ntp_can_sleep, ntp_can_sleep, time(0) + 6 * NTP_SEND_TIMEOUT);
+ }
+
+ gettimeofday(&transmit_timeval, NULL);
+ clock_gettime(CLOCK_MONOTONIC, &mtx_time);
+
+ msg.xmttime.seconds = htonl(transmit_timeval.tv_sec + OFFSET_1900_1970);
+ msg.xmttime.fraction = htonl(transmit_timeval.tv_usec * 1000);
+
+ len = sendto(fd, &msg, sizeof(msg), MSG_DONTWAIT,
+ addr, size);
+ if (len < 0) {
+ connman_error("ntp: Time request for server %s failed (%d/%s)",
+ server, errno, strerror(errno));
+
+ if (errno == ENETUNREACH)
+ __connman_timeserver_sync_next();
+
+ return;
+ }
+
+ if (len != sizeof(msg)) {
+ connman_error("ntp: Broken time request for server %s", server);
+ return;
+ }
+
+ /*
+ * Add an exponential retry timeout to retry the existing
+ * request. After a set number of retries, we'll fallback to
+ * trying another server.
+ */
+
+ timeout_id = g_timeout_add_seconds(timeout, send_timeout,
+ GUINT_TO_POINTER(timeout));
+}
+
+static gboolean next_poll(gpointer user_data)
+{
+ poll_id = 0;
+
+ if (!timeserver || transmit_fd == 0)
+ return FALSE;
+
+ send_packet(transmit_fd, timeserver, NTP_SEND_TIMEOUT, timeserver_addr.ss_family);
+
+ return FALSE;
+}
+
+static void reset_timeout(void)
+{
+ if (timeout_id > 0) {
+ g_source_remove(timeout_id);
+ timeout_id = 0;
+ }
+
+ retries = 0;
+}
+
+static void decode_msg(void *base, size_t len, struct timeval *tv,
+ struct timespec *mrx_time)
+{
+ struct ntp_msg *msg = base;
+ double m_delta, org, rec, xmt, dst;
+ double delay, offset;
+ static guint transmit_delay;
+ struct timex tmx = {};
+
+ if (len < sizeof(*msg)) {
+ connman_error("ntp: Invalid response from time server");
+ return;
+ }
+
+ if (!tv) {
+ connman_error("ntp: Invalid packet timestamp from time server");
+ return;
+ }
+
+ DBG("flags : 0x%02x", msg->flags);
+ DBG("stratum : %u", msg->stratum);
+ DBG("poll : %f seconds (%d)",
+ LOGTOD(msg->poll), msg->poll);
+ DBG("precision : %f seconds (%d)",
+ LOGTOD(msg->precision), msg->precision);
+ DBG("root delay : %u seconds (fraction %u)",
+ msg->rootdelay.seconds, msg->rootdelay.fraction);
+ DBG("root disp. : %u seconds (fraction %u)",
+ msg->rootdisp.seconds, msg->rootdisp.fraction);
+ DBG("reference : 0x%04x", msg->refid);
+
+ if (!msg->stratum) {
+ /* RFC 4330 ch 8 Kiss-of-Death packet */
+ uint32_t code = ntohl(msg->refid);
+
+ connman_info("ntp: Skipping server %s KoD code %c%c%c%c",
+ timeserver, code >> 24, code >> 16 & 0xff,
+ code >> 8 & 0xff, code & 0xff);
+ next_server();
+ return;
+ }
+
+ if (msg->poll < NTP_MINPOLL || msg->poll > NTP_MAXPOLL) {
+ DBG("fix poll : %f seconds (%d)",
+ LOGTOD(NTP_MAXPOLL_DEFAULT), NTP_MAXPOLL_DEFAULT);
+ transmit_delay = LOGTOD(NTP_MAXPOLL_DEFAULT);
+ } else {
+ transmit_delay = LOGTOD(msg->poll);
+ }
+
+ if (NTP_FLAGS_LI_DECODE(msg->flags) == NTP_FLAG_LI_NOTINSYNC) {
+ DBG("ignoring unsynchronized peer");
+ return;
+ }
+
+
+ if (NTP_FLAGS_VN_DECODE(msg->flags) != NTP_FLAG_VN_VER4) {
+ if (NTP_FLAGS_VN_DECODE(msg->flags) == NTP_FLAG_VN_VER3) {
+ DBG("requested version %d, accepting version %d",
+ NTP_FLAG_VN_VER4, NTP_FLAGS_VN_DECODE(msg->flags));
+ } else {
+ DBG("unsupported version %d", NTP_FLAGS_VN_DECODE(msg->flags));
+ return;
+ }
+ }
+
+ if (NTP_FLAGS_MD_DECODE(msg->flags) != NTP_FLAG_MD_SERVER) {
+ DBG("unsupported mode %d", NTP_FLAGS_MD_DECODE(msg->flags));
+ return;
+ }
+
+ m_delta = mrx_time->tv_sec - mtx_time.tv_sec +
+ 1.0e-9 * (mrx_time->tv_nsec - mtx_time.tv_nsec);
+
+ org = tv->tv_sec + (1.0e-6 * tv->tv_usec) - m_delta + OFFSET_1900_1970;
+ rec = ntohl(msg->rectime.seconds) +
+ ((double) ntohl(msg->rectime.fraction) / UINT_MAX);
+ xmt = ntohl(msg->xmttime.seconds) +
+ ((double) ntohl(msg->xmttime.fraction) / UINT_MAX);
+ dst = tv->tv_sec + (1.0e-6 * tv->tv_usec) + OFFSET_1900_1970;
+
+ DBG("org=%f rec=%f xmt=%f dst=%f", org, rec, xmt, dst);
+
+ offset = ((rec - org) + (xmt - dst)) / 2;
+ delay = (dst - org) - (xmt - rec);
+
+ DBG("offset=%f delay=%f", offset, delay);
+
+ /* Remove the timeout, as timeserver has responded */
+
+ reset_timeout();
+
+ /*
+ * Now poll the server every transmit_delay seconds
+ * for time correction.
+ */
+ if (poll_id > 0)
+ g_rttimeout_source_remove(poll_id);
+
+ DBG("Timeserver %s, next sync in %d seconds", timeserver, transmit_delay);
+
+ poll_id = g_rttimeout_add_seconds_full(CLOCK_BOOTTIME, G_PRIORITY_DEFAULT, transmit_delay,
+ next_poll, NULL, NULL);
+
+ if (offset < STEPTIME_MIN_OFFSET && offset > -STEPTIME_MIN_OFFSET) {
+ tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
+ tmx.status = STA_PLL;
+ tmx.offset = offset * NSEC_PER_SEC;
+ tmx.constant = msg->poll - 4;
+ tmx.maxerror = 0;
+ tmx.esterror = 0;
+
+ connman_info("ntp: adjust (slew): %+.6f sec", offset);
+ } else {
+ tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET | ADJ_MAXERROR | ADJ_ESTERROR;
+
+ /* ADJ_NANO uses nanoseconds in the microseconds field */
+ tmx.time.tv_sec = (long)offset;
+ tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
+ tmx.maxerror = 0;
+ tmx.esterror = 0;
+
+ /* the kernel expects -0.3s as {-1, 7000.000.000} */
+ if (tmx.time.tv_usec < 0) {
+ tmx.time.tv_sec -= 1;
+ tmx.time.tv_usec += NSEC_PER_SEC;
+ }
+
+ connman_info("ntp: adjust (jump): %+.6f sec", offset);
+ }
+
+ if (NTP_FLAGS_LI_DECODE(msg->flags) & NTP_FLAG_LI_ADDSECOND)
+ tmx.status |= STA_INS;
+ else if (NTP_FLAGS_LI_DECODE(msg->flags) & NTP_FLAG_LI_DELSECOND)
+ tmx.status |= STA_DEL;
+
+ if (adjtimex(&tmx) < 0) {
+ connman_error("ntp: Failed to adjust time");
+ } else {
+ DBG("interval/delta/delay/drift %fs/%+.3fs/%.3fs/%+ldppm",
+ LOGTOD(msg->poll), offset, delay, tmx.freq / 65536);
+ }
+
+ if (!ntp_can_sleep) {
+ ntp_can_sleep = true;
+ __connman_notifier_sleep_event(&ntp_can_sleep, ntp_can_sleep, time(0) + 2 * NTP_SEND_TIMEOUT);
+ }
+}
+
+static gboolean received_data(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ unsigned char buf[128];
+ struct sockaddr_storage sender_addr;
+ struct msghdr msg;
+ struct iovec iov;
+ struct cmsghdr *cmsg;
+ struct timeval *tv;
+ struct timespec mrx_time;
+ char aux[128];
+ ssize_t len;
+ int fd;
+
+ if (condition & (G_IO_HUP | G_IO_ERR | G_IO_NVAL)) {
+ connman_error("ntp: Problem with timer server channel");
+ channel_watch = 0;
+ return FALSE;
+ }
+
+ fd = g_io_channel_unix_get_fd(channel);
+
+ iov.iov_base = buf;
+ iov.iov_len = sizeof(buf);
+
+ memset(&msg, 0, sizeof(msg));
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = aux;
+ msg.msg_controllen = sizeof(aux);
+ msg.msg_name = &sender_addr;
+ msg.msg_namelen = sizeof(sender_addr);
+
+ len = recvmsg(fd, &msg, MSG_DONTWAIT);
+ if (len < 0)
+ return TRUE;
+
+ if (sender_addr.ss_family == AF_INET) {
+ if (((struct sockaddr_in *)×erver_addr)->sin_addr.s_addr != ((struct sockaddr_in *)&sender_addr)->sin_addr.s_addr)
+ return TRUE;
+ } else if(sender_addr.ss_family == AF_INET6) {
+ if (memcmp(((struct sockaddr_in6 *)×erver_addr)->sin6_addr.__in6_u.__u6_addr8,
+ ((struct sockaddr_in6 *)&sender_addr)->sin6_addr.__in6_u.__u6_addr8,
+ 16) != 0)
+ return TRUE;
+ } else {
+ connman_error("ntp: Not a valid family type");
+ return TRUE;
+ }
+
+ tv = NULL;
+ clock_gettime(CLOCK_MONOTONIC, &mrx_time);
+
+ for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+ if (cmsg->cmsg_level != SOL_SOCKET)
+ continue;
+
+ switch (cmsg->cmsg_type) {
+ case SCM_TIMESTAMP:
+ tv = (struct timeval *) CMSG_DATA(cmsg);
+ break;
+ }
+ }
+
+ decode_msg(iov.iov_base, iov.iov_len, tv, &mrx_time);
+
+ return TRUE;
+}
+
+static void start_ntp(char *server, int family)
+{
+ GIOChannel *channel;
+ struct sockaddr * addr;
+ struct sockaddr_in in4addr;
+ struct sockaddr_in6 in6addr;
+ int tos = IPTOS_LOWDELAY, timestamp = 1;
+ int size;
+
+ if (!server)
+ return;
+
+ DBG("server %s family %d", server, family);
+
+ if (channel_watch > 0)
+ goto send;
+
+ transmit_fd = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (transmit_fd <= 0) {
+ connman_error("ntp: Failed to open time server socket");
+ return;
+ }
+
+ if (family == AF_INET) {
+ memset(&in4addr, 0, sizeof(in4addr));
+ in4addr.sin_family = family;
+ addr = (struct sockaddr *)&in4addr;
+ size = sizeof(in4addr);
+ } else if (family == AF_INET6) {
+ memset(&in6addr, 0, sizeof(in6addr));
+ in6addr.sin6_family = family;
+ addr = (struct sockaddr *)&in6addr;
+ size = sizeof(in6addr);
+ } else {
+ connman_error("ntp: Family not correct");
+ return;
+ }
+
+ if (bind(transmit_fd, (struct sockaddr *) addr, size) < 0) {
+ connman_error("ntp: Failed to bind time server socket");
+ close(transmit_fd);
+ return;
+ }
+ if (family == AF_INET) {
+ if (setsockopt(transmit_fd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)) < 0) {
+ connman_error("ntp: Failed to set type of service option");
+ close(transmit_fd);
+ return;
+ }
+ } else if (family == AF_INET6) {
+ //TO Do
+ }
+
+ if (setsockopt(transmit_fd, SOL_SOCKET, SO_TIMESTAMP, ×tamp,
+ sizeof(timestamp)) < 0) {
+ connman_error("ntp: Failed to enable timestamp support");
+ close(transmit_fd);
+ return;
+ }
+
+ channel = g_io_channel_unix_new(transmit_fd);
+ if (!channel) {
+ close(transmit_fd);
+ return;
+ }
+
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ g_io_channel_set_close_on_unref(channel, TRUE);
+
+ channel_watch = g_io_add_watch_full(channel, G_PRIORITY_DEFAULT,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ received_data, NULL, NULL);
+
+ g_io_channel_unref(channel);
+
+send:
+ send_packet(transmit_fd, server, NTP_SEND_TIMEOUT, family);
+}
+
+int __connman_ntp_start(char *server)
+{
+ DBG("%s", server);
+ struct addrinfo hint;
+ struct addrinfo *info;
+ int family;
+ int ret;
+
+ if (!server)
+ return -EINVAL;
+
+ if (timeserver)
+ g_free(timeserver);
+
+ memset(&hint, 0, sizeof(hint));
+ hint.ai_family = AF_UNSPEC;
+ hint.ai_flags = AI_NUMERICHOST;
+ ret = getaddrinfo(server, NULL, &hint, &info);
+
+ if (ret) {
+ connman_error("ntp: cannot get the server info");
+ return -1;
+ }
+
+ family = info->ai_family;
+ if (family == AF_INET) {
+ if (inet_pton(family, server, &(((struct sockaddr_in *)×erver_addr)->sin_addr.s_addr)) == 0) {
+ connman_error("ntp: cannot convert ip address string");
+ return -1;
+ }
+ } else if (family == AF_INET6) {
+ if (inet_pton(family, server, ((struct sockaddr_in6 *)×erver_addr)->sin6_addr.__in6_u.__u6_addr8) == 0) {
+ connman_error("ntp: cannot convert ipv6 address string");
+ return -1;
+ }
+ } else {
+ connman_error("ntp: Neither IPv4 nor IPv6 type");
+ return -1;
+ }
+
+ timeserver_addr.ss_family = family;
+ timeserver = g_strdup(server);
+
+ freeaddrinfo(info);
+
+ start_ntp(timeserver, family);
+
+ return 0;
+}
+
+void __connman_ntp_stop()
+{
+ DBG("stop");
+
+ if (poll_id > 0) {
+ g_rttimeout_source_remove(poll_id);
+ poll_id = 0;
+ }
+
+ reset_timeout();
+
+ if (channel_watch > 0) {
+ g_source_remove(channel_watch);
+ channel_watch = 0;
+ transmit_fd = 0;
+ }
+
+ if (timeserver) {
+ g_free(timeserver);
+ timeserver = NULL;
+ }
+
+ if (!ntp_can_sleep) {
+ ntp_can_sleep = true;
+ __connman_notifier_sleep_event(&ntp_can_sleep, ntp_can_sleep, time(0) + 6 * NTP_SEND_TIMEOUT);
+ }
+}
diff --git a/src/peer.c b/src/peer.c
new file mode 100644
index 0000000..8a380c9
--- /dev/null
+++ b/src/peer.c
@@ -0,0 +1,1207 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <ctype.h>
+#include <gdbus.h>
+#include <gdhcp/gdhcp.h>
+#include <netinet/if_ether.h>
+
+#include <connman/agent.h>
+
+#include "connman.h"
+
+static DBusConnection *connection = NULL;
+
+static GHashTable *peers_table = NULL;
+
+static struct connman_peer_driver *peer_driver;
+
+struct _peers_notify {
+ int id;
+ GHashTable *add;
+ GHashTable *remove;
+} *peers_notify;
+
+struct _peer_service {
+ enum connman_peer_service_type type;
+ unsigned char *data;
+ int length;
+};
+
+struct connman_peer {
+ int refcount;
+ struct connman_device *device;
+ struct connman_device *sub_device;
+ unsigned char *iface_address[ETH_ALEN];
+ char *identifier;
+ char *name;
+ char *path;
+ enum connman_peer_state state;
+ struct connman_ipconfig *ipconfig;
+ DBusMessage *pending;
+ bool registered;
+ bool connection_master;
+ struct connman_ippool *ip_pool;
+ GDHCPServer *dhcp_server;
+ uint32_t lease_ip;
+ GSList *services;
+};
+
+static void settings_changed(struct connman_peer *peer);
+
+static void stop_dhcp_server(struct connman_peer *peer)
+{
+ DBG("");
+
+ if (peer->dhcp_server)
+ g_dhcp_server_unref(peer->dhcp_server);
+
+ peer->dhcp_server = NULL;
+
+ if (peer->ip_pool)
+ __connman_ippool_unref(peer->ip_pool);
+ peer->ip_pool = NULL;
+ peer->lease_ip = 0;
+}
+
+static void dhcp_server_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static void lease_added(unsigned char *mac, uint32_t ip)
+{
+ GList *list, *start;
+
+ start = list = g_hash_table_get_values(peers_table);
+ for (; list; list = list->next) {
+ struct connman_peer *temp = list->data;
+
+ if (!memcmp(temp->iface_address, mac, ETH_ALEN)) {
+ temp->lease_ip = ip;
+ settings_changed(temp);
+ break;
+ }
+ }
+
+ g_list_free(start);
+}
+
+static gboolean dhcp_server_started(gpointer data)
+{
+ struct connman_peer *peer = data;
+
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_READY);
+ connman_peer_unref(peer);
+
+ return FALSE;
+}
+
+static int start_dhcp_server(struct connman_peer *peer)
+{
+ const char *start_ip, *end_ip;
+ GDHCPServerError dhcp_error;
+ const char *broadcast;
+ const char *gateway;
+ const char *subnet;
+ int prefixlen;
+ int index;
+ int err;
+
+ DBG("");
+
+ err = -ENOMEM;
+
+ if (peer->sub_device)
+ index = connman_device_get_index(peer->sub_device);
+ else
+ index = connman_device_get_index(peer->device);
+
+ peer->ip_pool = __connman_ippool_create(index, 2, 1, NULL, NULL);
+ if (!peer->ip_pool)
+ goto error;
+
+ gateway = __connman_ippool_get_gateway(peer->ip_pool);
+ subnet = __connman_ippool_get_subnet_mask(peer->ip_pool);
+ broadcast = __connman_ippool_get_broadcast(peer->ip_pool);
+ start_ip = __connman_ippool_get_start_ip(peer->ip_pool);
+ end_ip = __connman_ippool_get_end_ip(peer->ip_pool);
+
+ prefixlen = connman_ipaddress_calc_netmask_len(subnet);
+
+ err = __connman_inet_modify_address(RTM_NEWADDR,
+ NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
+ gateway, NULL, prefixlen, broadcast);
+ if (err < 0)
+ goto error;
+
+ peer->dhcp_server = g_dhcp_server_new(G_DHCP_IPV4, index, &dhcp_error);
+ if (!peer->dhcp_server)
+ goto error;
+
+ g_dhcp_server_set_debug(peer->dhcp_server,
+ dhcp_server_debug, "Peer DHCP server");
+ g_dhcp_server_set_lease_time(peer->dhcp_server, 3600);
+ g_dhcp_server_set_option(peer->dhcp_server, G_DHCP_SUBNET, subnet);
+ g_dhcp_server_set_option(peer->dhcp_server, G_DHCP_ROUTER, gateway);
+ g_dhcp_server_set_option(peer->dhcp_server, G_DHCP_DNS_SERVER, NULL);
+ g_dhcp_server_set_ip_range(peer->dhcp_server, start_ip, end_ip);
+
+ g_dhcp_server_set_lease_added_cb(peer->dhcp_server, lease_added);
+
+ err = g_dhcp_server_start(peer->dhcp_server);
+ if (err < 0)
+ goto error;
+
+ g_timeout_add_seconds(0, dhcp_server_started, connman_peer_ref(peer));
+
+ return 0;
+
+error:
+ stop_dhcp_server(peer);
+ return err;
+}
+
+static void reply_pending(struct connman_peer *peer, int error)
+{
+ if (!peer->pending)
+ return;
+
+ connman_dbus_reply_pending(peer->pending, error, NULL);
+ peer->pending = NULL;
+}
+
+static void peer_free(gpointer data)
+{
+ struct connman_peer *peer = data;
+
+ reply_pending(peer, ENOENT);
+
+ connman_peer_unregister(peer);
+
+ if (peer->path) {
+ g_free(peer->path);
+ peer->path = NULL;
+ }
+
+ if (peer->ipconfig) {
+ __connman_ipconfig_set_ops(peer->ipconfig, NULL);
+ __connman_ipconfig_set_data(peer->ipconfig, NULL);
+ __connman_ipconfig_unref(peer->ipconfig);
+ peer->ipconfig = NULL;
+ }
+
+ stop_dhcp_server(peer);
+
+ if (peer->device) {
+ connman_device_unref(peer->device);
+ peer->device = NULL;
+ }
+
+ if (peer->services)
+ connman_peer_reset_services(peer);
+
+ g_free(peer->identifier);
+ g_free(peer->name);
+
+ g_free(peer);
+}
+
+static const char *state2string(enum connman_peer_state state)
+{
+ switch (state) {
+ case CONNMAN_PEER_STATE_UNKNOWN:
+ break;
+ case CONNMAN_PEER_STATE_IDLE:
+ return "idle";
+ case CONNMAN_PEER_STATE_ASSOCIATION:
+ return "association";
+ case CONNMAN_PEER_STATE_CONFIGURATION:
+ return "configuration";
+ case CONNMAN_PEER_STATE_READY:
+ return "ready";
+ case CONNMAN_PEER_STATE_DISCONNECT:
+ return "disconnect";
+ case CONNMAN_PEER_STATE_FAILURE:
+ return "failure";
+ }
+
+ return NULL;
+}
+
+static bool is_connecting(struct connman_peer *peer)
+{
+ if (peer->state == CONNMAN_PEER_STATE_ASSOCIATION ||
+ peer->state == CONNMAN_PEER_STATE_CONFIGURATION ||
+ peer->pending)
+ return true;
+
+ return false;
+}
+
+static bool is_connected(struct connman_peer *peer)
+{
+ if (peer->state == CONNMAN_PEER_STATE_READY)
+ return true;
+
+ return false;
+}
+
+static bool allow_property_changed(struct connman_peer *peer)
+{
+ if (g_hash_table_lookup_extended(peers_notify->add, peer->path,
+ NULL, NULL))
+ return false;
+
+ return true;
+}
+
+static void append_ipv4(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_peer *peer = user_data;
+ char trans[INET_ADDRSTRLEN+1] = {};
+ const char *local = "";
+ const char *remote = "";
+ char *dhcp = NULL;
+
+ if (!is_connected(peer))
+ return;
+
+ if (peer->connection_master) {
+ struct in_addr addr;
+
+ addr.s_addr = peer->lease_ip;
+ inet_ntop(AF_INET, &addr, trans, INET_ADDRSTRLEN);
+
+ local = __connman_ippool_get_gateway(peer->ip_pool);
+ remote = trans;
+ } else if (peer->ipconfig) {
+ local = __connman_ipconfig_get_local(peer->ipconfig);
+
+ remote = __connman_ipconfig_get_gateway(peer->ipconfig);
+ if (!remote) {
+ remote = dhcp = __connman_dhcp_get_server_address(
+ peer->ipconfig);
+ if (!dhcp)
+ remote = "";
+ }
+ }
+
+ connman_dbus_dict_append_basic(iter, "Local",
+ DBUS_TYPE_STRING, &local);
+ connman_dbus_dict_append_basic(iter, "Remote",
+ DBUS_TYPE_STRING, &remote);
+ if (dhcp)
+ g_free(dhcp);
+}
+
+static void append_peer_service(DBusMessageIter *iter,
+ struct _peer_service *service)
+{
+ DBusMessageIter dict;
+
+ connman_dbus_dict_open(iter, &dict);
+
+ switch (service->type) {
+ case CONNMAN_PEER_SERVICE_UNKNOWN:
+ /* Should never happen */
+ break;
+ case CONNMAN_PEER_SERVICE_WIFI_DISPLAY:
+ connman_dbus_dict_append_fixed_array(&dict,
+ "WiFiDisplayIEs", DBUS_TYPE_BYTE,
+ &service->data, service->length);
+ break;
+ }
+
+ connman_dbus_dict_close(iter, &dict);
+}
+
+static void append_peer_services(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_peer *peer = user_data;
+ DBusMessageIter container;
+ GSList *list;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
+ NULL, &container);
+
+ if (!peer->services) {
+ DBusMessageIter dict;
+
+ connman_dbus_dict_open(&container, &dict);
+ connman_dbus_dict_close(&container, &dict);
+ } else {
+ for (list = peer->services; list; list = list->next)
+ append_peer_service(&container, list->data);
+ }
+
+ dbus_message_iter_close_container(iter, &container);
+}
+
+static void append_properties(DBusMessageIter *iter, struct connman_peer *peer)
+{
+ const char *state = state2string(peer->state);
+ DBusMessageIter dict;
+
+ connman_dbus_dict_open(iter, &dict);
+
+ connman_dbus_dict_append_basic(&dict, "State",
+ DBUS_TYPE_STRING, &state);
+ connman_dbus_dict_append_basic(&dict, "Name",
+ DBUS_TYPE_STRING, &peer->name);
+ connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4, peer);
+ connman_dbus_dict_append_array(&dict, "Services",
+ DBUS_TYPE_DICT_ENTRY,
+ append_peer_services, peer);
+ connman_dbus_dict_close(iter, &dict);
+}
+
+static void settings_changed(struct connman_peer *peer)
+{
+ if (!allow_property_changed(peer))
+ return;
+
+ connman_dbus_property_changed_dict(peer->path,
+ CONNMAN_PEER_INTERFACE, "IPv4",
+ append_ipv4, peer);
+}
+
+static DBusMessage *get_peer_properties(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_peer *peer = data;
+ DBusMessageIter dict;
+ DBusMessage *reply;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &dict);
+ append_properties(&dict, peer);
+
+ return reply;
+}
+
+static void append_peer_struct(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ DBusMessageIter *array = user_data;
+ struct connman_peer *peer = value;
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(array, DBUS_TYPE_STRUCT,
+ NULL, &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+ &peer->path);
+ append_properties(&entry, peer);
+ dbus_message_iter_close_container(array, &entry);
+}
+
+static void state_changed(struct connman_peer *peer)
+{
+ const char *state;
+
+ state = state2string(peer->state);
+ if (!state || !allow_property_changed(peer))
+ return;
+
+ connman_dbus_property_changed_basic(peer->path,
+ CONNMAN_PEER_INTERFACE, "State",
+ DBUS_TYPE_STRING, &state);
+}
+
+static void append_existing_and_new_peers(gpointer key,
+ gpointer value, gpointer user_data)
+{
+ struct connman_peer *peer = value;
+ DBusMessageIter *iter = user_data;
+ DBusMessageIter entry, dict;
+
+ if (!peer || !peer->registered)
+ return;
+
+ if (g_hash_table_lookup(peers_notify->add, peer->path)) {
+ DBG("new %s", peer->path);
+
+ append_peer_struct(key, peer, iter);
+ g_hash_table_remove(peers_notify->add, peer->path);
+ } else if (!g_hash_table_lookup(peers_notify->remove, peer->path)) {
+ DBG("existing %s", peer->path);
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
+ NULL, &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+ &peer->path);
+ connman_dbus_dict_open(&entry, &dict);
+ connman_dbus_dict_close(&entry, &dict);
+
+ dbus_message_iter_close_container(iter, &entry);
+ }
+}
+
+static void peer_append_all(DBusMessageIter *iter, void *user_data)
+{
+ g_hash_table_foreach(peers_table, append_existing_and_new_peers, iter);
+}
+
+static void append_removed(gpointer key, gpointer value, gpointer user_data)
+{
+ DBusMessageIter *iter = user_data;
+ char *objpath = key;
+
+ DBG("removed %s", objpath);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &objpath);
+}
+
+static void peer_append_removed(DBusMessageIter *iter, void *user_data)
+{
+ g_hash_table_foreach(peers_notify->remove, append_removed, iter);
+}
+
+static gboolean peer_send_changed(gpointer data)
+{
+ DBusMessage *signal;
+
+ DBG("");
+
+ peers_notify->id = 0;
+
+ signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "PeersChanged");
+ if (!signal)
+ return FALSE;
+
+ __connman_dbus_append_objpath_dict_array(signal,
+ peer_append_all, NULL);
+ __connman_dbus_append_objpath_array(signal,
+ peer_append_removed, NULL);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+
+ g_hash_table_remove_all(peers_notify->remove);
+ g_hash_table_remove_all(peers_notify->add);
+
+ return FALSE;
+}
+
+static void peer_schedule_changed(void)
+{
+ if (peers_notify->id != 0)
+ return;
+
+ peers_notify->id = g_timeout_add(100, peer_send_changed, NULL);
+}
+
+static void peer_added(struct connman_peer *peer)
+{
+ DBG("peer %p", peer);
+
+ g_hash_table_remove(peers_notify->remove, peer->path);
+ g_hash_table_replace(peers_notify->add, peer->path, peer);
+
+ peer_schedule_changed();
+}
+
+static void peer_removed(struct connman_peer *peer)
+{
+ DBG("peer %p", peer);
+
+ g_hash_table_remove(peers_notify->add, peer->path);
+ g_hash_table_replace(peers_notify->remove, g_strdup(peer->path), NULL);
+
+ peer_schedule_changed();
+}
+
+static const char *get_dbus_sender(struct connman_peer *peer)
+{
+ if (!peer->pending)
+ return NULL;
+
+ return dbus_message_get_sender(peer->pending);
+}
+
+static enum connman_peer_wps_method check_wpspin(struct connman_peer *peer,
+ const char *wpspin)
+{
+ int len, i;
+
+ if (!wpspin)
+ return CONNMAN_PEER_WPS_PBC;
+
+ len = strlen(wpspin);
+ if (len == 0)
+ return CONNMAN_PEER_WPS_PBC;
+
+ if (len != 8)
+ return CONNMAN_PEER_WPS_UNKNOWN;
+ for (i = 0; i < 8; i++) {
+ if (!isdigit((unsigned char) wpspin[i]))
+ return CONNMAN_PEER_WPS_UNKNOWN;
+ }
+
+ return CONNMAN_PEER_WPS_PIN;
+}
+
+static void request_authorization_cb(struct connman_peer *peer,
+ bool choice_done, const char *wpspin,
+ const char *error, void *user_data)
+{
+ enum connman_peer_wps_method wps_method;
+ int err;
+
+ DBG("RequestInput return, %p", peer);
+
+ if (error) {
+ if (g_strcmp0(error,
+ "net.connman.Agent.Error.Canceled") == 0 ||
+ g_strcmp0(error,
+ "net.connman.Agent.Error.Rejected") == 0) {
+ err = -EINVAL;
+ goto out;
+ }
+ }
+
+ if (!choice_done || !peer_driver->connect) {
+ err = -EINVAL;
+ goto out;
+ }
+
+ wps_method = check_wpspin(peer, wpspin);
+
+ err = peer_driver->connect(peer, wps_method, wpspin);
+ if (err == -EINPROGRESS)
+ return;
+
+out:
+ reply_pending(peer, EIO);
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_IDLE);
+}
+
+static int peer_connect(struct connman_peer *peer)
+{
+ int err = -ENOTSUP;
+
+ if (peer_driver->connect)
+ err = peer_driver->connect(peer,
+ CONNMAN_PEER_WPS_UNKNOWN, NULL);
+
+ if (err == -ENOKEY) {
+ err = __connman_agent_request_peer_authorization(peer,
+ request_authorization_cb, true,
+ get_dbus_sender(peer), NULL);
+ }
+
+ return err;
+}
+
+static int peer_disconnect(struct connman_peer *peer)
+{
+ int err = -ENOTSUP;
+
+ connman_agent_cancel(peer);
+ reply_pending(peer, ECONNABORTED);
+
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_DISCONNECT);
+
+ if (peer->connection_master)
+ stop_dhcp_server(peer);
+ else
+ __connman_dhcp_stop(peer->ipconfig);
+
+ if (peer_driver->disconnect)
+ err = peer_driver->disconnect(peer);
+
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_IDLE);
+
+ return err;
+}
+
+static DBusMessage *connect_peer(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_peer *peer = user_data;
+ GList *list, *start;
+ int err;
+
+ DBG("peer %p", peer);
+
+ if (peer->pending)
+ return __connman_error_in_progress(msg);
+
+ list = g_hash_table_get_values(peers_table);
+ start = list;
+ for (; list; list = list->next) {
+ struct connman_peer *temp = list->data;
+
+ if (temp == peer || temp->device != peer->device)
+ continue;
+
+ if (is_connecting(temp) || is_connected(temp)) {
+ if (peer_disconnect(temp) == -EINPROGRESS) {
+ g_list_free(start);
+ return __connman_error_in_progress(msg);
+ }
+ }
+ }
+
+ g_list_free(start);
+
+ peer->pending = dbus_message_ref(msg);
+
+ err = peer_connect(peer);
+ if (err == -EINPROGRESS)
+ return NULL;
+
+ if (err < 0) {
+ dbus_message_unref(peer->pending);
+ peer->pending = NULL;
+
+ return __connman_error_failed(msg, -err);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *disconnect_peer(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_peer *peer = user_data;
+ int err;
+
+ DBG("peer %p", peer);
+
+ err = peer_disconnect(peer);
+ if (err < 0 && err != -EINPROGRESS)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+struct connman_peer *connman_peer_create(const char *identifier)
+{
+ struct connman_peer *peer;
+
+ peer = g_malloc0(sizeof(struct connman_peer));
+ peer->identifier = g_strdup(identifier);
+ peer->state = CONNMAN_PEER_STATE_IDLE;
+
+ peer->refcount = 1;
+
+ return peer;
+}
+
+struct connman_peer *connman_peer_ref_debug(struct connman_peer *peer,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", peer, peer->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&peer->refcount, 1);
+
+ return peer;
+}
+
+void connman_peer_unref_debug(struct connman_peer *peer,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", peer, peer->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&peer->refcount, 1) != 1)
+ return;
+
+ if (!peer->registered && !peer->path)
+ return peer_free(peer);
+
+ g_hash_table_remove(peers_table, peer->path);
+}
+
+const char *connman_peer_get_identifier(struct connman_peer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->identifier;
+}
+
+void connman_peer_set_name(struct connman_peer *peer, const char *name)
+{
+ g_free(peer->name);
+ peer->name = g_strdup(name);
+}
+
+void connman_peer_set_iface_address(struct connman_peer *peer,
+ const unsigned char *iface_address)
+{
+ memset(peer->iface_address, 0, ETH_ALEN);
+ memcpy(peer->iface_address, iface_address, ETH_ALEN);
+}
+
+void connman_peer_set_device(struct connman_peer *peer,
+ struct connman_device *device)
+{
+ if (!peer || !device)
+ return;
+
+ peer->device = device;
+ connman_device_ref(device);
+}
+
+struct connman_device *connman_peer_get_device(struct connman_peer *peer)
+{
+ if (!peer)
+ return NULL;
+
+ return peer->device;
+}
+
+void connman_peer_set_sub_device(struct connman_peer *peer,
+ struct connman_device *device)
+{
+ if (!peer || !device || peer->sub_device)
+ return;
+
+ peer->sub_device = device;
+}
+
+void connman_peer_set_as_master(struct connman_peer *peer, bool master)
+{
+ if (!peer || !is_connecting(peer))
+ return;
+
+ peer->connection_master = master;
+}
+
+static void dhcp_callback(struct connman_ipconfig *ipconfig,
+ struct connman_network *network,
+ bool success, gpointer data)
+{
+ struct connman_peer *peer = data;
+ int err;
+
+ if (!success)
+ goto error;
+
+ DBG("lease acquired for ipconfig %p", ipconfig);
+
+ err = __connman_ipconfig_address_add(ipconfig);
+ if (err < 0)
+ goto error;
+
+ return;
+
+error:
+ __connman_ipconfig_address_remove(ipconfig);
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_FAILURE);
+}
+
+static int start_dhcp_client(struct connman_peer *peer)
+{
+ if (peer->sub_device)
+ __connman_ipconfig_set_index(peer->ipconfig,
+ connman_device_get_index(peer->sub_device));
+
+ __connman_ipconfig_enable(peer->ipconfig);
+
+ return __connman_dhcp_start(peer->ipconfig, NULL, dhcp_callback, peer);
+}
+
+static void report_error_cb(void *user_context, bool retry, void *user_data)
+{
+ struct connman_peer *peer = user_context;
+
+ if (retry) {
+ int err;
+ err = peer_connect(peer);
+
+ if (err == 0 || err == -EINPROGRESS)
+ return;
+ }
+
+ reply_pending(peer, ENOTCONN);
+
+ peer_disconnect(peer);
+
+ if (!peer->connection_master) {
+ __connman_dhcp_stop(peer->ipconfig);
+ __connman_ipconfig_disable(peer->ipconfig);
+ } else
+ stop_dhcp_server(peer);
+
+ peer->connection_master = false;
+ peer->sub_device = NULL;
+}
+
+static int manage_peer_error(struct connman_peer *peer)
+{
+ int err;
+
+ err = __connman_agent_report_peer_error(peer, peer->path,
+ "connect-failed", report_error_cb,
+ get_dbus_sender(peer), NULL);
+ if (err != -EINPROGRESS) {
+ report_error_cb(peer, false, NULL);
+ return err;
+ }
+
+ return 0;
+}
+
+int connman_peer_set_state(struct connman_peer *peer,
+ enum connman_peer_state new_state)
+{
+ enum connman_peer_state old_state = peer->state;
+ int err;
+
+ DBG("peer (%s) old state %d new state %d", peer->name,
+ old_state, new_state);
+
+ if (old_state == new_state)
+ return -EALREADY;
+
+ switch (new_state) {
+ case CONNMAN_PEER_STATE_UNKNOWN:
+ return -EINVAL;
+ case CONNMAN_PEER_STATE_IDLE:
+ if (is_connecting(peer) || is_connected(peer))
+ return peer_disconnect(peer);
+ peer->sub_device = NULL;
+ break;
+ case CONNMAN_PEER_STATE_ASSOCIATION:
+ break;
+ case CONNMAN_PEER_STATE_CONFIGURATION:
+ if (peer->connection_master)
+ err = start_dhcp_server(peer);
+ else
+ err = start_dhcp_client(peer);
+ if (err < 0)
+ return connman_peer_set_state(peer,
+ CONNMAN_PEER_STATE_FAILURE);
+ break;
+ case CONNMAN_PEER_STATE_READY:
+ reply_pending(peer, 0);
+ break;
+ case CONNMAN_PEER_STATE_DISCONNECT:
+ if (peer->connection_master)
+ stop_dhcp_server(peer);
+ else
+ __connman_dhcp_stop(peer->ipconfig);
+ peer->connection_master = false;
+ peer->sub_device = NULL;
+
+ break;
+ case CONNMAN_PEER_STATE_FAILURE:
+ if (manage_peer_error(peer) == 0)
+ return 0;
+ break;
+ };
+
+ peer->state = new_state;
+ state_changed(peer);
+
+ if (peer->state == CONNMAN_PEER_STATE_READY ||
+ peer->state == CONNMAN_PEER_STATE_DISCONNECT)
+ settings_changed(peer);
+
+ return 0;
+}
+
+int connman_peer_request_connection(struct connman_peer *peer)
+{
+ return __connman_agent_request_peer_authorization(peer,
+ request_authorization_cb, false,
+ NULL, NULL);
+}
+
+static void peer_service_free(gpointer data)
+{
+ struct _peer_service *service = data;
+
+ if (!service)
+ return;
+
+ g_free(service->data);
+ g_free(service);
+}
+
+void connman_peer_reset_services(struct connman_peer *peer)
+{
+ if (!peer)
+ return;
+
+ g_slist_free_full(peer->services, peer_service_free);
+ peer->services = NULL;
+}
+
+void connman_peer_services_changed(struct connman_peer *peer)
+{
+ if (!peer || !peer->registered || !allow_property_changed(peer))
+ return;
+
+ connman_dbus_property_changed_array(peer->path,
+ CONNMAN_PEER_INTERFACE, "Services",
+ DBUS_TYPE_DICT_ENTRY, append_peer_services, peer);
+}
+
+void connman_peer_add_service(struct connman_peer *peer,
+ enum connman_peer_service_type type,
+ const unsigned char *data, int data_length)
+{
+ struct _peer_service *service;
+
+ if (!peer || !data || type == CONNMAN_PEER_SERVICE_UNKNOWN)
+ return;
+
+ service = g_malloc0(sizeof(struct _peer_service));
+ service->type = type;
+ service->data = g_memdup(data, data_length * sizeof(unsigned char));
+ service->length = data_length;
+
+ peer->services = g_slist_prepend(peer->services, service);
+}
+
+static void peer_up(struct connman_ipconfig *ipconfig, const char *ifname)
+{
+ DBG("%s up", ifname);
+}
+
+static void peer_down(struct connman_ipconfig *ipconfig, const char *ifname)
+{
+ DBG("%s down", ifname);
+}
+
+static void peer_lower_up(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ DBG("%s lower up", ifname);
+}
+
+static void peer_lower_down(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_peer *peer = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s lower down", ifname);
+
+ __connman_ipconfig_disable(ipconfig);
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_DISCONNECT);
+}
+
+static void peer_ip_bound(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_peer *peer = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s ip bound", ifname);
+
+ if (peer->state == CONNMAN_PEER_STATE_READY)
+ settings_changed(peer);
+ connman_peer_set_state(peer, CONNMAN_PEER_STATE_READY);
+}
+
+static void peer_ip_release(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_peer *peer = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s ip release", ifname);
+
+ if (peer->state == CONNMAN_PEER_STATE_READY)
+ settings_changed(peer);
+}
+
+static const struct connman_ipconfig_ops peer_ip_ops = {
+ .up = peer_up,
+ .down = peer_down,
+ .lower_up = peer_lower_up,
+ .lower_down = peer_lower_down,
+ .ip_bound = peer_ip_bound,
+ .ip_release = peer_ip_release,
+ .route_set = NULL,
+ .route_unset = NULL,
+};
+
+static struct connman_ipconfig *create_ipconfig(int index, void *user_data)
+{
+ struct connman_ipconfig *ipconfig;
+
+ ipconfig = __connman_ipconfig_create(index,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ if (!ipconfig)
+ return NULL;
+
+ __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_DHCP);
+ __connman_ipconfig_set_data(ipconfig, user_data);
+ __connman_ipconfig_set_ops(ipconfig, &peer_ip_ops);
+
+ return ipconfig;
+}
+
+static const GDBusMethodTable peer_methods[] = {
+ { GDBUS_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ get_peer_properties) },
+ { GDBUS_ASYNC_METHOD("Connect", NULL, NULL, connect_peer) },
+ { GDBUS_METHOD("Disconnect", NULL, NULL, disconnect_peer) },
+ { },
+};
+
+static const GDBusSignalTable peer_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { },
+};
+
+static char *get_peer_path(struct connman_device *device,
+ const char *identifier)
+{
+ return g_strdup_printf("%s/peer/peer_%s_%s", CONNMAN_PATH,
+ connman_device_get_ident(device), identifier);
+}
+
+int connman_peer_register(struct connman_peer *peer)
+{
+ int index;
+
+ DBG("peer %p", peer);
+
+ if (peer->path && peer->registered)
+ return -EALREADY;
+
+ index = connman_device_get_index(peer->device);
+ peer->ipconfig = create_ipconfig(index, peer);
+ if (!peer->ipconfig)
+ return -ENOMEM;
+
+ peer->path = get_peer_path(peer->device, peer->identifier);
+ DBG("path %s", peer->path);
+
+ g_hash_table_insert(peers_table, peer->path, peer);
+
+ g_dbus_register_interface(connection, peer->path,
+ CONNMAN_PEER_INTERFACE,
+ peer_methods, peer_signals,
+ NULL, peer, NULL);
+ peer->registered = true;
+ peer_added(peer);
+
+ return 0;
+}
+
+void connman_peer_unregister(struct connman_peer *peer)
+{
+ DBG("peer %p", peer);
+
+ if (!peer->path || !peer->registered)
+ return;
+
+ connman_agent_cancel(peer);
+ reply_pending(peer, EIO);
+
+ g_dbus_unregister_interface(connection, peer->path,
+ CONNMAN_PEER_INTERFACE);
+ peer->registered = false;
+ peer_removed(peer);
+}
+
+struct connman_peer *connman_peer_get(struct connman_device *device,
+ const char *identifier)
+{
+ char *ident = get_peer_path(device, identifier);
+ struct connman_peer *peer;
+
+ peer = g_hash_table_lookup(peers_table, ident);
+ g_free(ident);
+
+ return peer;
+}
+
+int connman_peer_driver_register(struct connman_peer_driver *driver)
+{
+ if (peer_driver && peer_driver != driver)
+ return -EINVAL;
+
+ peer_driver = driver;
+
+ __connman_peer_service_set_driver(driver);
+
+ return 0;
+}
+
+void connman_peer_driver_unregister(struct connman_peer_driver *driver)
+{
+ if (peer_driver != driver)
+ return;
+
+ peer_driver = NULL;
+
+ __connman_peer_service_set_driver(NULL);
+}
+
+void __connman_peer_list_struct(DBusMessageIter *array)
+{
+ g_hash_table_foreach(peers_table, append_peer_struct, array);
+}
+
+const char *__connman_peer_get_path(struct connman_peer *peer)
+{
+ if (!peer || !peer->registered)
+ return NULL;
+
+ return peer->path;
+}
+
+int __connman_peer_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+
+ peers_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, peer_free);
+
+ peers_notify = g_new0(struct _peers_notify, 1);
+ peers_notify->add = g_hash_table_new(g_str_hash, g_str_equal);
+ peers_notify->remove = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, NULL);
+ return 0;
+}
+
+void __connman_peer_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(peers_notify->remove);
+ g_hash_table_destroy(peers_notify->add);
+ g_free(peers_notify);
+
+ g_hash_table_destroy(peers_table);
+ peers_table = NULL;
+ dbus_connection_unref(connection);
+ connection = NULL;
+}
diff --git a/src/peer_service.c b/src/peer_service.c
new file mode 100644
index 0000000..053672a
--- /dev/null
+++ b/src/peer_service.c
@@ -0,0 +1,429 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+static DBusConnection *connection;
+
+struct _peer_service {
+ bool registered;
+ const char *owner;
+ DBusMessage *pending;
+
+ GBytes *specification;
+ GBytes *query;
+ int version;
+
+ bool master;
+};
+
+struct _peer_service_owner {
+ char *owner;
+ guint watch;
+ GList *services;
+};
+
+static struct connman_peer_driver *peer_driver;
+
+static GHashTable *owners_map;
+static GHashTable *services_map;
+static int peer_master;
+
+static void reply_pending(struct _peer_service *service, int error)
+{
+ if (!service->pending)
+ return;
+
+ connman_dbus_reply_pending(service->pending, error, NULL);
+ service->pending = NULL;
+}
+
+static struct _peer_service *find_peer_service(GBytes *specification,
+ GBytes *query, int version,
+ const char *owner, bool remove)
+{
+ struct _peer_service *service = NULL;
+ struct _peer_service_owner *ps_owner;
+ GList *list;
+
+ ps_owner = g_hash_table_lookup(services_map, specification);
+ if (!ps_owner)
+ return NULL;
+
+ if (owner && g_strcmp0(owner, ps_owner->owner) != 0)
+ return NULL;
+
+ for (list = ps_owner->services; list; list = list->next) {
+ service = list->data;
+
+ if (service->specification == specification)
+ break;
+
+ if (version) {
+ if (!service->version)
+ continue;
+ if (version != service->version)
+ continue;
+ }
+
+ if (query) {
+ if (!service->query)
+ continue;
+ if (g_bytes_equal(service->query, query))
+ continue;
+ }
+
+ if (g_bytes_equal(service->specification, specification))
+ break;
+ }
+
+ if (!service)
+ return NULL;
+
+ if (owner && remove)
+ ps_owner->services = g_list_delete_link(ps_owner->services,
+ list);
+
+ return service;
+}
+
+static void unregister_peer_service(struct _peer_service *service)
+{
+ gsize spec_length, query_length = 0;
+ const void *spec, *query = NULL;
+
+ if (!peer_driver || !service->specification)
+ return;
+
+ spec = g_bytes_get_data(service->specification, &spec_length);
+ if (service->query)
+ query = g_bytes_get_data(service->query, &query_length);
+
+ peer_driver->unregister_service(spec, spec_length, query,
+ query_length, service->version);
+}
+
+static void remove_peer_service(gpointer user_data)
+{
+ struct _peer_service *service = user_data;
+
+ reply_pending(service, ECONNABORTED);
+
+ if (service->registered)
+ unregister_peer_service(service);
+
+ if (service->specification) {
+ if (service->owner) {
+ find_peer_service(service->specification,
+ service->query, service->version,
+ service->owner, true);
+ }
+
+ g_hash_table_remove(services_map, service->specification);
+ g_bytes_unref(service->specification);
+ }
+
+ if (service->query)
+ g_bytes_unref(service->query);
+
+ if (service->master)
+ peer_master--;
+
+ g_free(service);
+}
+
+static void apply_peer_service_removal(gpointer user_data)
+{
+ struct _peer_service *service = user_data;
+
+ service->owner = NULL;
+ remove_peer_service(user_data);
+}
+
+static void remove_peer_service_owner(gpointer user_data)
+{
+ struct _peer_service_owner *ps_owner = user_data;
+
+ DBG("owner %s", ps_owner->owner);
+
+ if (ps_owner->watch > 0)
+ g_dbus_remove_watch(connection, ps_owner->watch);
+
+ if (ps_owner->services) {
+ g_list_free_full(ps_owner->services,
+ apply_peer_service_removal);
+ }
+
+ g_free(ps_owner->owner);
+ g_free(ps_owner);
+}
+
+static void owner_disconnect(DBusConnection *conn, void *user_data)
+{
+ struct _peer_service_owner *ps_owner = user_data;
+
+ ps_owner->watch = 0;
+ g_hash_table_remove(owners_map, ps_owner->owner);
+}
+
+static void service_registration_result(int result, void *user_data)
+{
+ struct _peer_service *service = user_data;
+
+ reply_pending(service, -result);
+
+ if (service->registered)
+ return;
+
+ if (result == 0) {
+ service->registered = true;
+ if (service->master)
+ peer_master++;
+ return;
+ }
+
+ remove_peer_service(service);
+}
+
+static int register_peer_service(struct _peer_service *service)
+{
+ gsize spec_length, query_length = 0;
+ const void *spec, *query = NULL;
+
+ if (!peer_driver)
+ return 0;
+
+ spec = g_bytes_get_data(service->specification, &spec_length);
+ if (service->query)
+ query = g_bytes_get_data(service->query, &query_length);
+
+ return peer_driver->register_service(spec, spec_length, query,
+ query_length, service->version,
+ service_registration_result, service);
+}
+
+static void register_all_services(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct _peer_service_owner *ps_owner = value;
+ GList *list;
+
+ for (list = ps_owner->services; list; list = list->next) {
+ struct _peer_service *service = list->data;
+
+ if (service->registered)
+ register_peer_service(service);
+ }
+}
+
+void __connman_peer_service_set_driver(struct connman_peer_driver *driver)
+{
+ peer_driver = driver;
+ if (!peer_driver)
+ return;
+
+ g_hash_table_foreach(owners_map, register_all_services, NULL);
+}
+
+int __connman_peer_service_register(const char *owner, DBusMessage *msg,
+ const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version,
+ bool master)
+{
+ struct _peer_service_owner *ps_owner;
+ GBytes *spec, *query_spec = NULL;
+ struct _peer_service *service;
+ bool new = false;
+ int ret = 0;
+
+ DBG("owner %s - spec %p/length %d - query %p/length %d - version %d",
+ owner,specification, specification_length,
+ query, query_length, version);
+
+ if (!specification || specification_length == 0)
+ return -EINVAL;
+
+ ps_owner = g_hash_table_lookup(owners_map, owner);
+ if (!ps_owner) {
+ ps_owner = g_try_new0(struct _peer_service_owner, 1);
+ if (!ps_owner)
+ return -ENOMEM;
+
+ ps_owner->owner = g_strdup(owner);
+ ps_owner->watch = g_dbus_add_disconnect_watch(connection,
+ owner, owner_disconnect,
+ ps_owner, NULL);
+ g_hash_table_insert(owners_map, ps_owner->owner, ps_owner);
+ new = true;
+ }
+
+ spec = g_bytes_new(specification, specification_length);
+ if (query)
+ query_spec = g_bytes_new(query, query_length);
+
+ service = find_peer_service(spec, query_spec, version, NULL, false);
+ if (service) {
+ DBG("Found one existing service %p", service);
+
+ if (g_strcmp0(service->owner, owner))
+ ret = -EBUSY;
+
+ if (service->pending)
+ ret = -EINPROGRESS;
+ else
+ ret = -EEXIST;
+
+ service = NULL;
+ goto error;
+ }
+
+ service = g_try_new0(struct _peer_service, 1);
+ if (!service) {
+ ret = -ENOMEM;
+ goto error;
+ }
+
+ service->owner = ps_owner->owner;
+ service->specification = spec;
+ service->query = query_spec;
+ service->version = version;
+ service->master = master;
+
+ g_hash_table_insert(services_map, spec, ps_owner);
+ spec = query_spec = NULL;
+
+ ret = register_peer_service(service);
+ if (ret != 0 && ret != -EINPROGRESS)
+ goto error;
+ else if (ret == -EINPROGRESS)
+ service->pending = dbus_message_ref(msg);
+ else {
+ service->registered = true;
+ if (master)
+ peer_master++;
+ }
+
+ ps_owner->services = g_list_prepend(ps_owner->services, service);
+
+ return ret;
+error:
+ if (spec)
+ g_bytes_unref(spec);
+ if (query_spec)
+ g_bytes_unref(query_spec);
+
+ if (service)
+ remove_peer_service(service);
+
+ if (new)
+ g_hash_table_remove(owners_map, ps_owner->owner);
+
+ return ret;
+}
+
+int __connman_peer_service_unregister(const char *owner,
+ const unsigned char *specification,
+ int specification_length,
+ const unsigned char *query,
+ int query_length, int version)
+{
+ struct _peer_service_owner *ps_owner;
+ GBytes *spec, *query_spec = NULL;
+ struct _peer_service *service;
+
+ DBG("owner %s - spec %p/length %d - query %p/length %d - version %d",
+ owner,specification, specification_length,
+ query, query_length, version);
+
+ ps_owner = g_hash_table_lookup(owners_map, owner);
+ if (!ps_owner)
+ return -ESRCH;
+
+ spec = g_bytes_new(specification, specification_length);
+ if (query)
+ query_spec = g_bytes_new(query, query_length);
+
+ service = find_peer_service(spec, query_spec, version, owner, true);
+
+ g_bytes_unref(spec);
+ g_bytes_unref(query_spec);
+
+ if (!service)
+ return -ESRCH;
+
+ remove_peer_service(service);
+
+ if (!ps_owner->services)
+ g_hash_table_remove(owners_map, ps_owner->owner);
+
+ return 0;
+}
+
+bool connman_peer_service_is_master(void)
+{
+ if (!peer_master || !peer_driver)
+ return false;
+
+ return true;
+}
+
+int __connman_peer_service_init(void)
+{
+ DBG("");
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ peer_driver = NULL;
+
+ owners_map = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
+ remove_peer_service_owner);
+ services_map = g_hash_table_new_full(g_bytes_hash, g_bytes_equal,
+ NULL, NULL);
+ peer_master = 0;
+
+ return 0;
+}
+
+void __connman_peer_service_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ g_hash_table_destroy(owners_map);
+ g_hash_table_destroy(services_map);
+ peer_master = 0;
+
+ dbus_connection_unref(connection);
+ connection = NULL;
+}
diff --git a/src/plugin.c b/src/plugin.c
new file mode 100644
index 0000000..7d73058
--- /dev/null
+++ b/src/plugin.c
@@ -0,0 +1,209 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <dlfcn.h>
+
+#include <glib.h>
+
+#ifdef CONNMAN_PLUGIN_BUILTIN
+#undef CONNMAN_PLUGIN_BUILTIN
+#endif
+
+#include "connman.h"
+
+static GSList *plugins = NULL;
+
+struct connman_plugin {
+ void *handle;
+ bool active;
+ struct connman_plugin_desc *desc;
+};
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_plugin *plugin1 = a;
+ const struct connman_plugin *plugin2 = b;
+
+ return plugin2->desc->priority - plugin1->desc->priority;
+}
+
+static bool add_plugin(void *handle, struct connman_plugin_desc *desc)
+{
+ struct connman_plugin *plugin;
+
+ if (!desc->init)
+ return false;
+
+ if (!g_str_equal(desc->version, CONNMAN_VERSION)) {
+ connman_error("Invalid version %s for %s", desc->version,
+ desc->description);
+ return false;
+ }
+
+ plugin = g_try_new0(struct connman_plugin, 1);
+ if (!plugin)
+ return false;
+
+ plugin->handle = handle;
+ plugin->active = false;
+ plugin->desc = desc;
+
+ __connman_log_enable(desc->debug_start, desc->debug_stop);
+
+ plugins = g_slist_insert_sorted(plugins, plugin, compare_priority);
+
+ return true;
+}
+
+static bool check_plugin(struct connman_plugin_desc *desc,
+ char **patterns, char **excludes)
+{
+ if (excludes) {
+ for (; *excludes; excludes++)
+ if (g_pattern_match_simple(*excludes, desc->name))
+ break;
+ if (*excludes) {
+ connman_info("Excluding %s", desc->description);
+ return false;
+ }
+ }
+
+ if (patterns) {
+ for (; *patterns; patterns++)
+ if (g_pattern_match_simple(*patterns, desc->name))
+ break;
+ if (!*patterns) {
+ connman_info("Ignoring %s", desc->description);
+ return false;
+ }
+ }
+
+ return true;
+}
+
+#include <builtin.h>
+
+int __connman_plugin_init(const char *pattern, const char *exclude)
+{
+ gchar **patterns = NULL;
+ gchar **excludes = NULL;
+ GSList *list;
+ GDir *dir;
+ const gchar *file;
+ gchar *filename;
+ unsigned int i;
+
+ DBG("");
+
+ if (pattern)
+ patterns = g_strsplit_set(pattern, ":, ", -1);
+
+ if (exclude)
+ excludes = g_strsplit_set(exclude, ":, ", -1);
+
+ for (i = 0; __connman_builtin[i]; i++) {
+ if (!check_plugin(__connman_builtin[i], patterns, excludes))
+ continue;
+
+ add_plugin(NULL, __connman_builtin[i]);
+ }
+
+ dir = g_dir_open(PLUGINDIR, 0, NULL);
+ if (dir) {
+ while ((file = g_dir_read_name(dir))) {
+ void *handle;
+ struct connman_plugin_desc *desc;
+
+ if (g_str_has_prefix(file, "lib") ||
+ !g_str_has_suffix(file, ".so"))
+ continue;
+
+ filename = g_build_filename(PLUGINDIR, file, NULL);
+
+ handle = dlopen(filename, RTLD_NOW);
+ if (!handle) {
+ connman_error("Can't load %s: %s",
+ filename, dlerror());
+ g_free(filename);
+ continue;
+ }
+
+ g_free(filename);
+
+ desc = dlsym(handle, "connman_plugin_desc");
+ if (!desc) {
+ connman_error("Can't load symbol: %s",
+ dlerror());
+ dlclose(handle);
+ continue;
+ }
+
+ if (!check_plugin(desc, patterns, excludes)) {
+ dlclose(handle);
+ continue;
+ }
+
+ if (!add_plugin(handle, desc))
+ dlclose(handle);
+ }
+
+ g_dir_close(dir);
+ }
+
+ for (list = plugins; list; list = list->next) {
+ struct connman_plugin *plugin = list->data;
+
+ if (plugin->desc->init() < 0)
+ continue;
+
+ plugin->active = true;
+ }
+
+ g_strfreev(patterns);
+ g_strfreev(excludes);
+
+ return 0;
+}
+
+void __connman_plugin_cleanup(void)
+{
+ GSList *list;
+
+ DBG("");
+
+ for (list = plugins; list; list = list->next) {
+ struct connman_plugin *plugin = list->data;
+
+ if (plugin->active && plugin->desc->exit)
+ plugin->desc->exit();
+
+ if (plugin->handle)
+ dlclose(plugin->handle);
+
+ g_free(plugin);
+ }
+
+ g_slist_free(plugins);
+}
diff --git a/src/provider.c b/src/provider.c
new file mode 100644
index 0000000..693552e
--- /dev/null
+++ b/src/provider.c
@@ -0,0 +1,787 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <gdbus.h>
+#include <gweb/gresolv.h>
+
+#include "connman.h"
+
+static DBusConnection *connection = NULL;
+
+static GHashTable *provider_hash = NULL;
+
+static GSList *driver_list = NULL;
+
+struct connman_provider {
+ int refcount;
+ bool immutable;
+ struct connman_service *vpn_service;
+ int index;
+ char *identifier;
+ int family;
+ struct connman_provider_driver *driver;
+ void *driver_data;
+};
+
+void __connman_provider_append_properties(struct connman_provider *provider,
+ DBusMessageIter *iter)
+{
+ const char *host, *domain, *type;
+
+ if (!provider->driver || !provider->driver->get_property)
+ return;
+
+ host = provider->driver->get_property(provider, "Host");
+ domain = provider->driver->get_property(provider, "Domain");
+ type = provider->driver->get_property(provider, "Type");
+
+ if (host)
+ connman_dbus_dict_append_basic(iter, "Host",
+ DBUS_TYPE_STRING, &host);
+
+ if (domain)
+ connman_dbus_dict_append_basic(iter, "Domain",
+ DBUS_TYPE_STRING, &domain);
+
+ if (type)
+ connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
+ &type);
+}
+
+struct connman_provider *
+connman_provider_ref_debug(struct connman_provider *provider,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&provider->refcount, 1);
+
+ return provider;
+}
+
+static void provider_remove(struct connman_provider *provider)
+{
+ if (provider->driver) {
+ provider->driver->remove(provider);
+ provider->driver = NULL;
+ }
+}
+
+static void provider_destruct(struct connman_provider *provider)
+{
+ DBG("provider %p", provider);
+
+ g_free(provider->identifier);
+ g_free(provider);
+}
+
+void connman_provider_unref_debug(struct connman_provider *provider,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&provider->refcount, 1) != 1)
+ return;
+
+ provider_destruct(provider);
+}
+
+static int provider_indicate_state(struct connman_provider *provider,
+ enum connman_service_state state)
+{
+ DBG("state %d", state);
+
+ __connman_service_ipconfig_indicate_state(provider->vpn_service, state,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ return __connman_service_ipconfig_indicate_state(provider->vpn_service,
+ state, CONNMAN_IPCONFIG_TYPE_IPV6);
+}
+
+int connman_provider_disconnect(struct connman_provider *provider)
+{
+ int err;
+
+ DBG("provider %p", provider);
+
+ if (provider->driver && provider->driver->disconnect)
+ err = provider->driver->disconnect(provider);
+ else
+ return -EOPNOTSUPP;
+
+ if (provider->vpn_service)
+ provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_DISCONNECT);
+
+ if (err < 0) {
+ if (err != -EINPROGRESS)
+ return err;
+
+ return -EINPROGRESS;
+ }
+
+ return 0;
+}
+
+int connman_provider_remove(struct connman_provider *provider)
+{
+ DBG("Removing VPN %s", provider->identifier);
+
+ provider_remove(provider);
+
+ connman_provider_set_state(provider, CONNMAN_PROVIDER_STATE_IDLE);
+
+ g_hash_table_remove(provider_hash, provider->identifier);
+
+ return 0;
+}
+
+int __connman_provider_connect(struct connman_provider *provider)
+{
+ int err;
+
+ DBG("provider %p", provider);
+
+ if (provider->driver && provider->driver->connect)
+ err = provider->driver->connect(provider);
+ else
+ return -EOPNOTSUPP;
+
+ if (err < 0) {
+ if (err != -EINPROGRESS)
+ return err;
+
+ provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_ASSOCIATION);
+
+ return -EINPROGRESS;
+ }
+
+ return 0;
+}
+
+int __connman_provider_remove_by_path(const char *path)
+{
+ struct connman_provider *provider;
+ GHashTableIter iter;
+ gpointer value, key;
+
+ DBG("path %s", path);
+
+ g_hash_table_iter_init(&iter, provider_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ const char *srv_path;
+ provider = value;
+
+ if (!provider->vpn_service)
+ continue;
+
+ srv_path = __connman_service_get_path(provider->vpn_service);
+
+ if (g_strcmp0(srv_path, path) == 0) {
+ DBG("Removing VPN %s", provider->identifier);
+
+ provider_remove(provider);
+
+ connman_provider_set_state(provider,
+ CONNMAN_PROVIDER_STATE_IDLE);
+
+ g_hash_table_remove(provider_hash,
+ provider->identifier);
+ return 0;
+ }
+ }
+
+ return -ENXIO;
+}
+
+static int set_connected(struct connman_provider *provider,
+ bool connected)
+{
+ struct connman_service *service = provider->vpn_service;
+ struct connman_ipconfig *ipconfig;
+
+ if (!service)
+ return -ENODEV;
+
+ ipconfig = __connman_service_get_ipconfig(service, provider->family);
+
+ if (connected) {
+ if (!ipconfig) {
+ provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_FAILURE);
+ return -EIO;
+ }
+
+ __connman_ipconfig_address_add(ipconfig);
+ __connman_ipconfig_gateway_add(ipconfig);
+
+ provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_READY);
+
+ if (provider->driver && provider->driver->set_routes)
+ provider->driver->set_routes(provider,
+ CONNMAN_PROVIDER_ROUTE_ALL);
+
+ } else {
+ if (ipconfig) {
+ provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_DISCONNECT);
+ __connman_ipconfig_gateway_remove(ipconfig);
+ }
+
+ provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_IDLE);
+ }
+
+ return 0;
+}
+
+int connman_provider_set_state(struct connman_provider *provider,
+ enum connman_provider_state state)
+{
+ if (!provider || !provider->vpn_service)
+ return -EINVAL;
+
+ switch (state) {
+ case CONNMAN_PROVIDER_STATE_UNKNOWN:
+ return -EINVAL;
+ case CONNMAN_PROVIDER_STATE_IDLE:
+ return set_connected(provider, false);
+ case CONNMAN_PROVIDER_STATE_CONNECT:
+ return provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_ASSOCIATION);
+ case CONNMAN_PROVIDER_STATE_READY:
+ return set_connected(provider, true);
+ case CONNMAN_PROVIDER_STATE_DISCONNECT:
+ return provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_DISCONNECT);
+ case CONNMAN_PROVIDER_STATE_FAILURE:
+ return provider_indicate_state(provider,
+ CONNMAN_SERVICE_STATE_FAILURE);
+ }
+
+ return -EINVAL;
+}
+
+int connman_provider_indicate_error(struct connman_provider *provider,
+ enum connman_provider_error error)
+{
+ enum connman_service_error service_error;
+
+ switch (error) {
+ case CONNMAN_PROVIDER_ERROR_LOGIN_FAILED:
+ service_error = CONNMAN_SERVICE_ERROR_LOGIN_FAILED;
+ break;
+ case CONNMAN_PROVIDER_ERROR_AUTH_FAILED:
+ service_error = CONNMAN_SERVICE_ERROR_AUTH_FAILED;
+ break;
+ case CONNMAN_PROVIDER_ERROR_CONNECT_FAILED:
+ service_error = CONNMAN_SERVICE_ERROR_CONNECT_FAILED;
+ break;
+ default:
+ service_error = CONNMAN_SERVICE_ERROR_UNKNOWN;
+ break;
+ }
+
+ return __connman_service_indicate_error(provider->vpn_service,
+ service_error);
+}
+
+int connman_provider_create_service(struct connman_provider *provider)
+{
+ if (provider->vpn_service) {
+ bool connected;
+
+ connected = __connman_service_is_connected_state(
+ provider->vpn_service, CONNMAN_IPCONFIG_TYPE_IPV4);
+ if (connected)
+ return -EALREADY;
+
+ connected = __connman_service_is_connected_state(
+ provider->vpn_service, CONNMAN_IPCONFIG_TYPE_IPV6);
+ if (connected)
+ return -EALREADY;
+
+ return 0;
+ }
+
+ provider->vpn_service =
+ __connman_service_create_from_provider(provider);
+
+ if (!provider->vpn_service) {
+ connman_warn("service creation failed for provider %s",
+ provider->identifier);
+
+ g_hash_table_remove(provider_hash, provider->identifier);
+ return -EOPNOTSUPP;
+ }
+
+ return 0;
+}
+
+bool __connman_provider_is_immutable(struct connman_provider *provider)
+
+{
+ if (provider)
+ return provider->immutable;
+
+ return false;
+}
+
+int connman_provider_set_immutable(struct connman_provider *provider,
+ bool immutable)
+{
+ if (!provider)
+ return -EINVAL;
+
+ provider->immutable = immutable;
+
+ return 0;
+}
+
+static struct connman_provider *provider_lookup(const char *identifier)
+{
+ return g_hash_table_lookup(provider_hash, identifier);
+}
+
+static void connection_ready(DBusMessage *msg, int error_code, void *user_data)
+{
+ DBusMessage *reply;
+ const char *identifier = user_data;
+
+ DBG("msg %p error %d", msg, error_code);
+
+ if (error_code != 0) {
+ reply = __connman_error_failed(msg, -error_code);
+ if (!g_dbus_send_message(connection, reply))
+ DBG("reply %p send failed", reply);
+ } else {
+ const char *path;
+ struct connman_provider *provider;
+
+ provider = provider_lookup(identifier);
+ if (!provider) {
+ reply = __connman_error_failed(msg, EINVAL);
+ g_dbus_send_message(connection, reply);
+ return;
+ }
+
+ path = __connman_service_get_path(provider->vpn_service);
+
+ g_dbus_send_reply(connection, msg,
+ DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+ }
+}
+
+int __connman_provider_create_and_connect(DBusMessage *msg)
+{
+ struct connman_provider_driver *driver;
+
+ if (!driver_list)
+ return -EINVAL;
+
+ driver = driver_list->data;
+ if (!driver || !driver->create)
+ return -EINVAL;
+
+ DBG("msg %p", msg);
+
+ return driver->create(msg, connection_ready);
+}
+
+const char *__connman_provider_get_ident(struct connman_provider *provider)
+{
+ if (!provider)
+ return NULL;
+
+ return provider->identifier;
+}
+
+int connman_provider_set_string(struct connman_provider *provider,
+ const char *key, const char *value)
+{
+ if (provider->driver && provider->driver->set_property)
+ return provider->driver->set_property(provider, key, value);
+
+ return 0;
+}
+
+const char *connman_provider_get_string(struct connman_provider *provider,
+ const char *key)
+{
+ if (provider->driver && provider->driver->get_property)
+ return provider->driver->get_property(provider, key);
+
+ return NULL;
+}
+
+bool
+__connman_provider_check_routes(struct connman_provider *provider)
+{
+ if (!provider)
+ return false;
+
+ if (provider->driver && provider->driver->check_routes)
+ return provider->driver->check_routes(provider);
+
+ return false;
+}
+
+void *connman_provider_get_data(struct connman_provider *provider)
+{
+ return provider->driver_data;
+}
+
+void connman_provider_set_data(struct connman_provider *provider, void *data)
+{
+ provider->driver_data = data;
+}
+
+void connman_provider_set_index(struct connman_provider *provider, int index)
+{
+ struct connman_service *service = provider->vpn_service;
+ struct connman_ipconfig *ipconfig;
+
+ DBG("");
+
+ if (!service)
+ return;
+
+ ipconfig = __connman_service_get_ip4config(service);
+
+ if (!ipconfig) {
+ connman_service_create_ip4config(service, index);
+
+ ipconfig = __connman_service_get_ip4config(service);
+ if (!ipconfig) {
+ DBG("Couldnt create ipconfig");
+ goto done;
+ }
+ }
+
+ __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_OFF);
+ __connman_ipconfig_set_index(ipconfig, index);
+
+ ipconfig = __connman_service_get_ip6config(service);
+
+ if (!ipconfig) {
+ connman_service_create_ip6config(service, index);
+
+ ipconfig = __connman_service_get_ip6config(service);
+ if (!ipconfig) {
+ DBG("Couldnt create ipconfig for IPv6");
+ goto done;
+ }
+ }
+
+ __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_OFF);
+ __connman_ipconfig_set_index(ipconfig, index);
+
+done:
+ provider->index = index;
+}
+
+int connman_provider_get_index(struct connman_provider *provider)
+{
+ return provider->index;
+}
+
+int connman_provider_set_ipaddress(struct connman_provider *provider,
+ struct connman_ipaddress *ipaddress)
+{
+ struct connman_ipconfig *ipconfig = NULL;
+
+ ipconfig = __connman_service_get_ipconfig(provider->vpn_service,
+ ipaddress->family);
+ if (!ipconfig)
+ return -EINVAL;
+
+ provider->family = ipaddress->family;
+
+ __connman_ipconfig_set_method(ipconfig, CONNMAN_IPCONFIG_METHOD_FIXED);
+
+ __connman_ipconfig_set_local(ipconfig, ipaddress->local);
+ __connman_ipconfig_set_peer(ipconfig, ipaddress->peer);
+ __connman_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
+ __connman_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
+ __connman_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
+
+ return 0;
+}
+
+int connman_provider_set_pac(struct connman_provider *provider, const char *pac)
+{
+ DBG("provider %p pac %s", provider, pac);
+
+ __connman_service_set_pac(provider->vpn_service, pac);
+
+ return 0;
+}
+
+
+int connman_provider_set_domain(struct connman_provider *provider,
+ const char *domain)
+{
+ DBG("provider %p domain %s", provider, domain);
+
+ __connman_service_set_domainname(provider->vpn_service, domain);
+
+ return 0;
+}
+
+int connman_provider_set_nameservers(struct connman_provider *provider,
+ char * const *nameservers)
+{
+ int i;
+
+ DBG("provider %p nameservers %p", provider, nameservers);
+
+ __connman_service_nameserver_clear(provider->vpn_service);
+
+ if (!nameservers)
+ return 0;
+
+ for (i = 0; nameservers[i]; i++)
+ __connman_service_nameserver_append(provider->vpn_service,
+ nameservers[i], false);
+
+ return 0;
+}
+
+static void unregister_provider(gpointer data)
+{
+ struct connman_provider *provider = data;
+
+ DBG("provider %p service %p", provider, provider->vpn_service);
+
+ if (provider->vpn_service) {
+ connman_service_unref(provider->vpn_service);
+ provider->vpn_service = NULL;
+ }
+
+ connman_provider_unref(provider);
+}
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ return 0;
+}
+
+int connman_provider_driver_register(struct connman_provider_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+ return 0;
+}
+
+void connman_provider_driver_unregister(struct connman_provider_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_remove(driver_list, driver);
+}
+
+void connman_provider_set_driver(struct connman_provider *provider,
+ struct connman_provider_driver *driver)
+{
+ provider->driver = driver;
+}
+
+static void provider_disconnect_all(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct connman_provider *provider = value;
+
+ connman_provider_disconnect(provider);
+}
+
+static void provider_offline_mode(bool enabled)
+{
+ DBG("enabled %d", enabled);
+
+ if (enabled)
+ g_hash_table_foreach(provider_hash, provider_disconnect_all,
+ NULL);
+
+}
+
+static void provider_initialize(struct connman_provider *provider)
+{
+ DBG("provider %p", provider);
+
+ provider->index = 0;
+ provider->identifier = NULL;
+}
+
+static struct connman_provider *provider_new(void)
+{
+ struct connman_provider *provider;
+
+ provider = g_try_new0(struct connman_provider, 1);
+ if (!provider)
+ return NULL;
+
+ provider->refcount = 1;
+
+ DBG("provider %p", provider);
+ provider_initialize(provider);
+
+ return provider;
+}
+
+struct connman_provider *connman_provider_get(const char *identifier)
+{
+ struct connman_provider *provider;
+
+ provider = g_hash_table_lookup(provider_hash, identifier);
+ if (provider)
+ return provider;
+
+ provider = provider_new();
+ if (!provider)
+ return NULL;
+
+ DBG("provider %p", provider);
+
+ provider->identifier = g_strdup(identifier);
+
+ g_hash_table_insert(provider_hash, provider->identifier, provider);
+
+ return provider;
+}
+
+void connman_provider_put(struct connman_provider *provider)
+{
+ g_hash_table_remove(provider_hash, provider->identifier);
+}
+
+static struct connman_provider *provider_get(int index)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ g_hash_table_iter_init(&iter, provider_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_provider *provider = value;
+
+ if (provider->index == index)
+ return provider;
+ }
+
+ return NULL;
+}
+
+static void provider_service_changed(struct connman_service *service,
+ enum connman_service_state state)
+{
+ struct connman_provider *provider;
+ int vpn_index, service_index;
+
+ if (!service)
+ return;
+
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ return;
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ break;
+ }
+
+ service_index = __connman_service_get_index(service);
+
+ vpn_index = __connman_connection_get_vpn_index(service_index);
+
+ DBG("service %p %s state %d index %d/%d", service,
+ __connman_service_get_ident(service),
+ state, service_index, vpn_index);
+
+ if (vpn_index < 0)
+ return;
+
+ provider = provider_get(vpn_index);
+ if (!provider)
+ return;
+
+ DBG("disconnect %p index %d", provider, vpn_index);
+
+ connman_provider_disconnect(provider);
+
+ return;
+}
+
+static struct connman_notifier provider_notifier = {
+ .name = "provider",
+ .offline_mode = provider_offline_mode,
+ .service_state_changed = provider_service_changed,
+};
+
+int __connman_provider_init(void)
+{
+ int err;
+
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+
+ provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, unregister_provider);
+
+ err = connman_notifier_register(&provider_notifier);
+ if (err < 0) {
+ g_hash_table_destroy(provider_hash);
+ dbus_connection_unref(connection);
+ }
+
+ return err;
+}
+
+void __connman_provider_cleanup(void)
+{
+ DBG("");
+
+ connman_notifier_unregister(&provider_notifier);
+
+ g_hash_table_destroy(provider_hash);
+ provider_hash = NULL;
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/proxy.c b/src/proxy.c
new file mode 100644
index 0000000..f331de9
--- /dev/null
+++ b/src/proxy.c
@@ -0,0 +1,251 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+
+#include "connman.h"
+
+static unsigned int next_lookup_token = 1;
+
+static GSList *driver_list = NULL;
+static GSList *lookup_list = NULL;
+
+struct proxy_lookup {
+ unsigned int token;
+ connman_proxy_lookup_cb cb;
+ void *user_data;
+ struct connman_service *service;
+ char *url;
+ guint watch;
+ struct connman_proxy_driver *proxy;
+};
+
+static void remove_lookup(struct proxy_lookup *lookup)
+{
+ if (lookup->watch > 0)
+ g_source_remove(lookup->watch);
+
+ lookup_list = g_slist_remove(lookup_list, lookup);
+
+ connman_service_unref(lookup->service);
+ g_free(lookup->url);
+ g_free(lookup);
+}
+
+static void remove_lookups(GSList *lookups)
+{
+ GSList *list;
+
+ for (list = lookups; list; list = list->next) {
+ struct proxy_lookup *lookup = list->data;
+
+ remove_lookup(lookup);
+ }
+
+ g_slist_free(lookups);
+}
+
+static gboolean lookup_callback(gpointer user_data)
+{
+ struct proxy_lookup *lookup = user_data;
+ GSList *list;
+
+ if (!lookup)
+ return FALSE;
+
+ lookup->watch = 0;
+
+ for (list = driver_list; list; list = list->next) {
+ struct connman_proxy_driver *proxy = list->data;
+
+ if (!proxy->request_lookup)
+ continue;
+
+ lookup->proxy = proxy;
+ break;
+ }
+
+ if (!lookup->proxy ||
+ lookup->proxy->request_lookup(lookup->service,
+ lookup->url) < 0) {
+
+ if (lookup->cb)
+ lookup->cb(NULL, lookup->user_data);
+
+ remove_lookup(lookup);
+ }
+
+ return FALSE;
+}
+
+unsigned int connman_proxy_lookup(const char *interface, const char *url,
+ struct connman_service *service,
+ connman_proxy_lookup_cb cb,
+ void *user_data)
+{
+ struct proxy_lookup *lookup;
+
+ DBG("interface %s url %s", interface, url);
+
+ if (!interface)
+ return 0;
+
+ lookup = g_try_new0(struct proxy_lookup, 1);
+ if (!lookup)
+ return 0;
+
+ lookup->token = next_lookup_token++;
+
+ lookup->cb = cb;
+ lookup->user_data = user_data;
+ lookup->url = g_strdup(url);
+ lookup->service = connman_service_ref(service);
+
+ lookup->watch = g_timeout_add_seconds(0, lookup_callback, lookup);
+ if (lookup->watch == 0) {
+ g_free(lookup->url);
+ g_free(lookup);
+ return 0;
+ }
+
+ DBG("token %u", lookup->token);
+ lookup_list = g_slist_prepend(lookup_list, lookup);
+
+ return lookup->token;
+}
+
+void connman_proxy_lookup_cancel(unsigned int token)
+{
+ GSList *list;
+ struct proxy_lookup *lookup = NULL;
+
+ DBG("token %u", token);
+
+ for (list = lookup_list; list; list = list->next) {
+ lookup = list->data;
+
+ if (lookup->token == token)
+ break;
+
+ lookup = NULL;
+ }
+
+ if (lookup) {
+ if (lookup->proxy &&
+ lookup->proxy->cancel_lookup)
+ lookup->proxy->cancel_lookup(lookup->service,
+ lookup->url);
+
+ remove_lookup(lookup);
+ }
+}
+
+void connman_proxy_driver_lookup_notify(struct connman_service *service,
+ const char *url, const char *result)
+{
+ GSList *list, *matches = NULL;
+
+ DBG("service %p url %s result %s", service, url, result);
+
+ for (list = lookup_list; list; list = list->next) {
+ struct proxy_lookup *lookup = list->data;
+
+ if (service != lookup->service)
+ continue;
+
+ if (g_strcmp0(lookup->url, url) == 0) {
+ if (lookup->cb)
+ lookup->cb(result, lookup->user_data);
+
+ matches = g_slist_prepend(matches, lookup);
+ }
+ }
+
+ if (matches)
+ remove_lookups(matches);
+}
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_proxy_driver *driver1 = a;
+ const struct connman_proxy_driver *driver2 = b;
+
+ return driver2->priority - driver1->priority;
+}
+
+/**
+ * connman_proxy_driver_register:
+ * @driver: Proxy driver definition
+ *
+ * Register a new proxy driver
+ *
+ * Returns: %0 on success
+ */
+int connman_proxy_driver_register(struct connman_proxy_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+
+ return 0;
+}
+
+/**
+ * connman_proxy_driver_unregister:
+ * @driver: Proxy driver definition
+ *
+ * Remove a previously registered proxy driver
+ */
+void connman_proxy_driver_unregister(struct connman_proxy_driver *driver)
+{
+ GSList *list;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_remove(driver_list, driver);
+
+ for (list = lookup_list; list; list = list->next) {
+ struct proxy_lookup *lookup = list->data;
+
+ if (lookup->proxy == driver)
+ lookup->proxy = NULL;
+ }
+
+}
+
+int __connman_proxy_init(void)
+{
+ DBG("");
+
+ return 0;
+}
+
+void __connman_proxy_cleanup(void)
+{
+ DBG("");
+
+ remove_lookups(lookup_list);
+}
diff --git a/src/resolver.c b/src/resolver.c
new file mode 100644
index 0000000..6a64938
--- /dev/null
+++ b/src/resolver.c
@@ -0,0 +1,668 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <resolv.h>
+#include <netdb.h>
+
+#include "connman.h"
+
+#define RESOLVER_FLAG_PUBLIC (1 << 0)
+
+/*
+ * Threshold for RDNSS lifetime. Will be used to trigger RS
+ * before RDNSS entries actually expire
+ */
+#define RESOLVER_LIFETIME_REFRESH_THRESHOLD 0.8
+
+struct entry_data {
+ int index;
+ char *domain;
+ char *server;
+ int family;
+ unsigned int flags;
+ unsigned int lifetime;
+ guint timeout;
+};
+
+static GSList *entry_list = NULL;
+static bool dnsproxy_enabled = false;
+
+struct resolvfile_entry {
+ int index;
+ char *domain;
+ char *server;
+};
+
+static GList *resolvfile_list = NULL;
+
+static void resolvfile_remove_entries(GList *entries)
+{
+ GList *list;
+
+ for (list = entries; list; list = list->next) {
+ struct resolvfile_entry *entry = list->data;
+
+ resolvfile_list = g_list_remove(resolvfile_list, entry);
+
+ g_free(entry->server);
+ g_free(entry->domain);
+ g_free(entry);
+ }
+
+ g_list_free(entries);
+}
+
+static int resolvfile_export(void)
+{
+ GList *list;
+ GString *content;
+ int fd, err;
+ unsigned int count;
+ mode_t old_umask;
+
+ content = g_string_new("# Generated by Connection Manager\n");
+
+ /*
+ * Domains and nameservers are added in reverse so that the most
+ * recently appended entry is the primary one. No more than
+ * MAXDNSRCH/MAXNS entries are used.
+ */
+
+ for (count = 0, list = g_list_last(resolvfile_list);
+ list && (count < MAXDNSRCH);
+ list = g_list_previous(list)) {
+ struct resolvfile_entry *entry = list->data;
+
+ if (!entry->domain)
+ continue;
+
+ if (count == 0)
+ g_string_append_printf(content, "search ");
+
+ g_string_append_printf(content, "%s ", entry->domain);
+ count++;
+ }
+
+ if (count)
+ g_string_append_printf(content, "\n");
+
+ for (count = 0, list = g_list_last(resolvfile_list);
+ list && (count < MAXNS);
+ list = g_list_previous(list)) {
+ struct resolvfile_entry *entry = list->data;
+
+ if (!entry->server)
+ continue;
+
+ g_string_append_printf(content, "nameserver %s\n",
+ entry->server);
+ count++;
+ }
+
+ old_umask = umask(022);
+
+ fd = open("/etc/resolv.conf", O_RDWR | O_CREAT | O_CLOEXEC,
+ S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+ if (fd < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ if (ftruncate(fd, 0) < 0) {
+ err = -errno;
+ goto failed;
+ }
+
+ err = 0;
+
+ if (write(fd, content->str, content->len) < 0)
+ err = -errno;
+
+failed:
+ close(fd);
+
+done:
+ g_string_free(content, TRUE);
+ umask(old_umask);
+
+ return err;
+}
+
+int __connman_resolvfile_append(int index, const char *domain,
+ const char *server)
+{
+ struct resolvfile_entry *entry;
+
+ DBG("index %d server %s", index, server);
+
+ if (index < 0)
+ return -ENOENT;
+
+ entry = g_try_new0(struct resolvfile_entry, 1);
+ if (!entry)
+ return -ENOMEM;
+
+ entry->index = index;
+ entry->domain = g_strdup(domain);
+ entry->server = g_strdup(server);
+
+ resolvfile_list = g_list_append(resolvfile_list, entry);
+
+ return resolvfile_export();
+}
+
+int __connman_resolvfile_remove(int index, const char *domain,
+ const char *server)
+{
+ GList *list, *matches = NULL;
+
+ DBG("index %d server %s", index, server);
+
+ for (list = resolvfile_list; list; list = g_list_next(list)) {
+ struct resolvfile_entry *entry = list->data;
+
+ if (index >= 0 && entry->index != index)
+ continue;
+
+ if (domain && g_strcmp0(entry->domain, domain) != 0)
+ continue;
+
+ if (g_strcmp0(entry->server, server) != 0)
+ continue;
+
+ matches = g_list_append(matches, entry);
+ }
+
+ resolvfile_remove_entries(matches);
+
+ return resolvfile_export();
+}
+
+static void append_fallback_nameservers(void)
+{
+ GSList *list;
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->index >= 0 && entry->server)
+ return;
+ }
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->index != -1 || !entry->server)
+ continue;
+
+ DBG("index %d server %s", entry->index, entry->server);
+
+ if (dnsproxy_enabled) {
+ __connman_dnsproxy_append(entry->index, entry->domain,
+ entry->server);
+ } else {
+ __connman_resolvfile_append(entry->index,
+ entry->domain, entry->server);
+ }
+ }
+}
+
+static void remove_fallback_nameservers(void)
+{
+ GSList *list;
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->index >= 0 || !entry->server)
+ continue;
+
+ DBG("index %d server %s", entry->index, entry->server);
+
+ if (dnsproxy_enabled) {
+ __connman_dnsproxy_remove(entry->index, entry->domain,
+ entry->server);
+ } else {
+ __connman_resolvfile_remove(entry->index,
+ entry->domain, entry->server);
+ }
+ }
+}
+
+static void remove_entries(GSList *entries)
+{
+ GSList *list;
+
+ for (list = entries; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ entry_list = g_slist_remove(entry_list, entry);
+
+ if (dnsproxy_enabled) {
+ __connman_dnsproxy_remove(entry->index, entry->domain,
+ entry->server);
+ } else {
+ __connman_resolvfile_remove(entry->index, entry->domain,
+ entry->server);
+ }
+
+ if (entry->timeout)
+ g_source_remove(entry->timeout);
+ g_free(entry->server);
+ g_free(entry->domain);
+ g_free(entry);
+ }
+
+ g_slist_free(entries);
+
+ append_fallback_nameservers();
+}
+
+static gboolean resolver_expire_cb(gpointer user_data)
+{
+ struct entry_data *entry = user_data;
+ GSList *list;
+
+ DBG("index %d domain %s server %s",
+ entry->index, entry->domain, entry->server);
+
+ list = g_slist_prepend(NULL, entry);
+
+ if (entry->index >= 0) {
+ struct connman_service *service;
+ service = __connman_service_lookup_from_index(entry->index);
+ if (service)
+ __connman_service_nameserver_remove(service,
+ entry->server, true);
+ }
+
+ remove_entries(list);
+
+ return FALSE;
+}
+
+static gboolean resolver_refresh_cb(gpointer user_data)
+{
+ struct entry_data *entry = user_data;
+ unsigned int interval;
+ struct connman_service *service = NULL;
+
+ /* Round up what we have left from lifetime */
+ interval = entry->lifetime *
+ (1 - RESOLVER_LIFETIME_REFRESH_THRESHOLD) + 1.0;
+
+ DBG("RDNSS start index %d domain %s "
+ "server %s remaining lifetime %d",
+ entry->index, entry->domain,
+ entry->server, interval);
+
+ entry->timeout = g_timeout_add_seconds(interval,
+ resolver_expire_cb, entry);
+
+ if (entry->index >= 0) {
+ service = __connman_service_lookup_from_index(entry->index);
+ if (service) {
+ /*
+ * Send Router Solicitation to refresh RDNSS entries
+ * before their lifetime expires
+ */
+ __connman_network_refresh_rs_ipv6(
+ __connman_service_get_network(service),
+ entry->index);
+ }
+ }
+ return FALSE;
+}
+
+static int append_resolver(int index, const char *domain,
+ const char *server, unsigned int lifetime,
+ unsigned int flags)
+{
+ struct entry_data *entry;
+ unsigned int interval;
+
+ DBG("index %d domain %s server %s lifetime %d flags %d",
+ index, domain, server, lifetime, flags);
+
+ if (!server && !domain)
+ return -EINVAL;
+
+ entry = g_try_new0(struct entry_data, 1);
+ if (!entry)
+ return -ENOMEM;
+
+ entry->index = index;
+ entry->domain = g_strdup(domain);
+ entry->server = g_strdup(server);
+ entry->flags = flags;
+ entry->lifetime = lifetime;
+
+ if (server)
+ entry->family = connman_inet_check_ipaddress(server);
+
+ if (lifetime) {
+ interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
+
+ DBG("RDNSS start index %d domain %s "
+ "server %s lifetime threshold %d",
+ index, domain, server, interval);
+
+ entry->timeout = g_timeout_add_seconds(interval,
+ resolver_refresh_cb, entry);
+
+ /*
+ * We update the service only for those nameservers
+ * that are automagically added via netlink (lifetime > 0)
+ */
+ if (server && entry->index >= 0) {
+ struct connman_service *service;
+ service = __connman_service_lookup_from_index(entry->index);
+ if (service)
+ __connman_service_nameserver_append(service,
+ server, true);
+ }
+ }
+
+ if (entry->index >= 0 && entry->server)
+ remove_fallback_nameservers();
+
+ entry_list = g_slist_append(entry_list, entry);
+
+ if (dnsproxy_enabled)
+ __connman_dnsproxy_append(entry->index, domain, server);
+ else
+ __connman_resolvfile_append(entry->index, domain, server);
+
+ return 0;
+}
+
+/**
+ * connman_resolver_append:
+ * @index: network interface index
+ * @domain: domain limitation
+ * @server: server address
+ *
+ * Append resolver server address to current list
+ */
+int connman_resolver_append(int index, const char *domain,
+ const char *server)
+{
+ GSList *list;
+
+ DBG("index %d domain %s server %s", index, domain, server);
+
+ if (!server && !domain)
+ return -EINVAL;
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->timeout > 0)
+ continue;
+
+ if (entry->index == index &&
+ g_strcmp0(entry->domain, domain) == 0 &&
+ g_strcmp0(entry->server, server) == 0) {
+ if (dnsproxy_enabled)
+ __connman_dnsproxy_append(entry->index, domain,
+ server);
+
+ return -EEXIST;
+ }
+ }
+
+ return append_resolver(index, domain, server, 0, 0);
+}
+
+/**
+ * connman_resolver_append_lifetime:
+ * @index: network interface index
+ * @domain: domain limitation
+ * @server: server address
+ * @timeout: server lifetime in seconds
+ *
+ * Append resolver server address to current list
+ */
+int connman_resolver_append_lifetime(int index, const char *domain,
+ const char *server, unsigned int lifetime)
+{
+ GSList *list;
+ unsigned int interval;
+
+ DBG("index %d domain %s server %s lifetime %d",
+ index, domain, server, lifetime);
+
+ if (!server && !domain)
+ return -EINVAL;
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->timeout == 0 ||
+ entry->index != index ||
+ g_strcmp0(entry->domain, domain) != 0 ||
+ g_strcmp0(entry->server, server) != 0)
+ continue;
+
+ g_source_remove(entry->timeout);
+
+ if (lifetime == 0) {
+ resolver_expire_cb(entry);
+ return 0;
+ }
+
+ interval = lifetime * RESOLVER_LIFETIME_REFRESH_THRESHOLD;
+
+ DBG("RDNSS start index %d domain %s "
+ "server %s lifetime threshold %d",
+ index, domain, server, interval);
+
+ entry->timeout = g_timeout_add_seconds(interval,
+ resolver_refresh_cb, entry);
+ return 0;
+ }
+
+ return append_resolver(index, domain, server, lifetime, 0);
+}
+
+/**
+ * connman_resolver_remove:
+ * @index: network interface index
+ * @domain: domain limitation
+ * @server: server address
+ *
+ * Remover resolver server address from current list
+ */
+int connman_resolver_remove(int index, const char *domain, const char *server)
+{
+ GSList *list, *matches = NULL;
+
+ DBG("index %d domain %s server %s", index, domain, server);
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->index != index)
+ continue;
+
+ if (g_strcmp0(entry->domain, domain) != 0)
+ continue;
+
+ if (g_strcmp0(entry->server, server) != 0)
+ continue;
+
+ matches = g_slist_prepend(matches, entry);
+ break;
+ }
+
+ if (!matches)
+ return -ENOENT;
+
+ remove_entries(matches);
+
+ return 0;
+}
+
+/**
+ * connman_resolver_remove_all:
+ * @index: network interface index
+ *
+ * Remove all resolver server address for the specified interface index
+ */
+int connman_resolver_remove_all(int index)
+{
+ GSList *list, *matches = NULL;
+
+ DBG("index %d", index);
+
+ if (index < 0)
+ return -EINVAL;
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->index != index)
+ continue;
+
+ matches = g_slist_prepend(matches, entry);
+ }
+
+ if (!matches)
+ return -ENOENT;
+
+ remove_entries(matches);
+
+ return 0;
+}
+
+int __connman_resolver_redo_servers(int index)
+{
+ GSList *list;
+
+ if (!dnsproxy_enabled)
+ return 0;
+
+ DBG("index %d", index);
+
+ if (index < 0)
+ return -EINVAL;
+
+ for (list = entry_list; list; list = list->next) {
+ struct entry_data *entry = list->data;
+
+ if (entry->timeout == 0 || entry->index != index)
+ continue;
+
+ /*
+ * This function must only check IPv6 server addresses so
+ * do not remove IPv4 name servers unnecessarily.
+ */
+ if (entry->family != AF_INET6)
+ continue;
+
+ /*
+ * We remove the server, and then re-create so that it will
+ * use proper source addresses when sending DNS queries.
+ */
+ __connman_dnsproxy_remove(entry->index, entry->domain,
+ entry->server);
+
+ __connman_dnsproxy_append(entry->index, entry->domain,
+ entry->server);
+ }
+
+ return 0;
+}
+
+static void free_entry(gpointer data)
+{
+ struct entry_data *entry = data;
+ g_free(entry->domain);
+ g_free(entry->server);
+ g_free(entry);
+}
+
+static void free_resolvfile(gpointer data)
+{
+ struct resolvfile_entry *entry = data;
+ g_free(entry->domain);
+ g_free(entry->server);
+ g_free(entry);
+}
+
+int __connman_resolver_init(gboolean dnsproxy)
+{
+ int i;
+ char **ns;
+
+ DBG("dnsproxy %d", dnsproxy);
+
+ if (!dnsproxy)
+ return 0;
+
+ if (__connman_dnsproxy_init() < 0) {
+ /* Fall back to resolv.conf */
+ return 0;
+ }
+
+ dnsproxy_enabled = true;
+
+ ns = connman_setting_get_string_list("FallbackNameservers");
+ for (i = 0; ns && ns[i]; i += 1) {
+ DBG("server %s", ns[i]);
+ append_resolver(-1, NULL, ns[i], 0, RESOLVER_FLAG_PUBLIC);
+ }
+
+ return 0;
+}
+
+void __connman_resolver_cleanup(void)
+{
+ DBG("");
+
+ if (dnsproxy_enabled)
+ __connman_dnsproxy_cleanup();
+ else {
+ GList *list;
+ GSList *slist;
+
+ for (list = resolvfile_list; list; list = g_list_next(list))
+ free_resolvfile(list->data);
+ g_list_free(resolvfile_list);
+ resolvfile_list = NULL;
+
+ for (slist = entry_list; slist; slist = g_slist_next(slist))
+ free_entry(slist->data);
+ g_slist_free(entry_list);
+ entry_list = NULL;
+ }
+}
diff --git a/src/rfkill.c b/src/rfkill.c
new file mode 100644
index 0000000..ecd3aa6
--- /dev/null
+++ b/src/rfkill.c
@@ -0,0 +1,236 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "connman.h"
+
+enum rfkill_type {
+ RFKILL_TYPE_ALL = 0,
+ RFKILL_TYPE_WLAN,
+ RFKILL_TYPE_BLUETOOTH,
+ RFKILL_TYPE_UWB,
+ RFKILL_TYPE_WWAN,
+ RFKILL_TYPE_GPS,
+ RFKILL_TYPE_FM,
+ NUM_RFKILL_TYPES,
+};
+
+enum rfkill_operation {
+ RFKILL_OP_ADD = 0,
+ RFKILL_OP_DEL,
+ RFKILL_OP_CHANGE,
+ RFKILL_OP_CHANGE_ALL,
+};
+
+struct rfkill_event {
+ uint32_t idx;
+ uint8_t type;
+ uint8_t op;
+ uint8_t soft;
+ uint8_t hard;
+};
+
+static enum connman_service_type convert_type(uint8_t type)
+{
+ switch (type) {
+ case RFKILL_TYPE_WLAN:
+ return CONNMAN_SERVICE_TYPE_WIFI;
+ case RFKILL_TYPE_BLUETOOTH:
+ return CONNMAN_SERVICE_TYPE_BLUETOOTH;
+ case RFKILL_TYPE_WWAN:
+ return CONNMAN_SERVICE_TYPE_CELLULAR;
+ }
+
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+}
+
+static enum rfkill_type convert_service_type(enum connman_service_type type)
+{
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ return RFKILL_TYPE_WLAN;
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ return RFKILL_TYPE_BLUETOOTH;
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ return RFKILL_TYPE_WWAN;
+ case CONNMAN_SERVICE_TYPE_GPS:
+ return RFKILL_TYPE_GPS;
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ return NUM_RFKILL_TYPES;
+ }
+
+ return NUM_RFKILL_TYPES;
+}
+
+static GIOStatus rfkill_process(GIOChannel *chan)
+{
+ unsigned char buf[32];
+ struct rfkill_event *event = (void *) buf;
+ enum connman_service_type type;
+ gsize len;
+ GIOStatus status;
+
+ DBG("");
+
+ memset(buf, 0, sizeof(buf));
+
+ status = g_io_channel_read_chars(chan, (gchar *) buf,
+ sizeof(struct rfkill_event), &len, NULL);
+
+ if (status != G_IO_STATUS_NORMAL)
+ return status;
+
+ if (len != sizeof(struct rfkill_event))
+ return status;
+
+ DBG("idx %u type %u op %u soft %u hard %u", event->idx,
+ event->type, event->op,
+ event->soft, event->hard);
+
+ type = convert_type(event->type);
+
+ switch (event->op) {
+ case RFKILL_OP_ADD:
+ __connman_technology_add_rfkill(event->idx, type,
+ event->soft, event->hard);
+ break;
+ case RFKILL_OP_DEL:
+ __connman_technology_remove_rfkill(event->idx, type);
+ break;
+ case RFKILL_OP_CHANGE:
+ __connman_technology_update_rfkill(event->idx, type,
+ event->soft, event->hard);
+ break;
+ default:
+ break;
+ }
+
+ return status;
+}
+
+static gboolean rfkill_event(GIOChannel *chan, GIOCondition cond, gpointer data)
+{
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ if (rfkill_process(chan) == G_IO_STATUS_ERROR)
+ return FALSE;
+
+ return TRUE;
+}
+
+static guint watch = 0;
+
+int __connman_rfkill_block(enum connman_service_type type, bool block)
+{
+ uint8_t rfkill_type;
+ struct rfkill_event event;
+ ssize_t len;
+ int fd, err = 0;
+
+ DBG("type %d block %d", type, block);
+
+ rfkill_type = convert_service_type(type);
+ if (rfkill_type == NUM_RFKILL_TYPES)
+ return -EINVAL;
+
+ fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC);
+ if (fd < 0)
+ return -errno;
+
+ memset(&event, 0, sizeof(event));
+ event.op = RFKILL_OP_CHANGE_ALL;
+ event.type = rfkill_type;
+ event.soft = block;
+
+ len = write(fd, &event, sizeof(event));
+ if (len < 0) {
+ err = -errno;
+ connman_error("Failed to change RFKILL state");
+ }
+
+ close(fd);
+
+ return err;
+}
+
+int __connman_rfkill_init(void)
+{
+ GIOChannel *channel;
+ GIOFlags flags;
+ int fd;
+
+ DBG("");
+
+ fd = open("/dev/rfkill", O_RDWR | O_CLOEXEC);
+ if (fd < 0) {
+ connman_error("Failed to open RFKILL control device");
+ return -EIO;
+ }
+
+ channel = g_io_channel_unix_new(fd);
+ g_io_channel_set_close_on_unref(channel, TRUE);
+
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ flags = g_io_channel_get_flags(channel);
+ flags |= G_IO_FLAG_NONBLOCK;
+ g_io_channel_set_flags(channel, flags, NULL);
+
+ /* Process current RFKILL events sent on device open */
+ while (rfkill_process(channel) == G_IO_STATUS_NORMAL);
+
+ watch = g_io_add_watch(channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ rfkill_event, NULL);
+
+ g_io_channel_unref(channel);
+
+ return watch ? 0 : -EIO;
+}
+
+void __connman_rfkill_cleanup(void)
+{
+ DBG("");
+
+ if (watch) {
+ g_source_remove(watch);
+ watch = 0;
+ }
+}
diff --git a/src/rlimits.c b/src/rlimits.c
new file mode 100644
index 0000000..2499bc1
--- /dev/null
+++ b/src/rlimits.c
@@ -0,0 +1,236 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011 Nest Labs, Inc. All rights reserved.
+ *
+ * Author: Grant Erickson <grant@nestlabs.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#include <sys/resource.h>
+
+#include <glib.h>
+
+#include <connman/log.h>
+
+#define CONNMAN_RLIMIT_SET(r, lp, err, label) \
+ do { \
+ err = __connman_rlimit_set(r, lp, #r); \
+ if (err < 0) \
+ goto label; \
+ } while (0)
+
+struct connman_rlimit {
+ gboolean set;
+ rlim_t limit;
+};
+
+struct connman_rlimits {
+#if defined(RLIMIT_AS)
+ struct connman_rlimit as;
+#endif
+ struct connman_rlimit core, data, fsize, nofile, stack;
+#if defined(RLIMIT_MEMLOCK)
+ struct connman_rlimit memlock;
+#endif
+#if defined(RLIMIT_NPROC)
+ struct connman_rlimit nproc;
+#endif
+};
+
+#if defined(RLIMIT_AS)
+static const char * RLIMIT_AS_KEY = "rlimit-as";
+#endif
+static const char * RLIMIT_CORE_KEY = "rlimit-core";
+static const char * RLIMIT_DATA_KEY = "rlimit-data";
+static const char * RLIMIT_FSIZE_KEY = "rlimit-fsize";
+static const char * RLIMIT_NOFILE_KEY = "rlimit-nofile";
+static const char * RLIMIT_STACK_KEY = "rlimit-stack";
+#if defined(RLIMIT_NPROC)
+static const char * RLIMIT_NPROC_KEY = "rlimit-nproc";
+#endif
+#if defined(RLIMIT_MEMLOCK)
+static const char * RLIMIT_MEMLOCK_KEY = "rlimit-memlock";
+#endif
+
+static int set_one_rlimit(int resource, rlim_t limit, const char *name)
+{
+ int err;
+ struct rlimit rl;
+ rl.rlim_cur = rl.rlim_max = limit;
+
+ DBG("resource %d limit %u name %s", resource, (unsigned)limit, name);
+
+ err = setrlimit(resource, &rl);
+
+ if (err < 0) {
+ connman_warn("setrlimit(%s, {%u, %u}) failed: %s",
+ name, (unsigned)limit,
+ (unsigned)limit,
+ strerror(errno));
+
+ return -errno;
+ }
+
+ return err;
+}
+
+static inline int __connman_rlimit_set(int resource,
+ const struct connman_rlimit *limit,
+ const char *name)
+{
+ int err = 0;
+
+ if (limit->set)
+ err = set_one_rlimit(resource, limit->limit, name);
+
+ return err;
+}
+
+static int __connman_rlimits_enforce(const struct connman_rlimits *limits)
+{
+ int err;
+
+ if (limits == NULL)
+ return 0;
+
+#if defined(RLIMIT_AS)
+ CONNMAN_RLIMIT_SET(RLIMIT_AS, &limits->as, err, done);
+#endif
+ CONNMAN_RLIMIT_SET(RLIMIT_CORE, &limits->core, err, done);
+ CONNMAN_RLIMIT_SET(RLIMIT_DATA, &limits->data, err, done);
+ CONNMAN_RLIMIT_SET(RLIMIT_FSIZE, &limits->fsize, err, done);
+ CONNMAN_RLIMIT_SET(RLIMIT_NOFILE, &limits->nofile, err, done);
+ CONNMAN_RLIMIT_SET(RLIMIT_STACK, &limits->stack, err, done);
+#if defined(RLIMIT_MEMLOCK)
+ CONNMAN_RLIMIT_SET(RLIMIT_MEMLOCK, &limits->memlock, err, done);
+#endif
+#if defined(RLIMIT_NPROC)
+ CONNMAN_RLIMIT_SET(RLIMIT_NPROC, &limits->nproc, err, done);
+#endif
+
+ done:
+ return err;
+}
+
+static void __connman_rlimit_read(GKeyFile *keyfile, const gchar *key,
+ struct connman_rlimit *limit)
+{
+ const char *group = "rlimits";
+ gint temp;
+ GError *error = NULL;
+
+ if (keyfile != NULL && key != NULL && limit != NULL) {
+ temp = g_key_file_get_integer(keyfile, group, key, &error);
+
+ DBG("key %s temp %d error %p", key, temp, error);
+
+ if (error == NULL) {
+ limit->set = TRUE;
+ limit->limit = temp;
+ } else {
+ limit->set = FALSE;
+ limit->limit = 0;
+ g_clear_error(&error);
+ }
+
+ DBG("set %u limit %u", limit->set, (unsigned)limit->limit);
+ }
+}
+
+static GKeyFile *__connman_rlimits_open(const gchar *path)
+{
+ GKeyFile *keyfile;
+ gchar *data = NULL;
+ gboolean result;
+ gsize length;
+
+ DBG("path %s", path);
+
+ result = g_file_get_contents(path, &data, &length, NULL);
+
+ keyfile = g_key_file_new();
+
+ if (result == FALSE)
+ goto done;
+
+ if (length > 0)
+ g_key_file_load_from_data(keyfile, data, length, 0, NULL);
+
+ g_free(data);
+
+done:
+ DBG("keyfile %p", keyfile);
+
+ return keyfile;
+}
+
+static int __connman_rlimits_load(const gchar *path,
+ struct connman_rlimits *limits)
+{
+ GKeyFile *keyfile;
+
+ if (limits == NULL)
+ return -EINVAL;
+
+ keyfile = __connman_rlimits_open(path);
+
+ if (keyfile == NULL)
+ return -EIO;
+
+#if defined(RLIMIT_AS)
+ __connman_rlimit_read(keyfile, RLIMIT_AS_KEY, &limits->as);
+#endif
+ __connman_rlimit_read(keyfile, RLIMIT_CORE_KEY, &limits->core);
+ __connman_rlimit_read(keyfile, RLIMIT_DATA_KEY, &limits->data);
+ __connman_rlimit_read(keyfile, RLIMIT_FSIZE_KEY, &limits->fsize);
+ __connman_rlimit_read(keyfile, RLIMIT_NOFILE_KEY, &limits->nofile);
+ __connman_rlimit_read(keyfile, RLIMIT_STACK_KEY, &limits->stack);
+#if defined(RLIMIT_NPROC)
+ __connman_rlimit_read(keyfile, RLIMIT_NPROC_KEY, &limits->nproc);
+#endif
+#if defined(RLIMIT_MEMLOCK)
+ __connman_rlimit_read(keyfile, RLIMIT_MEMLOCK_KEY, &limits->memlock);
+#endif
+
+ g_key_file_free(keyfile);
+
+ return 0;
+}
+
+int __connman_rlimits_init(const gchar *path)
+{
+ struct connman_rlimits rlimits;
+ int err;
+
+ if (path == NULL)
+ return -EINVAL;
+
+ err = __connman_rlimits_load(path, &rlimits);
+
+ if (err < 0)
+ return err;
+
+ return __connman_rlimits_enforce(&rlimits);
+}
diff --git a/src/rtnl.c b/src/rtnl.c
new file mode 100644
index 0000000..409729c
--- /dev/null
+++ b/src/rtnl.c
@@ -0,0 +1,1699 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <netinet/ether.h>
+#include <netinet/icmp6.h>
+#include <net/if_arp.h>
+#include <linux/if.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <linux/wireless.h>
+
+#include <glib.h>
+
+#include "connman.h"
+
+#ifndef ARPHDR_PHONET_PIPE
+#define ARPHDR_PHONET_PIPE (821)
+#endif
+
+#define print(arg...) do { if (0) connman_info(arg); } while (0)
+//#define print(arg...) connman_info(arg)
+
+struct watch_data {
+ unsigned int id;
+ int index;
+ connman_rtnl_link_cb_t newlink;
+ void *user_data;
+};
+
+static GSList *watch_list = NULL;
+static unsigned int watch_id = 0;
+
+static GSList *update_list = NULL;
+static guint update_interval = G_MAXUINT;
+static guint update_timeout = 0;
+
+struct interface_data {
+ int index;
+ char *ident;
+ enum connman_service_type service_type;
+ enum connman_device_type device_type;
+};
+
+static GHashTable *interface_list = NULL;
+
+static void free_interface(gpointer data)
+{
+ struct interface_data *interface = data;
+
+ __connman_technology_remove_interface(interface->service_type,
+ interface->index, interface->ident);
+
+ g_free(interface->ident);
+ g_free(interface);
+}
+
+static bool ether_blacklisted(const char *name)
+{
+ if (!name)
+ return true;
+
+ if (__connman_device_isfiltered(name))
+ return true;
+
+ return false;
+}
+
+static bool wext_interface(char *ifname)
+{
+ struct iwreq wrq;
+ int fd, err;
+
+ fd = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (fd < 0)
+ return false;
+
+ memset(&wrq, 0, sizeof(wrq));
+ strncpy(wrq.ifr_name, ifname, sizeof(wrq.ifr_name) - 1);
+
+ err = ioctl(fd, SIOCGIWNAME, &wrq);
+
+ close(fd);
+
+ if (err < 0)
+ return false;
+
+ return true;
+}
+
+static void read_uevent(struct interface_data *interface)
+{
+ char *filename, *name, line[128];
+ bool found_devtype;
+ FILE *f;
+
+ name = connman_inet_ifname(interface->index);
+
+ if (ether_blacklisted(name)) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
+ interface->device_type = CONNMAN_DEVICE_TYPE_UNKNOWN;
+ } else {
+ interface->service_type = CONNMAN_SERVICE_TYPE_ETHERNET;
+ interface->device_type = CONNMAN_DEVICE_TYPE_ETHERNET;
+ }
+
+ filename = g_strdup_printf("/sys/class/net/%s/uevent", name);
+
+ f = fopen(filename, "re");
+
+ g_free(filename);
+
+ if (!f) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
+ interface->device_type = CONNMAN_DEVICE_TYPE_UNKNOWN;
+ goto out;
+ }
+
+ found_devtype = false;
+ while (fgets(line, sizeof(line), f)) {
+ char *pos;
+
+ pos = strchr(line, '\n');
+ if (!pos)
+ continue;
+ pos[0] = '\0';
+
+ if (strncmp(line, "DEVTYPE=", 8) != 0)
+ continue;
+
+ found_devtype = true;
+
+ if (strcmp(line + 8, "wlan") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_WIFI;
+ interface->device_type = CONNMAN_DEVICE_TYPE_WIFI;
+ } else if (strcmp(line + 8, "wwan") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_CELLULAR;
+ interface->device_type = CONNMAN_DEVICE_TYPE_CELLULAR;
+ } else if (strcmp(line + 8, "bluetooth") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
+ interface->device_type = CONNMAN_DEVICE_TYPE_BLUETOOTH;
+ } else if (strcmp(line + 8, "gadget") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_GADGET;
+ interface->device_type = CONNMAN_DEVICE_TYPE_GADGET;
+ } else if (strcmp(line + 8, "vlan") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_ETHERNET;
+ interface->device_type = CONNMAN_DEVICE_TYPE_ETHERNET;
+ } else if (strcmp(line + 8, "lowpan") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_LOWPAN;
+ interface->device_type = CONNMAN_DEVICE_TYPE_LOWPAN;
+ } else if (strcmp(line + 8, "lowpan") == 0) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_LOWPAN;
+ interface->device_type = CONNMAN_DEVICE_TYPE_LOWPAN;
+ } else {
+ interface->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
+ interface->device_type = CONNMAN_DEVICE_TYPE_UNKNOWN;
+ }
+ }
+
+ fclose(f);
+
+ if (found_devtype)
+ goto out;
+
+ /* We haven't got a DEVTYPE, let's check if it's a wireless device */
+ if (wext_interface(name)) {
+ interface->service_type = CONNMAN_SERVICE_TYPE_WIFI;
+ interface->device_type = CONNMAN_DEVICE_TYPE_WIFI;
+
+ connman_error("%s runs an unsupported 802.11 driver", name);
+ }
+
+out:
+ g_free(name);
+}
+
+enum connman_device_type __connman_rtnl_get_device_type(int index)
+{
+ struct interface_data *interface;
+
+ interface = g_hash_table_lookup(interface_list,
+ GINT_TO_POINTER(index));
+ if (!interface)
+ return CONNMAN_DEVICE_TYPE_UNKNOWN;
+
+ return interface->device_type;
+}
+
+/**
+ * connman_rtnl_add_newlink_watch:
+ * @index: network device index
+ * @callback: callback function
+ * @user_data: callback data;
+ *
+ * Add a new RTNL watch for newlink events
+ *
+ * Returns: %0 on failure and a unique id on success
+ */
+unsigned int connman_rtnl_add_newlink_watch(int index,
+ connman_rtnl_link_cb_t callback, void *user_data)
+{
+ struct watch_data *watch;
+
+ watch = g_try_new0(struct watch_data, 1);
+ if (!watch)
+ return 0;
+
+ watch->id = ++watch_id;
+ watch->index = index;
+
+ watch->newlink = callback;
+ watch->user_data = user_data;
+
+ watch_list = g_slist_prepend(watch_list, watch);
+
+ DBG("id %d", watch->id);
+
+ if (callback) {
+ unsigned int flags = __connman_ipconfig_get_flags_from_index(index);
+
+ if (flags > 0)
+ callback(flags, 0, user_data);
+ }
+
+ return watch->id;
+}
+
+/**
+ * connman_rtnl_remove_watch:
+ * @id: watch identifier
+ *
+ * Remove the RTNL watch for the identifier
+ */
+void connman_rtnl_remove_watch(unsigned int id)
+{
+ GSList *list;
+
+ DBG("id %d", id);
+
+ if (id == 0)
+ return;
+
+ for (list = watch_list; list; list = list->next) {
+ struct watch_data *watch = list->data;
+
+ if (watch->id == id) {
+ watch_list = g_slist_remove(watch_list, watch);
+ g_free(watch);
+ break;
+ }
+ }
+}
+
+static void trigger_rtnl(int index, void *user_data)
+{
+ struct connman_rtnl *rtnl = user_data;
+
+ if (rtnl->newlink) {
+ unsigned short type = __connman_ipconfig_get_type_from_index(index);
+ unsigned int flags = __connman_ipconfig_get_flags_from_index(index);
+
+ rtnl->newlink(type, index, flags, 0);
+ }
+
+ if (rtnl->newgateway) {
+ const char *gateway =
+ __connman_ipconfig_get_gateway_from_index(index,
+ CONNMAN_IPCONFIG_TYPE_ALL);
+
+ if (gateway)
+ rtnl->newgateway(index, gateway);
+ }
+}
+
+static GSList *rtnl_list = NULL;
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_rtnl *rtnl1 = a;
+ const struct connman_rtnl *rtnl2 = b;
+
+ return rtnl2->priority - rtnl1->priority;
+}
+
+/**
+ * connman_rtnl_register:
+ * @rtnl: RTNL module
+ *
+ * Register a new RTNL module
+ *
+ * Returns: %0 on success
+ */
+int connman_rtnl_register(struct connman_rtnl *rtnl)
+{
+ DBG("rtnl %p name %s", rtnl, rtnl->name);
+
+ rtnl_list = g_slist_insert_sorted(rtnl_list, rtnl,
+ compare_priority);
+
+ __connman_ipconfig_foreach(trigger_rtnl, rtnl);
+
+ return 0;
+}
+
+/**
+ * connman_rtnl_unregister:
+ * @rtnl: RTNL module
+ *
+ * Remove a previously registered RTNL module
+ */
+void connman_rtnl_unregister(struct connman_rtnl *rtnl)
+{
+ DBG("rtnl %p name %s", rtnl, rtnl->name);
+
+ rtnl_list = g_slist_remove(rtnl_list, rtnl);
+}
+
+static const char *operstate2str(unsigned char operstate)
+{
+ switch (operstate) {
+ case IF_OPER_UNKNOWN:
+ return "UNKNOWN";
+ case IF_OPER_NOTPRESENT:
+ return "NOT-PRESENT";
+ case IF_OPER_DOWN:
+ return "DOWN";
+ case IF_OPER_LOWERLAYERDOWN:
+ return "LOWER-LAYER-DOWN";
+ case IF_OPER_TESTING:
+ return "TESTING";
+ case IF_OPER_DORMANT:
+ return "DORMANT";
+ case IF_OPER_UP:
+ return "UP";
+ }
+
+ return "";
+}
+
+static bool extract_link(struct ifinfomsg *msg, int bytes,
+ struct ether_addr *address, const char **ifname,
+ unsigned int *mtu, unsigned char *operstate,
+ struct rtnl_link_stats *stats)
+{
+ struct rtattr *attr;
+
+ for (attr = IFLA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFLA_ADDRESS:
+ if (address)
+ memcpy(address, RTA_DATA(attr), ETH_ALEN);
+ break;
+ case IFLA_IFNAME:
+ if (ifname)
+ *ifname = RTA_DATA(attr);
+ break;
+ case IFLA_MTU:
+ if (mtu)
+ *mtu = *((unsigned int *) RTA_DATA(attr));
+ break;
+ case IFLA_STATS:
+ if (stats)
+ memcpy(stats, RTA_DATA(attr),
+ sizeof(struct rtnl_link_stats));
+ break;
+ case IFLA_OPERSTATE:
+ if (operstate)
+ *operstate = *((unsigned char *) RTA_DATA(attr));
+ break;
+ case IFLA_LINKMODE:
+ break;
+ case IFLA_WIRELESS:
+ return false;
+ }
+ }
+
+ return true;
+}
+
+static void process_newlink(unsigned short type, int index, unsigned flags,
+ unsigned change, struct ifinfomsg *msg, int bytes)
+{
+ struct ether_addr address = {{ 0, 0, 0, 0, 0, 0 }};
+ struct rtnl_link_stats stats;
+ unsigned char operstate = 0xff;
+ struct interface_data *interface;
+ const char *ifname = NULL;
+ unsigned int mtu = 0;
+ char ident[13], str[18];
+ GSList *list;
+
+ memset(&stats, 0, sizeof(stats));
+ if (!extract_link(msg, bytes, &address, &ifname, &mtu, &operstate, &stats))
+ return;
+
+ snprintf(ident, 13, "%02x%02x%02x%02x%02x%02x",
+ address.ether_addr_octet[0],
+ address.ether_addr_octet[1],
+ address.ether_addr_octet[2],
+ address.ether_addr_octet[3],
+ address.ether_addr_octet[4],
+ address.ether_addr_octet[5]);
+
+ snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
+ address.ether_addr_octet[0],
+ address.ether_addr_octet[1],
+ address.ether_addr_octet[2],
+ address.ether_addr_octet[3],
+ address.ether_addr_octet[4],
+ address.ether_addr_octet[5]);
+
+ if (flags & IFF_SLAVE) {
+ connman_info("%s {newlink} ignoring slave, index %d address %s",
+ ifname, index, str);
+ return;
+ }
+
+ switch (type) {
+ case ARPHRD_ETHER:
+ case ARPHRD_LOOPBACK:
+ case ARPHDR_PHONET_PIPE:
+ case ARPHRD_PPP:
+ case ARPHRD_NONE:
+ __connman_ipconfig_newlink(index, type, flags,
+ str, mtu, &stats);
+ break;
+ }
+
+ connman_info("%s {newlink} index %d address %s mtu %u",
+ ifname, index, str, mtu);
+
+ if (operstate != 0xff)
+ connman_info("%s {newlink} index %d operstate %u <%s>",
+ ifname, index, operstate,
+ operstate2str(operstate));
+
+ interface = g_hash_table_lookup(interface_list, GINT_TO_POINTER(index));
+ if (!interface) {
+ interface = g_new0(struct interface_data, 1);
+ interface->index = index;
+ interface->ident = g_strdup(ident);
+
+ g_hash_table_insert(interface_list,
+ GINT_TO_POINTER(index), interface);
+
+ if (type == ARPHRD_ETHER)
+ read_uevent(interface);
+ } else
+ interface = NULL;
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct connman_rtnl *rtnl = list->data;
+
+ if (rtnl->newlink)
+ rtnl->newlink(type, index, flags, change);
+ }
+
+ /*
+ * The interface needs to be added after the newlink call.
+ * The newlink will create the technology when needed and
+ * __connman_technology_add_interface() expects the
+ * technology to be there already.
+ */
+ if (interface)
+ __connman_technology_add_interface(interface->service_type,
+ interface->index, interface->ident);
+
+ for (list = watch_list; list; list = list->next) {
+ struct watch_data *watch = list->data;
+
+ if (watch->index != index)
+ continue;
+
+ if (watch->newlink)
+ watch->newlink(flags, change, watch->user_data);
+ }
+}
+
+static void process_dellink(unsigned short type, int index, unsigned flags,
+ unsigned change, struct ifinfomsg *msg, int bytes)
+{
+ struct rtnl_link_stats stats;
+ unsigned char operstate = 0xff;
+ const char *ifname = NULL;
+ GSList *list;
+
+ memset(&stats, 0, sizeof(stats));
+ if (!extract_link(msg, bytes, NULL, &ifname, NULL, &operstate, &stats))
+ return;
+
+ if (operstate != 0xff)
+ connman_info("%s {dellink} index %d operstate %u <%s>",
+ ifname, index, operstate,
+ operstate2str(operstate));
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct connman_rtnl *rtnl = list->data;
+
+ if (rtnl->dellink)
+ rtnl->dellink(type, index, flags, change);
+ }
+
+ switch (type) {
+ case ARPHRD_ETHER:
+ case ARPHRD_LOOPBACK:
+ case ARPHDR_PHONET_PIPE:
+ case ARPHRD_PPP:
+ case ARPHRD_NONE:
+ __connman_ipconfig_dellink(index, &stats);
+ break;
+ }
+
+ g_hash_table_remove(interface_list, GINT_TO_POINTER(index));
+}
+
+static void extract_ipv4_addr(struct ifaddrmsg *msg, int bytes,
+ const char **label,
+ struct in_addr *local,
+ struct in_addr *address,
+ struct in_addr *broadcast)
+{
+ struct rtattr *attr;
+
+ for (attr = IFA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFA_ADDRESS:
+ if (address)
+ *address = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case IFA_LOCAL:
+ if (local)
+ *local = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case IFA_BROADCAST:
+ if (broadcast)
+ *broadcast = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case IFA_LABEL:
+ if (label)
+ *label = RTA_DATA(attr);
+ break;
+ }
+ }
+}
+
+static void extract_ipv6_addr(struct ifaddrmsg *msg, int bytes,
+ struct in6_addr *addr,
+ struct in6_addr *local)
+{
+ struct rtattr *attr;
+
+ for (attr = IFA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFA_ADDRESS:
+ if (addr)
+ *addr = *((struct in6_addr *) RTA_DATA(attr));
+ break;
+ case IFA_LOCAL:
+ if (local)
+ *local = *((struct in6_addr *) RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+static void process_newaddr(unsigned char family, unsigned char prefixlen,
+ int index, struct ifaddrmsg *msg, int bytes)
+{
+ struct in_addr ipv4_addr = { INADDR_ANY };
+ struct in6_addr ipv6_address, ipv6_local;
+ const char *label = NULL;
+ void *src;
+ char ip_string[INET6_ADDRSTRLEN];
+
+ if (family == AF_INET) {
+
+ extract_ipv4_addr(msg, bytes, &label, &ipv4_addr, NULL, NULL);
+ src = &ipv4_addr;
+ } else if (family == AF_INET6) {
+ extract_ipv6_addr(msg, bytes, &ipv6_address, &ipv6_local);
+ if (IN6_IS_ADDR_LINKLOCAL(&ipv6_address))
+ return;
+
+ src = &ipv6_address;
+ } else {
+ return;
+ }
+
+ if (!inet_ntop(family, src, ip_string, INET6_ADDRSTRLEN))
+ return;
+
+ if (__connman_ipconfig_newaddr(index, family, label,
+ prefixlen, ip_string) >= 0) {
+ if (family == AF_INET6) {
+ /*
+ * Re-create RDNSS configured servers if there
+ * are any for this interface. This is done
+ * because we might have now properly
+ * configured interface with proper
+ * autoconfigured address.
+ */
+ __connman_resolver_redo_servers(index);
+ }
+ }
+}
+
+static void process_deladdr(unsigned char family, unsigned char prefixlen,
+ int index, struct ifaddrmsg *msg, int bytes)
+{
+ struct in_addr ipv4_addr = { INADDR_ANY };
+ struct in6_addr ipv6_address, ipv6_local;
+ const char *label = NULL;
+ void *src;
+ char ip_string[INET6_ADDRSTRLEN];
+
+ if (family == AF_INET) {
+ extract_ipv4_addr(msg, bytes, &label, &ipv4_addr, NULL, NULL);
+ src = &ipv4_addr;
+ } else if (family == AF_INET6) {
+ extract_ipv6_addr(msg, bytes, &ipv6_address, &ipv6_local);
+ if (IN6_IS_ADDR_LINKLOCAL(&ipv6_address))
+ return;
+
+ src = &ipv6_address;
+ } else {
+ return;
+ }
+
+ if (!inet_ntop(family, src, ip_string, INET6_ADDRSTRLEN))
+ return;
+
+ __connman_ipconfig_deladdr(index, family, label,
+ prefixlen, ip_string);
+}
+
+static void extract_ipv4_route(struct rtmsg *msg, int bytes, int *index,
+ struct in_addr *dst,
+ struct in_addr *gateway)
+{
+ struct rtattr *attr;
+
+ for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ if (dst)
+ *dst = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case RTA_GATEWAY:
+ if (gateway)
+ *gateway = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case RTA_OIF:
+ if (index)
+ *index = *((int *) RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+static void extract_ipv6_route(struct rtmsg *msg, int bytes, int *index,
+ struct in6_addr *dst,
+ struct in6_addr *gateway)
+{
+ struct rtattr *attr;
+
+ for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ if (dst)
+ *dst = *((struct in6_addr *) RTA_DATA(attr));
+ break;
+ case RTA_GATEWAY:
+ if (gateway)
+ *gateway =
+ *((struct in6_addr *) RTA_DATA(attr));
+ break;
+ case RTA_OIF:
+ if (index)
+ *index = *((int *) RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+static void process_newroute(unsigned char family, unsigned char scope,
+ struct rtmsg *msg, int bytes)
+{
+ GSList *list;
+ char dststr[INET6_ADDRSTRLEN], gatewaystr[INET6_ADDRSTRLEN];
+ int index = -1;
+
+ if (family == AF_INET) {
+ struct in_addr dst = { INADDR_ANY }, gateway = { INADDR_ANY };
+
+ extract_ipv4_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ __connman_ipconfig_newroute(index, family, scope, dststr,
+ gatewaystr);
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK && dst.s_addr == INADDR_ANY))
+ return;
+
+ if (dst.s_addr != INADDR_ANY)
+ return;
+
+ } else if (family == AF_INET6) {
+ struct in6_addr dst = IN6ADDR_ANY_INIT,
+ gateway = IN6ADDR_ANY_INIT;
+
+ extract_ipv6_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ __connman_ipconfig_newroute(index, family, scope, dststr,
+ gatewaystr);
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK &&
+ IN6_IS_ADDR_UNSPECIFIED(&dst)))
+ return;
+
+ if (!IN6_IS_ADDR_UNSPECIFIED(&dst))
+ return;
+ } else
+ return;
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct connman_rtnl *rtnl = list->data;
+
+ if (rtnl->newgateway)
+ rtnl->newgateway(index, gatewaystr);
+ }
+}
+
+static void process_delroute(unsigned char family, unsigned char scope,
+ struct rtmsg *msg, int bytes)
+{
+ GSList *list;
+ char dststr[INET6_ADDRSTRLEN], gatewaystr[INET6_ADDRSTRLEN];
+ int index = -1;
+
+ if (family == AF_INET) {
+ struct in_addr dst = { INADDR_ANY }, gateway = { INADDR_ANY };
+
+ extract_ipv4_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ __connman_ipconfig_delroute(index, family, scope, dststr,
+ gatewaystr);
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK && dst.s_addr == INADDR_ANY))
+ return;
+
+ if (dst.s_addr != INADDR_ANY)
+ return;
+
+ } else if (family == AF_INET6) {
+ struct in6_addr dst = IN6ADDR_ANY_INIT,
+ gateway = IN6ADDR_ANY_INIT;
+
+ extract_ipv6_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ __connman_ipconfig_delroute(index, family, scope, dststr,
+ gatewaystr);
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK &&
+ IN6_IS_ADDR_UNSPECIFIED(&dst)))
+ return;
+
+ if (!IN6_IS_ADDR_UNSPECIFIED(&dst))
+ return;
+ } else
+ return;
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct connman_rtnl *rtnl = list->data;
+
+ if (rtnl->delgateway)
+ rtnl->delgateway(index, gatewaystr);
+ }
+}
+
+static inline void print_ether(struct rtattr *attr, const char *name)
+{
+ int len = (int) RTA_PAYLOAD(attr);
+
+ if (len == ETH_ALEN) {
+ struct ether_addr eth;
+ memcpy(ð, RTA_DATA(attr), ETH_ALEN);
+ print(" attr %s (len %d) %s\n", name, len, ether_ntoa(ð));
+ } else
+ print(" attr %s (len %d)\n", name, len);
+}
+
+static inline void print_inet(struct rtattr *attr, const char *name,
+ unsigned char family)
+{
+ int len = (int) RTA_PAYLOAD(attr);
+
+ if (family == AF_INET && len == sizeof(struct in_addr)) {
+ struct in_addr addr;
+ addr = *((struct in_addr *) RTA_DATA(attr));
+ print(" attr %s (len %d) %s\n", name, len, inet_ntoa(addr));
+ } else
+ print(" attr %s (len %d)\n", name, len);
+}
+
+static inline void print_string(struct rtattr *attr, const char *name)
+{
+ print(" attr %s (len %d) %s\n", name, (int) RTA_PAYLOAD(attr),
+ (char *) RTA_DATA(attr));
+}
+
+static inline void print_byte(struct rtattr *attr, const char *name)
+{
+ print(" attr %s (len %d) 0x%02x\n", name, (int) RTA_PAYLOAD(attr),
+ *((unsigned char *) RTA_DATA(attr)));
+}
+
+static inline void print_integer(struct rtattr *attr, const char *name)
+{
+ print(" attr %s (len %d) %d\n", name, (int) RTA_PAYLOAD(attr),
+ *((int *) RTA_DATA(attr)));
+}
+
+static inline void print_attr(struct rtattr *attr, const char *name)
+{
+ int len = (int) RTA_PAYLOAD(attr);
+
+ if (name && len > 0)
+ print(" attr %s (len %d)\n", name, len);
+ else
+ print(" attr %d (len %d)\n", attr->rta_type, len);
+}
+
+static void rtnl_link(struct nlmsghdr *hdr)
+{
+ struct ifinfomsg *msg;
+ struct rtattr *attr;
+ int bytes;
+
+ msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
+ bytes = IFLA_PAYLOAD(hdr);
+
+ print("ifi_index %d ifi_flags 0x%04x", msg->ifi_index, msg->ifi_flags);
+
+ for (attr = IFLA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFLA_ADDRESS:
+ print_ether(attr, "address");
+ break;
+ case IFLA_BROADCAST:
+ print_ether(attr, "broadcast");
+ break;
+ case IFLA_IFNAME:
+ print_string(attr, "ifname");
+ break;
+ case IFLA_MTU:
+ print_integer(attr, "mtu");
+ break;
+ case IFLA_LINK:
+ print_attr(attr, "link");
+ break;
+ case IFLA_QDISC:
+ print_attr(attr, "qdisc");
+ break;
+ case IFLA_STATS:
+ print_attr(attr, "stats");
+ break;
+ case IFLA_COST:
+ print_attr(attr, "cost");
+ break;
+ case IFLA_PRIORITY:
+ print_attr(attr, "priority");
+ break;
+ case IFLA_MASTER:
+ print_attr(attr, "master");
+ break;
+ case IFLA_WIRELESS:
+ print_attr(attr, "wireless");
+ break;
+ case IFLA_PROTINFO:
+ print_attr(attr, "protinfo");
+ break;
+ case IFLA_TXQLEN:
+ print_integer(attr, "txqlen");
+ break;
+ case IFLA_MAP:
+ print_attr(attr, "map");
+ break;
+ case IFLA_WEIGHT:
+ print_attr(attr, "weight");
+ break;
+ case IFLA_OPERSTATE:
+ print_byte(attr, "operstate");
+ break;
+ case IFLA_LINKMODE:
+ print_byte(attr, "linkmode");
+ break;
+ default:
+ print_attr(attr, NULL);
+ break;
+ }
+ }
+}
+
+static void rtnl_newlink(struct nlmsghdr *hdr)
+{
+ struct ifinfomsg *msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
+
+ rtnl_link(hdr);
+
+ if (hdr->nlmsg_type == IFLA_WIRELESS)
+ connman_warn_once("Obsolete WEXT WiFi driver detected");
+
+ process_newlink(msg->ifi_type, msg->ifi_index, msg->ifi_flags,
+ msg->ifi_change, msg, IFA_PAYLOAD(hdr));
+}
+
+static void rtnl_dellink(struct nlmsghdr *hdr)
+{
+ struct ifinfomsg *msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
+
+ rtnl_link(hdr);
+
+ process_dellink(msg->ifi_type, msg->ifi_index, msg->ifi_flags,
+ msg->ifi_change, msg, IFA_PAYLOAD(hdr));
+}
+
+static void rtnl_addr(struct nlmsghdr *hdr)
+{
+ struct ifaddrmsg *msg;
+ struct rtattr *attr;
+ int bytes;
+
+ msg = (struct ifaddrmsg *) NLMSG_DATA(hdr);
+ bytes = IFA_PAYLOAD(hdr);
+
+ print("ifa_family %d ifa_index %d", msg->ifa_family, msg->ifa_index);
+
+ for (attr = IFA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFA_ADDRESS:
+ print_inet(attr, "address", msg->ifa_family);
+ break;
+ case IFA_LOCAL:
+ print_inet(attr, "local", msg->ifa_family);
+ break;
+ case IFA_LABEL:
+ print_string(attr, "label");
+ break;
+ case IFA_BROADCAST:
+ print_inet(attr, "broadcast", msg->ifa_family);
+ break;
+ case IFA_ANYCAST:
+ print_attr(attr, "anycast");
+ break;
+ case IFA_CACHEINFO:
+ print_attr(attr, "cacheinfo");
+ break;
+ case IFA_MULTICAST:
+ print_attr(attr, "multicast");
+ break;
+ default:
+ print_attr(attr, NULL);
+ break;
+ }
+ }
+}
+
+static void rtnl_newaddr(struct nlmsghdr *hdr)
+{
+ struct ifaddrmsg *msg = (struct ifaddrmsg *) NLMSG_DATA(hdr);
+
+ rtnl_addr(hdr);
+
+ process_newaddr(msg->ifa_family, msg->ifa_prefixlen, msg->ifa_index,
+ msg, IFA_PAYLOAD(hdr));
+}
+
+static void rtnl_deladdr(struct nlmsghdr *hdr)
+{
+ struct ifaddrmsg *msg = (struct ifaddrmsg *) NLMSG_DATA(hdr);
+
+ rtnl_addr(hdr);
+
+ process_deladdr(msg->ifa_family, msg->ifa_prefixlen, msg->ifa_index,
+ msg, IFA_PAYLOAD(hdr));
+}
+
+static void rtnl_route(struct nlmsghdr *hdr)
+{
+ struct rtmsg *msg;
+ struct rtattr *attr;
+ int bytes;
+
+ msg = (struct rtmsg *) NLMSG_DATA(hdr);
+ bytes = RTM_PAYLOAD(hdr);
+
+ print("rtm_family %d rtm_table %d rtm_protocol %d",
+ msg->rtm_family, msg->rtm_table, msg->rtm_protocol);
+ print("rtm_scope %d rtm_type %d rtm_flags 0x%04x",
+ msg->rtm_scope, msg->rtm_type, msg->rtm_flags);
+
+ for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ print_inet(attr, "dst", msg->rtm_family);
+ break;
+ case RTA_SRC:
+ print_inet(attr, "src", msg->rtm_family);
+ break;
+ case RTA_IIF:
+ print_string(attr, "iif");
+ break;
+ case RTA_OIF:
+ print_integer(attr, "oif");
+ break;
+ case RTA_GATEWAY:
+ print_inet(attr, "gateway", msg->rtm_family);
+ break;
+ case RTA_PRIORITY:
+ print_attr(attr, "priority");
+ break;
+ case RTA_PREFSRC:
+ print_inet(attr, "prefsrc", msg->rtm_family);
+ break;
+ case RTA_METRICS:
+ print_attr(attr, "metrics");
+ break;
+ case RTA_TABLE:
+ print_integer(attr, "table");
+ break;
+ default:
+ print_attr(attr, NULL);
+ break;
+ }
+ }
+}
+
+static bool is_route_rtmsg(struct rtmsg *msg)
+{
+ if (msg->rtm_flags & RTM_F_CLONED)
+ return false;
+
+ if (msg->rtm_table != RT_TABLE_MAIN)
+ return false;
+
+ if (msg->rtm_protocol != RTPROT_BOOT &&
+ msg->rtm_protocol != RTPROT_KERNEL)
+ return false;
+
+ if (msg->rtm_type != RTN_UNICAST)
+ return false;
+
+ return true;
+}
+
+static void rtnl_newroute(struct nlmsghdr *hdr)
+{
+ struct rtmsg *msg = (struct rtmsg *) NLMSG_DATA(hdr);
+
+ rtnl_route(hdr);
+
+ if (is_route_rtmsg(msg))
+ process_newroute(msg->rtm_family, msg->rtm_scope,
+ msg, RTM_PAYLOAD(hdr));
+}
+
+static void rtnl_delroute(struct nlmsghdr *hdr)
+{
+ struct rtmsg *msg = (struct rtmsg *) NLMSG_DATA(hdr);
+
+ rtnl_route(hdr);
+
+ if (is_route_rtmsg(msg))
+ process_delroute(msg->rtm_family, msg->rtm_scope,
+ msg, RTM_PAYLOAD(hdr));
+}
+
+static void *rtnl_nd_opt_rdnss(struct nd_opt_hdr *opt, guint32 *lifetime,
+ int *nr_servers)
+{
+ guint32 *optint = (void *)opt;
+
+ if (opt->nd_opt_len < 3)
+ return NULL;
+
+ if (*lifetime > ntohl(optint[1]))
+ *lifetime = ntohl(optint[1]);
+
+ /* nd_opt_len is in units of 8 bytes. The header is 1 unit (8 bytes)
+ and each address is another 2 units (16 bytes).
+ So the number of addresses (given rounding) is nd_opt_len/2 */
+ *nr_servers = opt->nd_opt_len / 2;
+
+ /* And they start 8 bytes into the packet, or two guint32s in. */
+ return optint + 2;
+}
+
+static const char **rtnl_nd_opt_dnssl(struct nd_opt_hdr *opt, guint32 *lifetime)
+{
+ const char **domains = NULL;
+ guint32 *optint = (void *)opt;
+ unsigned char *optc = (void *)&optint[2];
+ int data_len = (opt->nd_opt_len * 8) - 8;
+ int nr_domains = 0;
+ int i, tmp;
+
+ if (*lifetime > ntohl(optint[1]))
+ *lifetime = ntohl(optint[1]);
+
+ /* Turn it into normal strings by converting the length bytes into '.',
+ and count how many search domains there are while we're at it. */
+ i = 0;
+ while (i < data_len) {
+ if (optc[i] > 0x3f) {
+ DBG("DNSSL contains compressed elements in violation of RFC6106");
+ return NULL;
+ }
+
+ if (optc[i] == 0) {
+ nr_domains++;
+ i++;
+ /* Check for double zero */
+ if (i < data_len && optc[i] == 0)
+ break;
+ continue;
+ }
+
+ tmp = i;
+ i += optc[i] + 1;
+
+ if (i >= data_len) {
+ DBG("DNSSL data overflows option length");
+ return NULL;
+ }
+
+ optc[tmp] = '.';
+ }
+
+ domains = g_try_new0(const char *, nr_domains + 1);
+ if (!domains)
+ return NULL;
+
+ /* Now point to the normal strings, missing out the leading '.' that
+ each of them will have now. */
+ for (i = 0; i < nr_domains; i++) {
+ domains[i] = (char *)optc + 1;
+ optc += strlen((char *)optc) + 1;
+ }
+
+ return domains;
+}
+
+static void rtnl_newnduseropt(struct nlmsghdr *hdr)
+{
+ struct nduseroptmsg *msg = (struct nduseroptmsg *) NLMSG_DATA(hdr);
+ struct nd_opt_hdr *opt;
+ guint32 lifetime = -1;
+ const char **domains = NULL;
+ struct in6_addr *servers = NULL;
+ int i, nr_servers = 0;
+ int msglen = msg->nduseropt_opts_len;
+ int index;
+
+ DBG("family %d index %d len %d type %d code %d",
+ msg->nduseropt_family, msg->nduseropt_ifindex,
+ msg->nduseropt_opts_len, msg->nduseropt_icmp_type,
+ msg->nduseropt_icmp_code);
+
+ if (msg->nduseropt_family != AF_INET6 ||
+ msg->nduseropt_icmp_type != ND_ROUTER_ADVERT ||
+ msg->nduseropt_icmp_code != 0)
+ return;
+
+ index = msg->nduseropt_ifindex;
+ if (index < 0)
+ return;
+
+ for (opt = (void *)&msg[1];
+ msglen > 0;
+ msglen -= opt->nd_opt_len * 8,
+ opt = ((void *)opt) + opt->nd_opt_len*8) {
+
+ DBG("remaining %d nd opt type %d len %d\n",
+ msglen, opt->nd_opt_type, opt->nd_opt_len);
+
+ if (opt->nd_opt_type == 25) { /* ND_OPT_RDNSS */
+ char buf[40];
+
+ servers = rtnl_nd_opt_rdnss(opt, &lifetime,
+ &nr_servers);
+ for (i = 0; i < nr_servers; i++) {
+ if (!inet_ntop(AF_INET6, servers + i, buf,
+ sizeof(buf)))
+ continue;
+
+ connman_resolver_append_lifetime(index,
+ NULL, buf, lifetime);
+ }
+
+ } else if (opt->nd_opt_type == 31) { /* ND_OPT_DNSSL */
+ g_free(domains);
+
+ domains = rtnl_nd_opt_dnssl(opt, &lifetime);
+ for (i = 0; domains && domains[i]; i++)
+ connman_resolver_append_lifetime(index,
+ domains[i], NULL, lifetime);
+ }
+ }
+
+ g_free(domains);
+}
+
+static const char *type2string(uint16_t type)
+{
+ switch (type) {
+ case NLMSG_NOOP:
+ return "NOOP";
+ case NLMSG_ERROR:
+ return "ERROR";
+ case NLMSG_DONE:
+ return "DONE";
+ case NLMSG_OVERRUN:
+ return "OVERRUN";
+ case RTM_GETLINK:
+ return "GETLINK";
+ case RTM_NEWLINK:
+ return "NEWLINK";
+ case RTM_DELLINK:
+ return "DELLINK";
+ case RTM_GETADDR:
+ return "GETADDR";
+ case RTM_NEWADDR:
+ return "NEWADDR";
+ case RTM_DELADDR:
+ return "DELADDR";
+ case RTM_GETROUTE:
+ return "GETROUTE";
+ case RTM_NEWROUTE:
+ return "NEWROUTE";
+ case RTM_DELROUTE:
+ return "DELROUTE";
+ case RTM_NEWNDUSEROPT:
+ return "NEWNDUSEROPT";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+static GIOChannel *channel = NULL;
+static guint channel_watch = 0;
+
+struct rtnl_request {
+ struct nlmsghdr hdr;
+ struct rtgenmsg msg;
+};
+#define RTNL_REQUEST_SIZE (sizeof(struct nlmsghdr) + sizeof(struct rtgenmsg))
+
+static GSList *request_list = NULL;
+static guint32 request_seq = 0;
+
+static struct rtnl_request *find_request(guint32 seq)
+{
+ GSList *list;
+
+ for (list = request_list; list; list = list->next) {
+ struct rtnl_request *req = list->data;
+
+ if (req->hdr.nlmsg_seq == seq)
+ return req;
+ }
+
+ return NULL;
+}
+
+static int send_request(struct rtnl_request *req)
+{
+ struct sockaddr_nl addr;
+ int sk;
+
+ DBG("%s len %d type %d flags 0x%04x seq %d",
+ type2string(req->hdr.nlmsg_type),
+ req->hdr.nlmsg_len, req->hdr.nlmsg_type,
+ req->hdr.nlmsg_flags, req->hdr.nlmsg_seq);
+
+ sk = g_io_channel_unix_get_fd(channel);
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+
+ return sendto(sk, req, req->hdr.nlmsg_len, 0,
+ (struct sockaddr *) &addr, sizeof(addr));
+}
+
+static int queue_request(struct rtnl_request *req)
+{
+ request_list = g_slist_append(request_list, req);
+
+ if (g_slist_length(request_list) > 1)
+ return 0;
+
+ return send_request(req);
+}
+
+static int process_response(guint32 seq)
+{
+ struct rtnl_request *req;
+
+ DBG("seq %d", seq);
+
+ req = find_request(seq);
+ if (req) {
+ request_list = g_slist_remove(request_list, req);
+ g_free(req);
+ }
+
+ req = g_slist_nth_data(request_list, 0);
+ if (!req)
+ return 0;
+
+ return send_request(req);
+}
+
+static void rtnl_message(void *buf, size_t len)
+{
+ DBG("buf %p len %zd", buf, len);
+
+ while (len > 0) {
+ struct nlmsghdr *hdr = buf;
+ struct nlmsgerr *err;
+
+ if (!NLMSG_OK(hdr, len))
+ break;
+
+ DBG("%s len %d type %d flags 0x%04x seq %d pid %d",
+ type2string(hdr->nlmsg_type),
+ hdr->nlmsg_len, hdr->nlmsg_type,
+ hdr->nlmsg_flags, hdr->nlmsg_seq,
+ hdr->nlmsg_pid);
+
+ switch (hdr->nlmsg_type) {
+ case NLMSG_NOOP:
+ case NLMSG_OVERRUN:
+ return;
+ case NLMSG_DONE:
+ process_response(hdr->nlmsg_seq);
+ return;
+ case NLMSG_ERROR:
+ err = NLMSG_DATA(hdr);
+ DBG("error %d (%s)", -err->error,
+ strerror(-err->error));
+ return;
+ case RTM_NEWLINK:
+ rtnl_newlink(hdr);
+ break;
+ case RTM_DELLINK:
+ rtnl_dellink(hdr);
+ break;
+ case RTM_NEWADDR:
+ rtnl_newaddr(hdr);
+ break;
+ case RTM_DELADDR:
+ rtnl_deladdr(hdr);
+ break;
+ case RTM_NEWROUTE:
+ rtnl_newroute(hdr);
+ break;
+ case RTM_DELROUTE:
+ rtnl_delroute(hdr);
+ break;
+ case RTM_NEWNDUSEROPT:
+ rtnl_newnduseropt(hdr);
+ break;
+ }
+
+ len -= hdr->nlmsg_len;
+ buf += hdr->nlmsg_len;
+ }
+}
+
+static gboolean netlink_event(GIOChannel *chan, GIOCondition cond, gpointer data)
+{
+ unsigned char buf[4096];
+ struct sockaddr_nl nladdr;
+ socklen_t addr_len = sizeof(nladdr);
+ ssize_t status;
+ int fd;
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ memset(buf, 0, sizeof(buf));
+ memset(&nladdr, 0, sizeof(nladdr));
+
+ fd = g_io_channel_unix_get_fd(chan);
+
+ status = recvfrom(fd, buf, sizeof(buf), 0,
+ (struct sockaddr *) &nladdr, &addr_len);
+ if (status < 0) {
+ if (errno == EINTR || errno == EAGAIN)
+ return TRUE;
+
+ return FALSE;
+ }
+
+ if (status == 0)
+ return FALSE;
+
+ if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
+ DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
+ return TRUE;
+ }
+
+ rtnl_message(buf, status);
+
+ return TRUE;
+}
+
+static int send_getlink(void)
+{
+ struct rtnl_request *req;
+
+ DBG("");
+
+ req = g_try_malloc0(RTNL_REQUEST_SIZE);
+ if (!req)
+ return -ENOMEM;
+
+ req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
+ req->hdr.nlmsg_type = RTM_GETLINK;
+ req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req->hdr.nlmsg_pid = 0;
+ req->hdr.nlmsg_seq = request_seq++;
+ req->msg.rtgen_family = AF_INET;
+
+ return queue_request(req);
+}
+
+static int send_getaddr(void)
+{
+ struct rtnl_request *req;
+
+ DBG("");
+
+ req = g_try_malloc0(RTNL_REQUEST_SIZE);
+ if (!req)
+ return -ENOMEM;
+
+ req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
+ req->hdr.nlmsg_type = RTM_GETADDR;
+ req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req->hdr.nlmsg_pid = 0;
+ req->hdr.nlmsg_seq = request_seq++;
+ req->msg.rtgen_family = AF_INET;
+
+ return queue_request(req);
+}
+
+static int send_getroute(void)
+{
+ struct rtnl_request *req;
+
+ DBG("");
+
+ req = g_try_malloc0(RTNL_REQUEST_SIZE);
+ if (!req)
+ return -ENOMEM;
+
+ req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
+ req->hdr.nlmsg_type = RTM_GETROUTE;
+ req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req->hdr.nlmsg_pid = 0;
+ req->hdr.nlmsg_seq = request_seq++;
+ req->msg.rtgen_family = AF_INET;
+
+ return queue_request(req);
+}
+
+static gboolean update_timeout_cb(gpointer user_data)
+{
+ __connman_rtnl_request_update();
+
+ return TRUE;
+}
+
+static void update_interval_callback(guint min)
+{
+ if (update_timeout > 0)
+ g_source_remove(update_timeout);
+
+ if (min < G_MAXUINT) {
+ update_interval = min;
+ update_timeout = g_timeout_add_seconds(update_interval,
+ update_timeout_cb, NULL);
+ } else {
+ update_timeout = 0;
+ update_interval = G_MAXUINT;
+ }
+}
+
+static gint compare_interval(gconstpointer a, gconstpointer b)
+{
+ guint val_a = GPOINTER_TO_UINT(a);
+ guint val_b = GPOINTER_TO_UINT(b);
+
+ return val_a - val_b;
+}
+
+unsigned int __connman_rtnl_update_interval_add(unsigned int interval)
+{
+ guint min;
+
+ if (interval == 0)
+ return 0;
+
+ update_list = g_slist_insert_sorted(update_list,
+ GUINT_TO_POINTER(interval), compare_interval);
+
+ min = GPOINTER_TO_UINT(g_slist_nth_data(update_list, 0));
+ if (min < update_interval) {
+ update_interval_callback(min);
+ __connman_rtnl_request_update();
+ }
+
+ return update_interval;
+}
+
+unsigned int __connman_rtnl_update_interval_remove(unsigned int interval)
+{
+ guint min = G_MAXUINT;
+
+ if (interval == 0)
+ return 0;
+
+ update_list = g_slist_remove(update_list, GINT_TO_POINTER(interval));
+
+ if (update_list)
+ min = GPOINTER_TO_UINT(g_slist_nth_data(update_list, 0));
+
+ if (min > update_interval)
+ update_interval_callback(min);
+
+ return min;
+}
+
+int __connman_rtnl_request_update(void)
+{
+ return send_getlink();
+}
+
+int __connman_rtnl_init(void)
+{
+ struct sockaddr_nl addr;
+ int sk;
+
+ DBG("");
+
+ interface_list = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_interface);
+
+ sk = socket(PF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
+ if (sk < 0)
+ return -1;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+ addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE |
+ RTMGRP_IPV6_IFADDR | RTMGRP_IPV6_ROUTE |
+ (1<<(RTNLGRP_ND_USEROPT-1));
+
+ if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ close(sk);
+ return -1;
+ }
+
+ channel = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(channel, TRUE);
+
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ channel_watch = g_io_add_watch(channel,
+ G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ netlink_event, NULL);
+
+ return 0;
+}
+
+void __connman_rtnl_start(void)
+{
+ DBG("");
+
+ send_getlink();
+ send_getaddr();
+ send_getroute();
+}
+
+void __connman_rtnl_cleanup(void)
+{
+ GSList *list;
+
+ DBG("");
+
+ for (list = watch_list; list; list = list->next) {
+ struct watch_data *watch = list->data;
+
+ DBG("removing watch %d", watch->id);
+
+ g_free(watch);
+ list->data = NULL;
+ }
+
+ g_slist_free(watch_list);
+ watch_list = NULL;
+
+ g_slist_free(update_list);
+ update_list = NULL;
+
+ for (list = request_list; list; list = list->next) {
+ struct rtnl_request *req = list->data;
+
+ DBG("%s len %d type %d flags 0x%04x seq %d",
+ type2string(req->hdr.nlmsg_type),
+ req->hdr.nlmsg_len, req->hdr.nlmsg_type,
+ req->hdr.nlmsg_flags, req->hdr.nlmsg_seq);
+
+ g_free(req);
+ list->data = NULL;
+ }
+
+ g_slist_free(request_list);
+ request_list = NULL;
+
+ if (channel_watch) {
+ g_source_remove(channel_watch);
+ channel_watch = 0;
+ }
+
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+
+ channel = NULL;
+
+ g_hash_table_destroy(interface_list);
+}
diff --git a/src/service.c b/src/service.c
new file mode 100644
index 0000000..28080d3
--- /dev/null
+++ b/src/service.c
@@ -0,0 +1,7338 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <netdb.h>
+#include <gdbus.h>
+#include <ctype.h>
+#include <stdint.h>
+
+#include <connman/storage.h>
+#include <connman/setting.h>
+#include <connman/agent.h>
+
+#include "connman.h"
+
+#define CONNECT_TIMEOUT 120
+
+static DBusConnection *connection = NULL;
+
+static GList *service_list = NULL;
+static GHashTable *service_hash = NULL;
+static GSList *counter_list = NULL;
+static unsigned int autoconnect_timeout = 0;
+static unsigned int vpn_autoconnect_timeout = 0;
+static struct connman_service *current_default = NULL;
+static bool services_dirty = false;
+
+struct connman_stats {
+ bool valid;
+ bool enabled;
+ struct connman_stats_data data_last;
+ struct connman_stats_data data;
+ GTimer *timer;
+};
+
+struct connman_stats_counter {
+ bool append_all;
+ struct connman_stats stats;
+ struct connman_stats stats_roaming;
+};
+
+struct connman_service {
+ int refcount;
+ char *identifier;
+ char *path;
+ enum connman_service_type type;
+ enum connman_service_security security;
+ enum connman_service_state state;
+ enum connman_service_state state_ipv4;
+ enum connman_service_state state_ipv6;
+ enum connman_service_error error;
+ enum connman_service_connect_reason connect_reason;
+ uint8_t strength;
+ bool favorite;
+ bool immutable;
+ bool hidden;
+ bool ignore;
+ bool autoconnect;
+ GTimeVal modified;
+ unsigned int order;
+ char *name;
+ char *passphrase;
+ bool roaming;
+ struct connman_ipconfig *ipconfig_ipv4;
+ struct connman_ipconfig *ipconfig_ipv6;
+ struct connman_network *network;
+ struct connman_provider *provider;
+ char **nameservers;
+ char **nameservers_config;
+ char **nameservers_auto;
+ int nameservers_timeout;
+ char **domains;
+ char *hostname;
+ char *domainname;
+ char **timeservers;
+ char **timeservers_config;
+ /* 802.1x settings from the config files */
+ char *eap;
+ char *identity;
+ char *agent_identity;
+ char *ca_cert_file;
+ char *client_cert_file;
+ char *private_key_file;
+ char *private_key_passphrase;
+ char *phase2;
+ DBusMessage *pending;
+ DBusMessage *provider_pending;
+ guint timeout;
+ struct connman_stats stats;
+ struct connman_stats stats_roaming;
+ GHashTable *counter_table;
+ enum connman_service_proxy_method proxy;
+ enum connman_service_proxy_method proxy_config;
+ char **proxies;
+ char **excludes;
+ char *pac;
+ bool wps;
+ int online_check_count;
+ bool do_split_routing;
+ bool new_service;
+ bool hidden_service;
+ char *config_file;
+ char *config_entry;
+};
+
+static bool allow_property_changed(struct connman_service *service);
+
+static struct connman_ipconfig *create_ip4config(struct connman_service *service,
+ int index, enum connman_ipconfig_method method);
+static struct connman_ipconfig *create_ip6config(struct connman_service *service,
+ int index);
+static void dns_changed(struct connman_service *service);
+
+struct find_data {
+ const char *path;
+ struct connman_service *service;
+};
+
+static void compare_path(gpointer value, gpointer user_data)
+{
+ struct connman_service *service = value;
+ struct find_data *data = user_data;
+
+ if (data->service)
+ return;
+
+ if (g_strcmp0(service->path, data->path) == 0)
+ data->service = service;
+}
+
+static struct connman_service *find_service(const char *path)
+{
+ struct find_data data = { .path = path, .service = NULL };
+
+ DBG("path %s", path);
+
+ g_list_foreach(service_list, compare_path, &data);
+
+ return data.service;
+}
+
+static const char *reason2string(enum connman_service_connect_reason reason)
+{
+
+ switch (reason) {
+ case CONNMAN_SERVICE_CONNECT_REASON_NONE:
+ return "none";
+ case CONNMAN_SERVICE_CONNECT_REASON_USER:
+ return "user";
+ case CONNMAN_SERVICE_CONNECT_REASON_AUTO:
+ return "auto";
+ case CONNMAN_SERVICE_CONNECT_REASON_SESSION:
+ return "session";
+ }
+
+ return "unknown";
+}
+
+const char *__connman_service_type2string(enum connman_service_type type)
+{
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ break;
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ return "system";
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ return "ethernet";
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ return "wifi";
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ return "bluetooth";
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ return "cellular";
+ case CONNMAN_SERVICE_TYPE_GPS:
+ return "gps";
+ case CONNMAN_SERVICE_TYPE_VPN:
+ return "vpn";
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ return "gadget";
+ case CONNMAN_SERVICE_TYPE_P2P:
+ return "p2p";
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ return "lowpan";
+
+ }
+
+ return NULL;
+}
+
+enum connman_service_type __connman_service_string2type(const char *str)
+{
+ if (!str)
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+
+ if (strcmp(str, "ethernet") == 0)
+ return CONNMAN_SERVICE_TYPE_ETHERNET;
+ if (strcmp(str, "gadget") == 0)
+ return CONNMAN_SERVICE_TYPE_GADGET;
+ if (strcmp(str, "wifi") == 0)
+ return CONNMAN_SERVICE_TYPE_WIFI;
+ if (strcmp(str, "cellular") == 0)
+ return CONNMAN_SERVICE_TYPE_CELLULAR;
+ if (strcmp(str, "bluetooth") == 0)
+ return CONNMAN_SERVICE_TYPE_BLUETOOTH;
+ if (strcmp(str, "vpn") == 0)
+ return CONNMAN_SERVICE_TYPE_VPN;
+ if (strcmp(str, "gps") == 0)
+ return CONNMAN_SERVICE_TYPE_GPS;
+ if (strcmp(str, "system") == 0)
+ return CONNMAN_SERVICE_TYPE_SYSTEM;
+ if (strcmp(str, "p2p") == 0)
+ return CONNMAN_SERVICE_TYPE_P2P;
+ if (strcmp(str, "lowpan") == 0)
+ return CONNMAN_SERVICE_TYPE_LOWPAN;
+
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+}
+
+enum connman_service_security __connman_service_string2security(const char *str)
+{
+ if (!str)
+ return CONNMAN_SERVICE_SECURITY_UNKNOWN;
+
+ if (!strcmp(str, "psk"))
+ return CONNMAN_SERVICE_SECURITY_PSK;
+ if (!strcmp(str, "ieee8021x"))
+ return CONNMAN_SERVICE_SECURITY_8021X;
+ if (!strcmp(str, "none"))
+ return CONNMAN_SERVICE_SECURITY_NONE;
+ if (!strcmp(str, "wep"))
+ return CONNMAN_SERVICE_SECURITY_WEP;
+
+ return CONNMAN_SERVICE_SECURITY_UNKNOWN;
+}
+
+static const char *security2string(enum connman_service_security security)
+{
+ switch (security) {
+ case CONNMAN_SERVICE_SECURITY_UNKNOWN:
+ break;
+ case CONNMAN_SERVICE_SECURITY_NONE:
+ return "none";
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ return "wep";
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ case CONNMAN_SERVICE_SECURITY_WPA:
+ case CONNMAN_SERVICE_SECURITY_RSN:
+ return "psk";
+ case CONNMAN_SERVICE_SECURITY_8021X:
+ return "ieee8021x";
+ }
+
+ return NULL;
+}
+
+static const char *state2string(enum connman_service_state state)
+{
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ break;
+ case CONNMAN_SERVICE_STATE_IDLE:
+ return "idle";
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ return "association";
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ return "configuration";
+ case CONNMAN_SERVICE_STATE_READY:
+ return "ready";
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ return "online";
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ return "disconnect";
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ return "failure";
+ }
+
+ return NULL;
+}
+
+static const char *error2string(enum connman_service_error error)
+{
+ switch (error) {
+ case CONNMAN_SERVICE_ERROR_UNKNOWN:
+ break;
+ case CONNMAN_SERVICE_ERROR_OUT_OF_RANGE:
+ return "out-of-range";
+ case CONNMAN_SERVICE_ERROR_PIN_MISSING:
+ return "pin-missing";
+ case CONNMAN_SERVICE_ERROR_DHCP_FAILED:
+ return "dhcp-failed";
+ case CONNMAN_SERVICE_ERROR_CONNECT_FAILED:
+ return "connect-failed";
+ case CONNMAN_SERVICE_ERROR_LOGIN_FAILED:
+ return "login-failed";
+ case CONNMAN_SERVICE_ERROR_AUTH_FAILED:
+ return "auth-failed";
+ case CONNMAN_SERVICE_ERROR_INVALID_KEY:
+ return "invalid-key";
+ }
+
+ return NULL;
+}
+
+static const char *proxymethod2string(enum connman_service_proxy_method method)
+{
+ switch (method) {
+ case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
+ return "direct";
+ case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
+ return "manual";
+ case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
+ return "auto";
+ case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
+ break;
+ }
+
+ return NULL;
+}
+
+static enum connman_service_proxy_method string2proxymethod(const char *method)
+{
+ if (g_strcmp0(method, "direct") == 0)
+ return CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
+ else if (g_strcmp0(method, "auto") == 0)
+ return CONNMAN_SERVICE_PROXY_METHOD_AUTO;
+ else if (g_strcmp0(method, "manual") == 0)
+ return CONNMAN_SERVICE_PROXY_METHOD_MANUAL;
+ else
+ return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
+}
+
+int __connman_service_load_modifiable(struct connman_service *service)
+{
+ GKeyFile *keyfile;
+ GError *error = NULL;
+ gchar *str;
+ bool autoconnect;
+
+ DBG("service %p", service);
+
+ keyfile = connman_storage_load_service(service->identifier);
+ if (!keyfile)
+ return -EIO;
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ case CONNMAN_SERVICE_TYPE_VPN:
+ service->do_split_routing = g_key_file_get_boolean(keyfile,
+ service->identifier, "SplitRouting", NULL);
+ /* fall through */
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ autoconnect = g_key_file_get_boolean(keyfile,
+ service->identifier, "AutoConnect", &error);
+ if (!error)
+ service->autoconnect = autoconnect;
+ g_clear_error(&error);
+ break;
+ }
+
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "Modified", NULL);
+ if (str) {
+ g_time_val_from_iso8601(str, &service->modified);
+ g_free(str);
+ }
+
+ g_key_file_free(keyfile);
+
+ return 0;
+}
+
+static int service_load(struct connman_service *service)
+{
+ GKeyFile *keyfile;
+ GError *error = NULL;
+ gsize length;
+ gchar *str;
+ bool autoconnect;
+ unsigned int ssid_len;
+ int err = 0;
+ int order = 0;
+
+ DBG("service %p", service);
+
+ keyfile = connman_storage_load_service(service->identifier);
+ if (!keyfile) {
+ service->new_service = true;
+ return -EIO;
+ } else
+ service->new_service = false;
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ case CONNMAN_SERVICE_TYPE_VPN:
+ service->do_split_routing = g_key_file_get_boolean(keyfile,
+ service->identifier, "SplitRouting", NULL);
+ autoconnect = g_key_file_get_boolean(keyfile,
+ service->identifier, "AutoConnect", &error);
+ if (!error)
+ service->autoconnect = autoconnect;
+ g_clear_error(&error);
+ break;
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ if (!service->name) {
+ gchar *name;
+
+ name = g_key_file_get_string(keyfile,
+ service->identifier, "Name", NULL);
+ if (name) {
+ g_free(service->name);
+ service->name = name;
+ }
+
+ if (service->network)
+ connman_network_set_name(service->network,
+ name);
+ }
+
+ if (service->network &&
+ !connman_network_get_blob(service->network,
+ "WiFi.SSID", &ssid_len)) {
+ gchar *hex_ssid;
+
+ hex_ssid = g_key_file_get_string(keyfile,
+ service->identifier,
+ "SSID", NULL);
+
+ if (hex_ssid) {
+ gchar *ssid;
+ unsigned int i, j = 0, hex;
+ size_t hex_ssid_len = strlen(hex_ssid);
+
+ ssid = g_try_malloc0(hex_ssid_len / 2);
+ if (!ssid) {
+ g_free(hex_ssid);
+ err = -ENOMEM;
+ goto done;
+ }
+
+ for (i = 0; i < hex_ssid_len; i += 2) {
+ sscanf(hex_ssid + i, "%02x", &hex);
+ ssid[j++] = hex;
+ }
+
+ connman_network_set_blob(service->network,
+ "WiFi.SSID", ssid, hex_ssid_len / 2);
+ }
+
+ g_free(hex_ssid);
+ }
+ /* fall through */
+
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ service->favorite = g_key_file_get_boolean(keyfile,
+ service->identifier, "Favorite", NULL);
+
+ /* fall through */
+
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ autoconnect = g_key_file_get_boolean(keyfile,
+ service->identifier, "AutoConnect", &error);
+ if (!error)
+ service->autoconnect = autoconnect;
+ g_clear_error(&error);
+
+ order = g_key_file_get_integer(keyfile,
+ service->identifier, "Order", &error);
+ if (!error)
+ service->order = order;
+ g_clear_error(&error);
+
+ break;
+ }
+
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "Modified", NULL);
+ if (str) {
+ g_time_val_from_iso8601(str, &service->modified);
+ g_free(str);
+ }
+
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "Passphrase", NULL);
+ if (str) {
+ g_free(service->passphrase);
+ service->passphrase = str;
+ }
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
+ service->identifier, "IPv4.");
+
+ if (service->ipconfig_ipv6)
+ __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
+ service->identifier, "IPv6.");
+
+ service->nameservers_config = g_key_file_get_string_list(keyfile,
+ service->identifier, "Nameservers", &length, NULL);
+ if (service->nameservers_config && length == 0) {
+ g_strfreev(service->nameservers_config);
+ service->nameservers_config = NULL;
+ }
+
+ service->timeservers_config = g_key_file_get_string_list(keyfile,
+ service->identifier, "Timeservers", &length, NULL);
+ if (service->timeservers_config && length == 0) {
+ g_strfreev(service->timeservers_config);
+ service->timeservers_config = NULL;
+ }
+
+ service->domains = g_key_file_get_string_list(keyfile,
+ service->identifier, "Domains", &length, NULL);
+ if (service->domains && length == 0) {
+ g_strfreev(service->domains);
+ service->domains = NULL;
+ }
+
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "Proxy.Method", NULL);
+ if (str)
+ service->proxy_config = string2proxymethod(str);
+
+ g_free(str);
+
+ service->proxies = g_key_file_get_string_list(keyfile,
+ service->identifier, "Proxy.Servers", &length, NULL);
+ if (service->proxies && length == 0) {
+ g_strfreev(service->proxies);
+ service->proxies = NULL;
+ }
+
+ service->excludes = g_key_file_get_string_list(keyfile,
+ service->identifier, "Proxy.Excludes", &length, NULL);
+ if (service->excludes && length == 0) {
+ g_strfreev(service->excludes);
+ service->excludes = NULL;
+ }
+
+ str = g_key_file_get_string(keyfile,
+ service->identifier, "Proxy.URL", NULL);
+ if (str) {
+ g_free(service->pac);
+ service->pac = str;
+ }
+
+ service->hidden_service = g_key_file_get_boolean(keyfile,
+ service->identifier, "Hidden", NULL);
+
+done:
+ g_key_file_free(keyfile);
+
+ return err;
+}
+
+static int service_save(struct connman_service *service)
+{
+ GKeyFile *keyfile;
+ gchar *str;
+ guint freq;
+ const char *cst_str = NULL;
+ int err = 0;
+
+ DBG("service %p new %d", service, service->new_service);
+
+ if (service->new_service)
+ return -ESRCH;
+
+ keyfile = __connman_storage_open_service(service->identifier);
+ if (!keyfile)
+ return -EIO;
+
+ if (service->name)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Name", service->name);
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ case CONNMAN_SERVICE_TYPE_VPN:
+ g_key_file_set_boolean(keyfile, service->identifier,
+ "SplitRouting", service->do_split_routing);
+ if (service->favorite)
+ g_key_file_set_boolean(keyfile, service->identifier,
+ "AutoConnect", service->autoconnect);
+ break;
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ if (service->network) {
+ const unsigned char *ssid;
+ unsigned int ssid_len = 0;
+
+ ssid = connman_network_get_blob(service->network,
+ "WiFi.SSID", &ssid_len);
+
+ if (ssid && ssid_len > 0 && ssid[0] != '\0') {
+ char *identifier = service->identifier;
+ GString *ssid_str;
+ unsigned int i;
+
+ ssid_str = g_string_sized_new(ssid_len * 2);
+ if (!ssid_str) {
+ err = -ENOMEM;
+ goto done;
+ }
+
+ for (i = 0; i < ssid_len; i++)
+ g_string_append_printf(ssid_str,
+ "%02x", ssid[i]);
+
+ g_key_file_set_string(keyfile, identifier,
+ "SSID", ssid_str->str);
+
+ g_string_free(ssid_str, TRUE);
+ }
+
+ freq = connman_network_get_frequency(service->network);
+ g_key_file_set_integer(keyfile, service->identifier,
+ "Frequency", freq);
+ }
+ /* fall through */
+
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ g_key_file_set_boolean(keyfile, service->identifier,
+ "Favorite", service->favorite);
+
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Failure", NULL);
+
+ /* fall through */
+
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ g_key_file_set_integer(keyfile, service->identifier,
+ "Order", service->order);
+ if (service->favorite)
+ g_key_file_set_boolean(keyfile, service->identifier,
+ "AutoConnect", service->autoconnect);
+ break;
+ }
+
+ str = g_time_val_to_iso8601(&service->modified);
+ if (str) {
+ g_key_file_set_string(keyfile, service->identifier,
+ "Modified", str);
+ g_free(str);
+ }
+
+ if (service->passphrase && strlen(service->passphrase) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Passphrase", service->passphrase);
+ else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Passphrase", NULL);
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_save(service->ipconfig_ipv4, keyfile,
+ service->identifier, "IPv4.");
+
+ if (service->ipconfig_ipv6)
+ __connman_ipconfig_save(service->ipconfig_ipv6, keyfile,
+ service->identifier, "IPv6.");
+
+ if (service->nameservers_config) {
+ guint len = g_strv_length(service->nameservers_config);
+
+ g_key_file_set_string_list(keyfile, service->identifier,
+ "Nameservers",
+ (const gchar **) service->nameservers_config, len);
+ } else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Nameservers", NULL);
+
+ if (service->timeservers_config) {
+ guint len = g_strv_length(service->timeservers_config);
+
+ g_key_file_set_string_list(keyfile, service->identifier,
+ "Timeservers",
+ (const gchar **) service->timeservers_config, len);
+ } else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Timeservers", NULL);
+
+ if (service->domains) {
+ guint len = g_strv_length(service->domains);
+
+ g_key_file_set_string_list(keyfile, service->identifier,
+ "Domains",
+ (const gchar **) service->domains, len);
+ } else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Domains", NULL);
+
+ cst_str = proxymethod2string(service->proxy_config);
+ if (cst_str)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Proxy.Method", cst_str);
+
+ if (service->proxies) {
+ guint len = g_strv_length(service->proxies);
+
+ g_key_file_set_string_list(keyfile, service->identifier,
+ "Proxy.Servers",
+ (const gchar **) service->proxies, len);
+ } else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Proxy.Servers", NULL);
+
+ if (service->excludes) {
+ guint len = g_strv_length(service->excludes);
+
+ g_key_file_set_string_list(keyfile, service->identifier,
+ "Proxy.Excludes",
+ (const gchar **) service->excludes, len);
+ } else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Proxy.Excludes", NULL);
+
+ if (service->pac && strlen(service->pac) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Proxy.URL", service->pac);
+ else
+ g_key_file_remove_key(keyfile, service->identifier,
+ "Proxy.URL", NULL);
+
+ if (service->hidden_service)
+ g_key_file_set_boolean(keyfile, service->identifier, "Hidden",
+ TRUE);
+
+ if (service->config_file && strlen(service->config_file) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Config.file", service->config_file);
+
+ if (service->config_entry &&
+ strlen(service->config_entry) > 0)
+ g_key_file_set_string(keyfile, service->identifier,
+ "Config.ident", service->config_entry);
+
+done:
+ __connman_storage_save_service(keyfile, service->identifier);
+
+ g_key_file_free(keyfile);
+
+ return err;
+}
+
+void __connman_service_save(struct connman_service *service)
+{
+ if (!service)
+ return;
+
+ service_save(service);
+}
+
+static enum connman_service_state combine_state(
+ enum connman_service_state state_a,
+ enum connman_service_state state_b)
+{
+ enum connman_service_state result;
+
+ if (state_a == state_b) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_UNKNOWN) {
+ result = state_b;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_UNKNOWN) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_IDLE) {
+ result = state_b;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_IDLE) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_ONLINE) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_ONLINE) {
+ result = state_b;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_READY) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_READY) {
+ result = state_b;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_CONFIGURATION) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_CONFIGURATION) {
+ result = state_b;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_ASSOCIATION) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_ASSOCIATION) {
+ result = state_b;
+ goto done;
+ }
+
+ if (state_a == CONNMAN_SERVICE_STATE_DISCONNECT) {
+ result = state_a;
+ goto done;
+ }
+
+ if (state_b == CONNMAN_SERVICE_STATE_DISCONNECT) {
+ result = state_b;
+ goto done;
+ }
+
+ result = CONNMAN_SERVICE_STATE_FAILURE;
+
+done:
+ return result;
+}
+
+static bool is_connecting_state(struct connman_service *service,
+ enum connman_service_state state)
+{
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ if (service->network)
+ return connman_network_get_connecting(service->network);
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ break;
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ return true;
+ }
+
+ return false;
+}
+
+static bool is_connected_state(const struct connman_service *service,
+ enum connman_service_state state)
+{
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ break;
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ return true;
+ }
+
+ return false;
+}
+
+static bool is_idle_state(const struct connman_service *service,
+ enum connman_service_state state)
+{
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ break;
+ case CONNMAN_SERVICE_STATE_IDLE:
+ return true;
+ }
+
+ return false;
+}
+
+static bool is_idle(struct connman_service *service)
+{
+ switch (service->state) {
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ return true;
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ break;
+ }
+
+ return false;
+}
+
+static bool is_connecting(struct connman_service *service)
+{
+ return is_connecting_state(service, service->state);
+}
+
+static bool is_connected(struct connman_service *service)
+{
+ return is_connected_state(service, service->state);
+}
+
+
+static int nameservers_changed_cb(void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ DBG("service %p", service);
+
+ service->nameservers_timeout = 0;
+ if ((is_idle(service) && !service->nameservers) ||
+ is_connected(service))
+ dns_changed(service);
+
+ return FALSE;
+}
+
+static void nameservers_changed(struct connman_service *service)
+{
+ if (!service->nameservers_timeout)
+ service->nameservers_timeout = g_timeout_add_seconds(0,
+ nameservers_changed_cb,
+ service);
+}
+
+static bool nameserver_available(struct connman_service *service,
+ enum connman_ipconfig_type type,
+ const char *ns)
+{
+ int family;
+
+ family = connman_inet_check_ipaddress(ns);
+
+ if (family == AF_INET) {
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ return false;
+
+ return is_connected_state(service, service->state_ipv4);
+ }
+
+ if (family == AF_INET6) {
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ return false;
+
+ return is_connected_state(service, service->state_ipv6);
+ }
+
+ return false;
+}
+
+static int nameserver_add(struct connman_service *service,
+ enum connman_ipconfig_type type,
+ const char *nameserver)
+{
+ int index, ret;
+
+ if (!nameserver_available(service, type, nameserver))
+ return 0;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -ENXIO;
+
+ ret = connman_resolver_append(index, NULL, nameserver);
+ if (ret >= 0)
+ nameservers_changed(service);
+
+ return ret;
+}
+
+static int nameserver_add_all(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ int i = 0;
+
+ if (service->nameservers_config) {
+ while (service->nameservers_config[i]) {
+ nameserver_add(service, type,
+ service->nameservers_config[i]);
+ i++;
+ }
+
+ return 0;
+ }
+
+ if (service->nameservers) {
+ while (service->nameservers[i]) {
+ nameserver_add(service, type,
+ service->nameservers[i]);
+ i++;
+ }
+ }
+
+ return 0;
+}
+
+static int nameserver_remove(struct connman_service *service,
+ enum connman_ipconfig_type type,
+ const char *nameserver)
+{
+ int index, ret;
+
+ if (!nameserver_available(service, type, nameserver))
+ return 0;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -ENXIO;
+
+ ret = connman_resolver_append(index, NULL, nameserver);
+ if (ret >= 0)
+ nameservers_changed(service);
+
+ return ret;
+}
+
+static int nameserver_remove_all(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ int index, i = 0;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -ENXIO;
+
+ while (service->nameservers_config && service->nameservers_config[i]) {
+
+ nameserver_remove(service, type,
+ service->nameservers_config[i]);
+ i++;
+ }
+
+ i = 0;
+ while (service->nameservers && service->nameservers[i]) {
+ nameserver_remove(service, type, service->nameservers[i]);
+ i++;
+ }
+
+ return 0;
+}
+
+static int searchdomain_add_all(struct connman_service *service)
+{
+ int index, i = 0;
+
+ if (!is_connected(service))
+ return -ENOTCONN;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -ENXIO;
+
+ if (service->domains) {
+ while (service->domains[i]) {
+ connman_resolver_append(index, service->domains[i],
+ NULL);
+ i++;
+ }
+
+ return 0;
+ }
+
+ if (service->domainname)
+ connman_resolver_append(index, service->domainname, NULL);
+
+ return 0;
+
+}
+
+static int searchdomain_remove_all(struct connman_service *service)
+{
+ int index, i = 0;
+
+ if (!is_connected(service))
+ return -ENOTCONN;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -ENXIO;
+
+ while (service->domains && service->domains[i]) {
+ connman_resolver_remove(index, service->domains[i], NULL);
+ i++;
+ }
+
+ if (service->domainname)
+ connman_resolver_remove(index, service->domainname, NULL);
+
+ return 0;
+}
+
+/*
+ * The is_auto variable is set to true when IPv6 autoconf nameservers are
+ * inserted to resolver via netlink message (see rtnl.c:rtnl_newnduseropt()
+ * for details) and not through service.c
+ */
+int __connman_service_nameserver_append(struct connman_service *service,
+ const char *nameserver, bool is_auto)
+{
+ char **nameservers;
+ int len, i;
+
+ DBG("service %p nameserver %s auto %d", service, nameserver, is_auto);
+
+ if (!nameserver)
+ return -EINVAL;
+
+ if (is_auto)
+ nameservers = service->nameservers_auto;
+ else
+ nameservers = service->nameservers;
+
+ for (i = 0; nameservers && nameservers[i]; i++)
+ if (g_strcmp0(nameservers[i], nameserver) == 0)
+ return -EEXIST;
+
+ if (nameservers) {
+ len = g_strv_length(nameservers);
+ nameservers = g_try_renew(char *, nameservers, len + 2);
+ } else {
+ len = 0;
+ nameservers = g_try_new0(char *, len + 2);
+ }
+
+ if (!nameservers)
+ return -ENOMEM;
+
+ nameservers[len] = g_strdup(nameserver);
+ if (!nameservers[len])
+ return -ENOMEM;
+
+ nameservers[len + 1] = NULL;
+
+ if (is_auto) {
+ service->nameservers_auto = nameservers;
+ } else {
+ service->nameservers = nameservers;
+ nameserver_add(service, CONNMAN_IPCONFIG_TYPE_ALL, nameserver);
+ }
+
+ nameservers_changed(service);
+
+ return 0;
+}
+
+int __connman_service_nameserver_remove(struct connman_service *service,
+ const char *nameserver, bool is_auto)
+{
+ char **servers, **nameservers;
+ bool found = false;
+ int len, i, j;
+
+ DBG("service %p nameserver %s auto %d", service, nameserver, is_auto);
+
+ if (!nameserver)
+ return -EINVAL;
+
+ if (is_auto)
+ nameservers = service->nameservers_auto;
+ else
+ nameservers = service->nameservers;
+
+ if (!nameservers)
+ return 0;
+
+ for (i = 0; nameservers && nameservers[i]; i++)
+ if (g_strcmp0(nameservers[i], nameserver) == 0) {
+ found = true;
+ break;
+ }
+
+ if (!found)
+ return 0;
+
+ len = g_strv_length(nameservers);
+
+ if (len == 1) {
+ servers = NULL;
+ goto set_servers;
+ }
+
+ servers = g_try_new0(char *, len);
+ if (!servers)
+ return -ENOMEM;
+
+ for (i = 0, j = 0; i < len; i++) {
+ if (g_strcmp0(nameservers[i], nameserver)) {
+ servers[j] = nameservers[i];
+ j++;
+ } else
+ g_free(nameservers[i]);
+
+ nameservers[i] = NULL;
+ }
+ servers[len - 1] = NULL;
+
+set_servers:
+ g_strfreev(nameservers);
+ nameservers = servers;
+
+ if (is_auto) {
+ service->nameservers_auto = nameservers;
+ } else {
+ service->nameservers = nameservers;
+ nameserver_remove(service, CONNMAN_IPCONFIG_TYPE_ALL,
+ nameserver);
+ }
+
+ return 0;
+}
+
+void __connman_service_nameserver_clear(struct connman_service *service)
+{
+ nameserver_remove_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
+
+ g_strfreev(service->nameservers);
+ service->nameservers = NULL;
+
+ nameserver_add_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
+}
+
+static void add_nameserver_route(int family, int index, char *nameserver,
+ const char *gw)
+{
+ switch (family) {
+ case AF_INET:
+ if (connman_inet_compare_subnet(index, nameserver))
+ break;
+
+ if (connman_inet_add_host_route(index, nameserver, gw) < 0)
+ /* For P-t-P link the above route add will fail */
+ connman_inet_add_host_route(index, nameserver, NULL);
+ break;
+
+ case AF_INET6:
+ if (connman_inet_add_ipv6_host_route(index, nameserver,
+ gw) < 0)
+ connman_inet_add_ipv6_host_route(index, nameserver,
+ NULL);
+ break;
+ }
+}
+
+static void nameserver_add_routes(int index, char **nameservers,
+ const char *gw)
+{
+ int i, ns_family, gw_family;
+
+ gw_family = connman_inet_check_ipaddress(gw);
+ if (gw_family < 0)
+ return;
+
+ for (i = 0; nameservers[i]; i++) {
+ ns_family = connman_inet_check_ipaddress(nameservers[i]);
+ if (ns_family < 0 || ns_family != gw_family)
+ continue;
+
+ add_nameserver_route(ns_family, index, nameservers[i], gw);
+ }
+}
+
+static void nameserver_del_routes(int index, char **nameservers,
+ enum connman_ipconfig_type type)
+{
+ int i, family;
+
+ for (i = 0; nameservers[i]; i++) {
+ family = connman_inet_check_ipaddress(nameservers[i]);
+ if (family < 0)
+ continue;
+
+ switch (family) {
+ case AF_INET:
+ if (type != CONNMAN_IPCONFIG_TYPE_IPV6)
+ connman_inet_del_host_route(index,
+ nameservers[i]);
+ break;
+ case AF_INET6:
+ if (type != CONNMAN_IPCONFIG_TYPE_IPV4)
+ connman_inet_del_ipv6_host_route(index,
+ nameservers[i]);
+ break;
+ }
+ }
+}
+
+void __connman_service_nameserver_add_routes(struct connman_service *service,
+ const char *gw)
+{
+ int index;
+
+ if (!service)
+ return;
+
+ index = __connman_service_get_index(service);
+
+ if (service->nameservers_config) {
+ /*
+ * Configured nameserver takes preference over the
+ * discoverd nameserver gathered from DHCP, VPN, etc.
+ */
+ nameserver_add_routes(index, service->nameservers_config, gw);
+ } else if (service->nameservers) {
+ /*
+ * We add nameservers host routes for nameservers that
+ * are not on our subnet. For those who are, the subnet
+ * route will be installed by the time the dns proxy code
+ * tries to reach them. The subnet route is installed
+ * when setting the interface IP address.
+ */
+ nameserver_add_routes(index, service->nameservers, gw);
+ }
+}
+
+void __connman_service_nameserver_del_routes(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ int index;
+
+ if (!service)
+ return;
+
+ index = __connman_service_get_index(service);
+
+ if (service->nameservers_config)
+ nameserver_del_routes(index, service->nameservers_config,
+ type);
+ else if (service->nameservers)
+ nameserver_del_routes(index, service->nameservers, type);
+}
+
+static struct connman_stats *stats_get(struct connman_service *service)
+{
+ if (service->roaming)
+ return &service->stats_roaming;
+ else
+ return &service->stats;
+}
+
+static bool stats_enabled(struct connman_service *service)
+{
+ struct connman_stats *stats = stats_get(service);
+
+ return stats->enabled;
+}
+
+static void stats_start(struct connman_service *service)
+{
+ struct connman_stats *stats = stats_get(service);
+
+ DBG("service %p", service);
+
+ connman_verify_execute(stats != NULL, return);
+
+ if (!stats->timer)
+ return;
+
+ stats->enabled = true;
+ stats->data_last.time = stats->data.time;
+
+ g_timer_start(stats->timer);
+}
+
+static void stats_stop(struct connman_service *service)
+{
+ struct connman_stats *stats = stats_get(service);
+ unsigned int seconds;
+
+ DBG("service %p", service);
+
+ connman_verify_execute(stats != NULL, return);
+
+ if (!stats->timer)
+ return;
+
+ if (!stats->enabled)
+ return;
+
+ g_timer_stop(stats->timer);
+
+ seconds = g_timer_elapsed(stats->timer, NULL);
+ stats->data.time = stats->data_last.time + seconds;
+
+ stats->enabled = false;
+}
+
+static void reset_stats(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ /* home */
+ service->stats.valid = false;
+
+ service->stats.data.rx_packets = 0;
+ service->stats.data.tx_packets = 0;
+ service->stats.data.rx_bytes = 0;
+ service->stats.data.tx_bytes = 0;
+ service->stats.data.rx_errors = 0;
+ service->stats.data.tx_errors = 0;
+ service->stats.data.rx_dropped = 0;
+ service->stats.data.tx_dropped = 0;
+ service->stats.data.time = 0;
+ service->stats.data_last.time = 0;
+
+ g_timer_reset(service->stats.timer);
+
+ /* roaming */
+ service->stats_roaming.valid = false;
+
+ service->stats_roaming.data.rx_packets = 0;
+ service->stats_roaming.data.tx_packets = 0;
+ service->stats_roaming.data.rx_bytes = 0;
+ service->stats_roaming.data.tx_bytes = 0;
+ service->stats_roaming.data.rx_errors = 0;
+ service->stats_roaming.data.tx_errors = 0;
+ service->stats_roaming.data.rx_dropped = 0;
+ service->stats_roaming.data.tx_dropped = 0;
+ service->stats_roaming.data.time = 0;
+ service->stats_roaming.data_last.time = 0;
+
+ g_timer_reset(service->stats_roaming.timer);
+}
+
+struct connman_service *__connman_service_get_default(void)
+{
+ struct connman_service *service;
+
+ if (!service_list)
+ return NULL;
+
+ service = service_list->data;
+
+ if (!is_connected(service))
+ return NULL;
+
+ return service;
+}
+
+bool __connman_service_index_is_default(int index)
+{
+ struct connman_service *service;
+
+ if (index < 0)
+ return false;
+
+ service = __connman_service_get_default();
+
+ return __connman_service_get_index(service) == index;
+}
+
+static void default_changed(void)
+{
+ struct connman_service *service = __connman_service_get_default();
+
+ if (service == current_default)
+ return;
+
+ DBG("current default %p %s", current_default,
+ current_default ? current_default->identifier : "");
+ DBG("new default %p %s", service, service ? service->identifier : "");
+
+ __connman_service_timeserver_changed(current_default, NULL);
+
+ current_default = service;
+
+ if (service) {
+ if (service->hostname &&
+ connman_setting_get_bool("AllowHostnameUpdates"))
+ __connman_utsname_set_hostname(service->hostname);
+
+ if (service->domainname)
+ __connman_utsname_set_domainname(service->domainname);
+ }
+
+ __connman_notifier_default_changed(service);
+}
+
+static void state_changed(struct connman_service *service)
+{
+ const char *str;
+
+ __connman_notifier_service_state_changed(service, service->state);
+
+ str = state2string(service->state);
+ if (!str)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "State",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void strength_changed(struct connman_service *service)
+{
+ if (service->strength == 0)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Strength",
+ DBUS_TYPE_BYTE, &service->strength);
+}
+
+static void favorite_changed(struct connman_service *service)
+{
+ dbus_bool_t favorite;
+
+ if (!service->path)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ favorite = service->favorite;
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Favorite",
+ DBUS_TYPE_BOOLEAN, &favorite);
+}
+
+static void immutable_changed(struct connman_service *service)
+{
+ dbus_bool_t immutable;
+
+ if (!service->path)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ immutable = service->immutable;
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Immutable",
+ DBUS_TYPE_BOOLEAN, &immutable);
+}
+
+static void roaming_changed(struct connman_service *service)
+{
+ dbus_bool_t roaming;
+
+ if (!service->path)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ roaming = service->roaming;
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Roaming",
+ DBUS_TYPE_BOOLEAN, &roaming);
+}
+
+static void autoconnect_changed(struct connman_service *service)
+{
+ dbus_bool_t autoconnect;
+
+ if (!service->path)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ autoconnect = service->autoconnect;
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "AutoConnect",
+ DBUS_TYPE_BOOLEAN, &autoconnect);
+}
+
+static void append_security(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ const char *str;
+
+ str = security2string(service->security);
+ if (str)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &str);
+
+ /*
+ * Some access points incorrectly advertise WPS even when they
+ * are configured as open or no security, so filter
+ * appropriately.
+ */
+ if (service->wps) {
+ switch (service->security) {
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ case CONNMAN_SERVICE_SECURITY_WPA:
+ case CONNMAN_SERVICE_SECURITY_RSN:
+ str = "wps";
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &str);
+ break;
+ case CONNMAN_SERVICE_SECURITY_UNKNOWN:
+ case CONNMAN_SERVICE_SECURITY_NONE:
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ case CONNMAN_SERVICE_SECURITY_8021X:
+ break;
+ }
+ }
+}
+
+static void append_ethernet(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_append_ethernet(service->ipconfig_ipv4,
+ iter);
+ else if (service->ipconfig_ipv6)
+ __connman_ipconfig_append_ethernet(service->ipconfig_ipv6,
+ iter);
+}
+
+static void append_ipv4(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (!is_connected_state(service, service->state_ipv4))
+ return;
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_append_ipv4(service->ipconfig_ipv4, iter);
+}
+
+static void append_ipv6(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (!is_connected_state(service, service->state_ipv6))
+ return;
+
+ if (service->ipconfig_ipv6)
+ __connman_ipconfig_append_ipv6(service->ipconfig_ipv6, iter,
+ service->ipconfig_ipv4);
+}
+
+static void append_ipv4config(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_append_ipv4config(service->ipconfig_ipv4,
+ iter);
+}
+
+static void append_ipv6config(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (service->ipconfig_ipv6)
+ __connman_ipconfig_append_ipv6config(service->ipconfig_ipv6,
+ iter);
+}
+
+static void append_nameservers(DBusMessageIter *iter,
+ struct connman_service *service, char **servers)
+{
+ int i;
+ bool available = true;
+
+ for (i = 0; servers[i]; i++) {
+ if (service)
+ available = nameserver_available(service,
+ CONNMAN_IPCONFIG_TYPE_ALL,
+ servers[i]);
+
+ DBG("servers[%d] %s available %d", i, servers[i], available);
+
+ if (available)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &servers[i]);
+ }
+}
+
+static void append_dns(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (!is_connected(service))
+ return;
+
+ if (service->nameservers_config) {
+ append_nameservers(iter, service, service->nameservers_config);
+ return;
+ } else {
+ if (service->nameservers)
+ append_nameservers(iter, service,
+ service->nameservers);
+
+ if (service->nameservers_auto)
+ append_nameservers(iter, service,
+ service->nameservers_auto);
+
+ if (!service->nameservers && !service->nameservers_auto) {
+ char **ns;
+
+ DBG("append fallback nameservers");
+
+ ns = connman_setting_get_string_list("FallbackNameservers");
+ if (ns)
+ append_nameservers(iter, service, ns);
+ }
+ }
+}
+
+static void append_dnsconfig(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (!service->nameservers_config)
+ return;
+
+ append_nameservers(iter, NULL, service->nameservers_config);
+}
+
+static void append_ts(DBusMessageIter *iter, void *user_data)
+{
+ GSList *list = user_data;
+
+ while (list) {
+ char *timeserver = list->data;
+
+ if (timeserver)
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ ×erver);
+
+ list = g_slist_next(list);
+ }
+}
+
+static void append_tsconfig(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ int i;
+
+ if (!service->timeservers_config)
+ return;
+
+ for (i = 0; service->timeservers_config[i]; i++) {
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING,
+ &service->timeservers_config[i]);
+ }
+}
+
+static void append_domainconfig(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ int i;
+
+ if (!service->domains)
+ return;
+
+ for (i = 0; service->domains[i]; i++)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &service->domains[i]);
+}
+
+static void append_domain(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (!is_connected(service) &&
+ !is_connecting(service))
+ return;
+
+ if (service->domains)
+ append_domainconfig(iter, user_data);
+ else if (service->domainname)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &service->domainname);
+}
+
+static void append_proxies(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ int i;
+
+ if (!service->proxies)
+ return;
+
+ for (i = 0; service->proxies[i]; i++)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &service->proxies[i]);
+}
+
+static void append_excludes(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ int i;
+
+ if (!service->excludes)
+ return;
+
+ for (i = 0; service->excludes[i]; i++)
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &service->excludes[i]);
+}
+
+static void append_proxy(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ enum connman_service_proxy_method proxy;
+ const char *pac = NULL;
+ const char *method = proxymethod2string(
+ CONNMAN_SERVICE_PROXY_METHOD_DIRECT);
+
+ if (!is_connected(service))
+ return;
+
+ proxy = connman_service_get_proxy_method(service);
+
+ switch (proxy) {
+ case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
+ return;
+ case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
+ goto done;
+ case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
+ connman_dbus_dict_append_array(iter, "Servers",
+ DBUS_TYPE_STRING, append_proxies,
+ service);
+
+ connman_dbus_dict_append_array(iter, "Excludes",
+ DBUS_TYPE_STRING, append_excludes,
+ service);
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
+ /* Maybe DHCP, or WPAD, has provided an url for a pac file */
+ if (service->ipconfig_ipv4)
+ pac = __connman_ipconfig_get_proxy_autoconfig(
+ service->ipconfig_ipv4);
+ else if (service->ipconfig_ipv6)
+ pac = __connman_ipconfig_get_proxy_autoconfig(
+ service->ipconfig_ipv6);
+
+ if (!service->pac && !pac)
+ goto done;
+
+ if (service->pac)
+ pac = service->pac;
+
+ connman_dbus_dict_append_basic(iter, "URL",
+ DBUS_TYPE_STRING, &pac);
+ break;
+ }
+
+ method = proxymethod2string(proxy);
+
+done:
+ connman_dbus_dict_append_basic(iter, "Method",
+ DBUS_TYPE_STRING, &method);
+}
+
+static void append_proxyconfig(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ const char *method;
+
+ if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
+ return;
+
+ switch (service->proxy_config) {
+ case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
+ return;
+ case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
+ if (service->proxies)
+ connman_dbus_dict_append_array(iter, "Servers",
+ DBUS_TYPE_STRING,
+ append_proxies, service);
+
+ if (service->excludes)
+ connman_dbus_dict_append_array(iter, "Excludes",
+ DBUS_TYPE_STRING,
+ append_excludes, service);
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
+ if (service->pac)
+ connman_dbus_dict_append_basic(iter, "URL",
+ DBUS_TYPE_STRING, &service->pac);
+ break;
+ }
+
+ method = proxymethod2string(service->proxy_config);
+
+ connman_dbus_dict_append_basic(iter, "Method",
+ DBUS_TYPE_STRING, &method);
+}
+
+static void append_provider(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ if (!is_connected(service))
+ return;
+
+ if (service->provider)
+ __connman_provider_append_properties(service->provider, iter);
+}
+
+
+static void settings_changed(struct connman_service *service,
+ struct connman_ipconfig *ipconfig)
+{
+ enum connman_ipconfig_type type;
+
+ if (!allow_property_changed(service))
+ return;
+
+ type = __connman_ipconfig_get_config_type(ipconfig);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE, "IPv4",
+ append_ipv4, service);
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE, "IPv6",
+ append_ipv6, service);
+
+ __connman_notifier_ipconfig_changed(service, ipconfig);
+}
+
+static void ipv4_configuration_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE,
+ "IPv4.Configuration",
+ append_ipv4config,
+ service);
+}
+
+static void ipv6_configuration_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE,
+ "IPv6.Configuration",
+ append_ipv6config,
+ service);
+}
+
+static void dns_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_array(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Nameservers",
+ DBUS_TYPE_STRING, append_dns, service);
+}
+
+static void dns_configuration_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_array(service->path,
+ CONNMAN_SERVICE_INTERFACE,
+ "Nameservers.Configuration",
+ DBUS_TYPE_STRING, append_dnsconfig, service);
+
+ dns_changed(service);
+}
+
+static void domain_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_array(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Domains",
+ DBUS_TYPE_STRING, append_domain, service);
+}
+
+static void domain_configuration_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_array(service->path,
+ CONNMAN_SERVICE_INTERFACE,
+ "Domains.Configuration",
+ DBUS_TYPE_STRING, append_domainconfig, service);
+}
+
+static void proxy_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Proxy",
+ append_proxy, service);
+}
+
+static void proxy_configuration_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Proxy.Configuration",
+ append_proxyconfig, service);
+
+ proxy_changed(service);
+}
+
+static void timeservers_configuration_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_array(service->path,
+ CONNMAN_SERVICE_INTERFACE,
+ "Timeservers.Configuration",
+ DBUS_TYPE_STRING,
+ append_tsconfig, service);
+}
+
+static void link_changed(struct connman_service *service)
+{
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_dict(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Ethernet",
+ append_ethernet, service);
+}
+
+static void stats_append_counters(DBusMessageIter *dict,
+ struct connman_stats_data *stats,
+ struct connman_stats_data *counters,
+ bool append_all)
+{
+ if (counters->rx_packets != stats->rx_packets || append_all) {
+ counters->rx_packets = stats->rx_packets;
+ connman_dbus_dict_append_basic(dict, "RX.Packets",
+ DBUS_TYPE_UINT32, &stats->rx_packets);
+ }
+
+ if (counters->tx_packets != stats->tx_packets || append_all) {
+ counters->tx_packets = stats->tx_packets;
+ connman_dbus_dict_append_basic(dict, "TX.Packets",
+ DBUS_TYPE_UINT32, &stats->tx_packets);
+ }
+
+ if (counters->rx_bytes != stats->rx_bytes || append_all) {
+ counters->rx_bytes = stats->rx_bytes;
+ connman_dbus_dict_append_basic(dict, "RX.Bytes",
+ DBUS_TYPE_UINT32, &stats->rx_bytes);
+ }
+
+ if (counters->tx_bytes != stats->tx_bytes || append_all) {
+ counters->tx_bytes = stats->tx_bytes;
+ connman_dbus_dict_append_basic(dict, "TX.Bytes",
+ DBUS_TYPE_UINT32, &stats->tx_bytes);
+ }
+
+ if (counters->rx_errors != stats->rx_errors || append_all) {
+ counters->rx_errors = stats->rx_errors;
+ connman_dbus_dict_append_basic(dict, "RX.Errors",
+ DBUS_TYPE_UINT32, &stats->rx_errors);
+ }
+
+ if (counters->tx_errors != stats->tx_errors || append_all) {
+ counters->tx_errors = stats->tx_errors;
+ connman_dbus_dict_append_basic(dict, "TX.Errors",
+ DBUS_TYPE_UINT32, &stats->tx_errors);
+ }
+
+ if (counters->rx_dropped != stats->rx_dropped || append_all) {
+ counters->rx_dropped = stats->rx_dropped;
+ connman_dbus_dict_append_basic(dict, "RX.Dropped",
+ DBUS_TYPE_UINT32, &stats->rx_dropped);
+ }
+
+ if (counters->tx_dropped != stats->tx_dropped || append_all) {
+ counters->tx_dropped = stats->tx_dropped;
+ connman_dbus_dict_append_basic(dict, "TX.Dropped",
+ DBUS_TYPE_UINT32, &stats->tx_dropped);
+ }
+
+ if (counters->time != stats->time || append_all) {
+ counters->time = stats->time;
+ connman_dbus_dict_append_basic(dict, "Time",
+ DBUS_TYPE_UINT32, &stats->time);
+ }
+}
+
+static void stats_append(struct connman_service *service,
+ const char *counter,
+ struct connman_stats_counter *counters,
+ bool append_all)
+{
+ DBusMessageIter array, dict;
+ DBusMessage *msg;
+
+ DBG("service %p counter %s", service, counter);
+
+ msg = dbus_message_new(DBUS_MESSAGE_TYPE_METHOD_CALL);
+ if (!msg)
+ return;
+
+ dbus_message_append_args(msg, DBUS_TYPE_OBJECT_PATH,
+ &service->path, DBUS_TYPE_INVALID);
+
+ dbus_message_iter_init_append(msg, &array);
+
+ /* home counter */
+ connman_dbus_dict_open(&array, &dict);
+
+ stats_append_counters(&dict, &service->stats.data,
+ &counters->stats.data, append_all);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ /* roaming counter */
+ connman_dbus_dict_open(&array, &dict);
+
+ stats_append_counters(&dict, &service->stats_roaming.data,
+ &counters->stats_roaming.data, append_all);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ __connman_counter_send_usage(counter, msg);
+}
+
+static void stats_update(struct connman_service *service,
+ unsigned int rx_packets, unsigned int tx_packets,
+ unsigned int rx_bytes, unsigned int tx_bytes,
+ unsigned int rx_errors, unsigned int tx_errors,
+ unsigned int rx_dropped, unsigned int tx_dropped)
+{
+ struct connman_stats *stats = stats_get(service);
+ struct connman_stats_data *data_last = &stats->data_last;
+ struct connman_stats_data *data = &stats->data;
+ unsigned int seconds;
+
+ DBG("service %p", service);
+
+ if (stats->valid) {
+ data->rx_packets +=
+ rx_packets - data_last->rx_packets;
+ data->tx_packets +=
+ tx_packets - data_last->tx_packets;
+ data->rx_bytes +=
+ rx_bytes - data_last->rx_bytes;
+ data->tx_bytes +=
+ tx_bytes - data_last->tx_bytes;
+ data->rx_errors +=
+ rx_errors - data_last->rx_errors;
+ data->tx_errors +=
+ tx_errors - data_last->tx_errors;
+ data->rx_dropped +=
+ rx_dropped - data_last->rx_dropped;
+ data->tx_dropped +=
+ tx_dropped - data_last->tx_dropped;
+ } else {
+ stats->valid = true;
+ }
+
+ data_last->rx_packets = rx_packets;
+ data_last->tx_packets = tx_packets;
+ data_last->rx_bytes = rx_bytes;
+ data_last->tx_bytes = tx_bytes;
+ data_last->rx_errors = rx_errors;
+ data_last->tx_errors = tx_errors;
+ data_last->rx_dropped = rx_dropped;
+ data_last->tx_dropped = tx_dropped;
+
+ seconds = g_timer_elapsed(stats->timer, NULL);
+ stats->data.time = stats->data_last.time + seconds;
+}
+
+void __connman_service_notify(struct connman_service *service,
+ unsigned int rx_packets, unsigned int tx_packets,
+ unsigned int rx_bytes, unsigned int tx_bytes,
+ unsigned int rx_errors, unsigned int tx_errors,
+ unsigned int rx_dropped, unsigned int tx_dropped)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ const char *counter;
+ struct connman_stats_counter *counters;
+ struct connman_stats_data *data;
+ int err;
+
+ if (!service)
+ return;
+
+ if (!is_connected(service))
+ return;
+
+ stats_update(service,
+ rx_packets, tx_packets,
+ rx_bytes, tx_bytes,
+ rx_errors, tx_errors,
+ rx_dropped, tx_dropped);
+
+ data = &stats_get(service)->data;
+ err = __connman_stats_update(service, service->roaming, data);
+ if (err < 0)
+ connman_error("Failed to store statistics for %s",
+ service->identifier);
+
+ g_hash_table_iter_init(&iter, service->counter_table);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ counter = key;
+ counters = value;
+
+ stats_append(service, counter, counters, counters->append_all);
+ counters->append_all = false;
+ }
+}
+
+int __connman_service_counter_register(const char *counter)
+{
+ struct connman_service *service;
+ GList *list;
+ struct connman_stats_counter *counters;
+
+ DBG("counter %s", counter);
+
+ counter_list = g_slist_prepend(counter_list, (gpointer)counter);
+
+ for (list = service_list; list; list = list->next) {
+ service = list->data;
+
+ counters = g_try_new0(struct connman_stats_counter, 1);
+ if (!counters)
+ return -ENOMEM;
+
+ counters->append_all = true;
+
+ g_hash_table_replace(service->counter_table, (gpointer)counter,
+ counters);
+ }
+
+ return 0;
+}
+
+void __connman_service_counter_unregister(const char *counter)
+{
+ struct connman_service *service;
+ GList *list;
+
+ DBG("counter %s", counter);
+
+ for (list = service_list; list; list = list->next) {
+ service = list->data;
+
+ g_hash_table_remove(service->counter_table, counter);
+ }
+
+ counter_list = g_slist_remove(counter_list, counter);
+}
+
+int __connman_service_iterate_services(service_iterate_cb cb, void *user_data)
+{
+ GList *list;
+
+ for (list = service_list; list; list = list->next) {
+ struct connman_service *service = list->data;
+
+ cb(service, user_data);
+ }
+
+ return 0;
+}
+
+static void append_properties(DBusMessageIter *dict, dbus_bool_t limited,
+ struct connman_service *service)
+{
+ dbus_bool_t val;
+ const char *str;
+ GSList *list;
+
+ str = __connman_service_type2string(service->type);
+ if (str)
+ connman_dbus_dict_append_basic(dict, "Type",
+ DBUS_TYPE_STRING, &str);
+
+ connman_dbus_dict_append_array(dict, "Security",
+ DBUS_TYPE_STRING, append_security, service);
+
+ // TODO: This is a temporary hack to support fetching the passphrase
+ // from lowpan networks!
+
+ // Long term, I’d rather have a way for a ConnMan client to be able to
+ // explicitly query authentication credentials for a service instead of always
+ // providing them with the service dictionary. My reasoning is that since
+ // the dictionary has never had sensitive information in it before that
+ // there might be code that is using it in a way that would not be
+ // appropriate for network security credentials. More about hardening
+ // than anything else.
+
+ if ((service->type == CONNMAN_SERVICE_TYPE_LOWPAN)
+ && (service->passphrase != NULL))
+ connman_dbus_dict_append_basic(dict, "Passphrase",
+ DBUS_TYPE_STRING, &service->passphrase);
+
+ str = state2string(service->state);
+ if (str)
+ connman_dbus_dict_append_basic(dict, "State",
+ DBUS_TYPE_STRING, &str);
+
+ str = error2string(service->error);
+ if (str)
+ connman_dbus_dict_append_basic(dict, "Error",
+ DBUS_TYPE_STRING, &str);
+
+ if (service->strength > 0)
+ connman_dbus_dict_append_basic(dict, "Strength",
+ DBUS_TYPE_BYTE, &service->strength);
+
+ val = service->favorite;
+ connman_dbus_dict_append_basic(dict, "Favorite",
+ DBUS_TYPE_BOOLEAN, &val);
+
+ val = service->immutable;
+ connman_dbus_dict_append_basic(dict, "Immutable",
+ DBUS_TYPE_BOOLEAN, &val);
+
+ if (service->favorite)
+ val = service->autoconnect;
+ else
+ val = service->favorite;
+
+ connman_dbus_dict_append_basic(dict, "AutoConnect",
+ DBUS_TYPE_BOOLEAN, &val);
+
+ if (service->name)
+ connman_dbus_dict_append_basic(dict, "Name",
+ DBUS_TYPE_STRING, &service->name);
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ val = service->roaming;
+ connman_dbus_dict_append_basic(dict, "Roaming",
+ DBUS_TYPE_BOOLEAN, &val);
+
+ connman_dbus_dict_append_dict(dict, "Ethernet",
+ append_ethernet, service);
+ break;
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ connman_dbus_dict_append_dict(dict, "Ethernet",
+ append_ethernet, service);
+ break;
+ }
+
+ connman_dbus_dict_append_dict(dict, "IPv4", append_ipv4, service);
+
+ connman_dbus_dict_append_dict(dict, "IPv4.Configuration",
+ append_ipv4config, service);
+
+ connman_dbus_dict_append_dict(dict, "IPv6", append_ipv6, service);
+
+ connman_dbus_dict_append_dict(dict, "IPv6.Configuration",
+ append_ipv6config, service);
+
+ connman_dbus_dict_append_array(dict, "Nameservers",
+ DBUS_TYPE_STRING, append_dns, service);
+
+ connman_dbus_dict_append_array(dict, "Nameservers.Configuration",
+ DBUS_TYPE_STRING, append_dnsconfig, service);
+
+ if (service->state == CONNMAN_SERVICE_STATE_READY ||
+ service->state == CONNMAN_SERVICE_STATE_ONLINE)
+ list = __connman_timeserver_get_all(service);
+ else
+ list = NULL;
+
+ connman_dbus_dict_append_array(dict, "Timeservers",
+ DBUS_TYPE_STRING, append_ts, list);
+
+ g_slist_free_full(list, g_free);
+
+ connman_dbus_dict_append_array(dict, "Timeservers.Configuration",
+ DBUS_TYPE_STRING, append_tsconfig, service);
+
+ connman_dbus_dict_append_array(dict, "Domains",
+ DBUS_TYPE_STRING, append_domain, service);
+
+ connman_dbus_dict_append_array(dict, "Domains.Configuration",
+ DBUS_TYPE_STRING, append_domainconfig, service);
+
+ connman_dbus_dict_append_dict(dict, "Proxy", append_proxy, service);
+
+ connman_dbus_dict_append_dict(dict, "Proxy.Configuration",
+ append_proxyconfig, service);
+
+ connman_dbus_dict_append_dict(dict, "Provider",
+ append_provider, service);
+}
+
+static void append_struct_service(DBusMessageIter *iter,
+ connman_dbus_append_cb_t function,
+ struct connman_service *service)
+{
+ DBusMessageIter entry, dict;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+ &service->path);
+
+ connman_dbus_dict_open(&entry, &dict);
+ if (function)
+ function(&dict, service);
+ connman_dbus_dict_close(&entry, &dict);
+
+ dbus_message_iter_close_container(iter, &entry);
+}
+
+static void append_dict_properties(DBusMessageIter *dict, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ append_properties(dict, TRUE, service);
+}
+
+static void append_struct(gpointer value, gpointer user_data)
+{
+ struct connman_service *service = value;
+ DBusMessageIter *iter = user_data;
+
+ if (!service->path)
+ return;
+
+ append_struct_service(iter, append_dict_properties, service);
+}
+
+void __connman_service_list_struct(DBusMessageIter *iter)
+{
+ g_list_foreach(service_list, append_struct, iter);
+}
+
+bool __connman_service_is_hidden(struct connman_service *service)
+{
+ return service->hidden;
+}
+
+bool
+__connman_service_is_split_routing(struct connman_service *service)
+{
+ return service->do_split_routing;
+}
+
+bool __connman_service_index_is_split_routing(int index)
+{
+ struct connman_service *service;
+
+ if (index < 0)
+ return false;
+
+ service = __connman_service_lookup_from_index(index);
+ if (!service)
+ return false;
+
+ return __connman_service_is_split_routing(service);
+}
+
+int __connman_service_get_index(struct connman_service *service)
+{
+ if (!service)
+ return -1;
+
+ if (service->network)
+ return connman_network_get_index(service->network);
+ else if (service->provider)
+ return connman_provider_get_index(service->provider);
+
+ return -1;
+}
+
+void __connman_service_set_hidden(struct connman_service *service)
+{
+ if (!service || service->hidden)
+ return;
+
+ service->hidden_service = true;
+}
+
+void __connman_service_set_hostname(struct connman_service *service,
+ const char *hostname)
+{
+ if (!service || service->hidden)
+ return;
+
+ g_free(service->hostname);
+ service->hostname = g_strdup(hostname);
+}
+
+const char *__connman_service_get_hostname(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->hostname;
+}
+
+void __connman_service_set_domainname(struct connman_service *service,
+ const char *domainname)
+{
+ if (!service || service->hidden)
+ return;
+
+ g_free(service->domainname);
+ service->domainname = g_strdup(domainname);
+
+ domain_changed(service);
+}
+
+const char *connman_service_get_domainname(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ if (service->domains)
+ return service->domains[0];
+ else
+ return service->domainname;
+}
+
+char **connman_service_get_nameservers(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ if (service->nameservers_config)
+ return g_strdupv(service->nameservers_config);
+ else if (service->nameservers ||
+ service->nameservers_auto) {
+ int len = 0, len_auto = 0, i;
+ char **nameservers;
+
+ if (service->nameservers)
+ len = g_strv_length(service->nameservers);
+ if (service->nameservers_auto)
+ len_auto = g_strv_length(service->nameservers_auto);
+
+ nameservers = g_try_new0(char *, len + len_auto + 1);
+ if (!nameservers)
+ return NULL;
+
+ for (i = 0; i < len; i++)
+ nameservers[i] = g_strdup(service->nameservers[i]);
+
+ for (i = 0; i < len_auto; i++)
+ nameservers[i + len] =
+ g_strdup(service->nameservers_auto[i]);
+
+ return nameservers;
+ }
+
+ return g_strdupv(connman_setting_get_string_list("FallbackNameservers"));
+}
+
+char **connman_service_get_timeservers_config(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->timeservers_config;
+}
+
+char **connman_service_get_timeservers(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->timeservers;
+}
+
+void connman_service_set_proxy_method(struct connman_service *service,
+ enum connman_service_proxy_method method)
+{
+ if (!service || service->hidden)
+ return;
+
+ service->proxy = method;
+
+ proxy_changed(service);
+
+ if (method != CONNMAN_SERVICE_PROXY_METHOD_AUTO)
+ __connman_notifier_proxy_changed(service);
+}
+
+enum connman_service_proxy_method connman_service_get_proxy_method(
+ struct connman_service *service)
+{
+ if (!service)
+ return CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
+
+ if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN) {
+ if (service->proxy_config == CONNMAN_SERVICE_PROXY_METHOD_AUTO &&
+ !service->pac)
+ return service->proxy;
+
+ return service->proxy_config;
+ }
+
+ return service->proxy;
+}
+
+char **connman_service_get_proxy_servers(struct connman_service *service)
+{
+ return g_strdupv(service->proxies);
+}
+
+char **connman_service_get_proxy_excludes(struct connman_service *service)
+{
+ return g_strdupv(service->excludes);
+}
+
+const char *connman_service_get_proxy_url(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->pac;
+}
+
+void __connman_service_set_proxy_autoconfig(struct connman_service *service,
+ const char *url)
+{
+ if (!service || service->hidden)
+ return;
+
+ service->proxy = CONNMAN_SERVICE_PROXY_METHOD_AUTO;
+
+ if (service->ipconfig_ipv4) {
+ if (__connman_ipconfig_set_proxy_autoconfig(
+ service->ipconfig_ipv4, url) < 0)
+ return;
+ } else if (service->ipconfig_ipv6) {
+ if (__connman_ipconfig_set_proxy_autoconfig(
+ service->ipconfig_ipv6, url) < 0)
+ return;
+ } else
+ return;
+
+ proxy_changed(service);
+
+ __connman_notifier_proxy_changed(service);
+}
+
+const char *connman_service_get_proxy_autoconfig(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ if (service->ipconfig_ipv4)
+ return __connman_ipconfig_get_proxy_autoconfig(
+ service->ipconfig_ipv4);
+ else if (service->ipconfig_ipv6)
+ return __connman_ipconfig_get_proxy_autoconfig(
+ service->ipconfig_ipv6);
+ return NULL;
+}
+
+void __connman_service_set_timeservers(struct connman_service *service,
+ char **timeservers)
+{
+ int i;
+
+ if (!service)
+ return;
+
+ g_strfreev(service->timeservers);
+ service->timeservers = NULL;
+
+ for (i = 0; timeservers && timeservers[i]; i++)
+ __connman_service_timeserver_append(service, timeservers[i]);
+}
+
+int __connman_service_timeserver_append(struct connman_service *service,
+ const char *timeserver)
+{
+ int len;
+
+ DBG("service %p timeserver %s", service, timeserver);
+
+ if (!timeserver)
+ return -EINVAL;
+
+ if (service->timeservers) {
+ int i;
+
+ for (i = 0; service->timeservers[i]; i++)
+ if (g_strcmp0(service->timeservers[i], timeserver) == 0)
+ return -EEXIST;
+
+ len = g_strv_length(service->timeservers);
+ service->timeservers = g_try_renew(char *, service->timeservers,
+ len + 2);
+ } else {
+ len = 0;
+ service->timeservers = g_try_new0(char *, len + 2);
+ }
+
+ if (!service->timeservers)
+ return -ENOMEM;
+
+ service->timeservers[len] = g_strdup(timeserver);
+ service->timeservers[len + 1] = NULL;
+
+ return 0;
+}
+
+int __connman_service_timeserver_remove(struct connman_service *service,
+ const char *timeserver)
+{
+ char **servers;
+ int len, i, j, found = 0;
+
+ DBG("service %p timeserver %s", service, timeserver);
+
+ if (!timeserver)
+ return -EINVAL;
+
+ if (!service->timeservers)
+ return 0;
+
+ for (i = 0; service->timeservers &&
+ service->timeservers[i]; i++)
+ if (g_strcmp0(service->timeservers[i], timeserver) == 0) {
+ found = 1;
+ break;
+ }
+
+ if (found == 0)
+ return 0;
+
+ len = g_strv_length(service->timeservers);
+
+ if (len == 1) {
+ g_strfreev(service->timeservers);
+ service->timeservers = NULL;
+
+ return 0;
+ }
+
+ servers = g_try_new0(char *, len);
+ if (!servers)
+ return -ENOMEM;
+
+ for (i = 0, j = 0; i < len; i++) {
+ if (g_strcmp0(service->timeservers[i], timeserver) != 0) {
+ servers[j] = g_strdup(service->timeservers[i]);
+ if (!servers[j])
+ return -ENOMEM;
+ j++;
+ }
+ }
+ servers[len - 1] = NULL;
+
+ g_strfreev(service->timeservers);
+ service->timeservers = servers;
+
+ return 0;
+}
+
+void __connman_service_timeserver_changed(struct connman_service *service,
+ GSList *ts_list)
+{
+ if (!service)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ connman_dbus_property_changed_array(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Timeservers",
+ DBUS_TYPE_STRING, append_ts, ts_list);
+}
+
+void __connman_service_set_pac(struct connman_service *service,
+ const char *pac)
+{
+ if (service->hidden)
+ return;
+ g_free(service->pac);
+ service->pac = g_strdup(pac);
+
+ proxy_changed(service);
+}
+
+void __connman_service_set_identity(struct connman_service *service,
+ const char *identity)
+{
+ if (service->immutable || service->hidden)
+ return;
+
+ g_free(service->identity);
+ service->identity = g_strdup(identity);
+
+ if (service->network)
+ connman_network_set_string(service->network,
+ "WiFi.Identity",
+ service->identity);
+}
+
+void __connman_service_set_agent_identity(struct connman_service *service,
+ const char *agent_identity)
+{
+ if (service->hidden)
+ return;
+ g_free(service->agent_identity);
+ service->agent_identity = g_strdup(agent_identity);
+
+ if (service->network)
+ connman_network_set_string(service->network,
+ "WiFi.AgentIdentity",
+ service->agent_identity);
+}
+
+static int check_passphrase(enum connman_service_security security,
+ const char *passphrase)
+{
+ guint i;
+ gsize length;
+
+ if (!passphrase)
+ return 0;
+
+ length = strlen(passphrase);
+
+ switch (security) {
+ case CONNMAN_SERVICE_SECURITY_UNKNOWN:
+ case CONNMAN_SERVICE_SECURITY_NONE:
+ case CONNMAN_SERVICE_SECURITY_WPA:
+ case CONNMAN_SERVICE_SECURITY_RSN:
+
+ DBG("service security '%s' (%d) not handled",
+ security2string(security), security);
+
+ return -EOPNOTSUPP;
+
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ /* A raw key is always 64 bytes length,
+ * its content is in hex representation.
+ * A PSK key must be between [8..63].
+ */
+ if (length == 64) {
+ for (i = 0; i < 64; i++)
+ if (!isxdigit((unsigned char)
+ passphrase[i]))
+ return -ENOKEY;
+ } else if (length < 8 || length > 63)
+ return -ENOKEY;
+ break;
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ /* length of WEP key is 10 or 26
+ * length of WEP passphrase is 5 or 13
+ */
+ if (length == 10 || length == 26) {
+ for (i = 0; i < length; i++)
+ if (!isxdigit((unsigned char)
+ passphrase[i]))
+ return -ENOKEY;
+ } else if (length != 5 && length != 13)
+ return -ENOKEY;
+ break;
+
+ case CONNMAN_SERVICE_SECURITY_8021X:
+ break;
+ }
+
+ return 0;
+}
+
+int __connman_service_set_passphrase(struct connman_service *service,
+ const char *passphrase)
+{
+ int err;
+
+ if (service->hidden)
+ return -EINVAL;
+
+ if (service->immutable &&
+ service->security != CONNMAN_SERVICE_SECURITY_8021X)
+ return -EINVAL;
+
+ err = check_passphrase(service->security, passphrase);
+
+ if (err < 0)
+ return err;
+
+ g_free(service->passphrase);
+ service->passphrase = g_strdup(passphrase);
+
+ if (service->network)
+ connman_network_set_string(service->network, "WiFi.Passphrase",
+ service->passphrase);
+
+ return 0;
+}
+
+const char *__connman_service_get_passphrase(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->passphrase;
+}
+
+static DBusMessage *get_properties(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+ DBusMessage *reply;
+ DBusMessageIter array, dict;
+
+ DBG("service %p", service);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &array);
+
+ connman_dbus_dict_open(&array, &dict);
+ append_properties(&dict, FALSE, service);
+ connman_dbus_dict_close(&array, &dict);
+
+ return reply;
+}
+
+static int update_proxy_configuration(struct connman_service *service,
+ DBusMessageIter *array)
+{
+ DBusMessageIter dict;
+ enum connman_service_proxy_method method;
+ GString *servers_str = NULL;
+ GString *excludes_str = NULL;
+ const char *url = NULL;
+
+ method = CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
+
+ dbus_message_iter_recurse(array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, variant;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ goto error;
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ goto error;
+
+ dbus_message_iter_recurse(&entry, &variant);
+
+ type = dbus_message_iter_get_arg_type(&variant);
+
+ if (g_str_equal(key, "Method")) {
+ const char *val;
+
+ if (type != DBUS_TYPE_STRING)
+ goto error;
+
+ dbus_message_iter_get_basic(&variant, &val);
+ method = string2proxymethod(val);
+ } else if (g_str_equal(key, "URL")) {
+ if (type != DBUS_TYPE_STRING)
+ goto error;
+
+ dbus_message_iter_get_basic(&variant, &url);
+ } else if (g_str_equal(key, "Servers")) {
+ DBusMessageIter str_array;
+
+ if (type != DBUS_TYPE_ARRAY)
+ goto error;
+
+ servers_str = g_string_new(NULL);
+ if (!servers_str)
+ goto error;
+
+ dbus_message_iter_recurse(&variant, &str_array);
+
+ while (dbus_message_iter_get_arg_type(&str_array) ==
+ DBUS_TYPE_STRING) {
+ char *val = NULL;
+
+ dbus_message_iter_get_basic(&str_array, &val);
+
+ if (servers_str->len > 0)
+ g_string_append_printf(servers_str,
+ " %s", val);
+ else
+ g_string_append(servers_str, val);
+
+ dbus_message_iter_next(&str_array);
+ }
+ } else if (g_str_equal(key, "Excludes")) {
+ DBusMessageIter str_array;
+
+ if (type != DBUS_TYPE_ARRAY)
+ goto error;
+
+ excludes_str = g_string_new(NULL);
+ if (!excludes_str)
+ goto error;
+
+ dbus_message_iter_recurse(&variant, &str_array);
+
+ while (dbus_message_iter_get_arg_type(&str_array) ==
+ DBUS_TYPE_STRING) {
+ char *val = NULL;
+
+ dbus_message_iter_get_basic(&str_array, &val);
+
+ if (excludes_str->len > 0)
+ g_string_append_printf(excludes_str,
+ " %s", val);
+ else
+ g_string_append(excludes_str, val);
+
+ dbus_message_iter_next(&str_array);
+ }
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ switch (method) {
+ case CONNMAN_SERVICE_PROXY_METHOD_DIRECT:
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_MANUAL:
+ if (!servers_str && !service->proxies)
+ goto error;
+
+ if (servers_str) {
+ g_strfreev(service->proxies);
+
+ if (servers_str->len > 0)
+ service->proxies = g_strsplit_set(
+ servers_str->str, " ", 0);
+ else
+ service->proxies = NULL;
+ }
+
+ if (excludes_str) {
+ g_strfreev(service->excludes);
+
+ if (excludes_str->len > 0)
+ service->excludes = g_strsplit_set(
+ excludes_str->str, " ", 0);
+ else
+ service->excludes = NULL;
+ }
+
+ if (!service->proxies)
+ method = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
+
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_AUTO:
+ g_free(service->pac);
+
+ if (url && strlen(url) > 0)
+ service->pac = g_strdup(url);
+ else
+ service->pac = NULL;
+
+ /* if we are connected:
+ - if service->pac == NULL
+ - if __connman_ipconfig_get_proxy_autoconfig(
+ service->ipconfig) == NULL
+ --> We should start WPAD */
+
+ break;
+ case CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN:
+ goto error;
+ }
+
+ if (servers_str)
+ g_string_free(servers_str, TRUE);
+
+ if (excludes_str)
+ g_string_free(excludes_str, TRUE);
+
+ service->proxy_config = method;
+
+ return 0;
+
+error:
+ if (servers_str)
+ g_string_free(servers_str, TRUE);
+
+ if (excludes_str)
+ g_string_free(excludes_str, TRUE);
+
+ return -EINVAL;
+}
+
+int __connman_service_reset_ipconfig(struct connman_service *service,
+ enum connman_ipconfig_type type, DBusMessageIter *array,
+ enum connman_service_state *new_state)
+{
+ struct connman_ipconfig *ipconfig, *new_ipconfig;
+ enum connman_ipconfig_method old_method, new_method;
+ enum connman_service_state state;
+ int err = 0, index;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ ipconfig = service->ipconfig_ipv4;
+ state = service->state_ipv4;
+ new_method = CONNMAN_IPCONFIG_METHOD_DHCP;
+ } else if (type == CONNMAN_IPCONFIG_TYPE_IPV6) {
+ ipconfig = service->ipconfig_ipv6;
+ state = service->state_ipv6;
+ new_method = CONNMAN_IPCONFIG_METHOD_AUTO;
+ } else
+ return -EINVAL;
+
+ if (!ipconfig)
+ return -ENXIO;
+
+ old_method = __connman_ipconfig_get_method(ipconfig);
+ index = __connman_ipconfig_get_index(ipconfig);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ new_ipconfig = create_ip4config(service, index,
+ CONNMAN_IPCONFIG_METHOD_UNKNOWN);
+ else
+ new_ipconfig = create_ip6config(service, index);
+
+ if (array) {
+ err = __connman_ipconfig_set_config(new_ipconfig, array);
+ if (err < 0) {
+ __connman_ipconfig_unref(new_ipconfig);
+ return err;
+ }
+
+ new_method = __connman_ipconfig_get_method(new_ipconfig);
+ }
+
+ if (is_connecting_state(service, state) ||
+ is_connected_state(service, state))
+ __connman_network_clear_ipconfig(service->network, ipconfig);
+
+ __connman_ipconfig_unref(ipconfig);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ service->ipconfig_ipv4 = new_ipconfig;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ service->ipconfig_ipv6 = new_ipconfig;
+
+ if (is_connecting_state(service, state) ||
+ is_connected_state(service, state))
+ __connman_ipconfig_enable(new_ipconfig);
+
+ if (new_state && new_method != old_method) {
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ *new_state = service->state_ipv4;
+ else
+ *new_state = service->state_ipv6;
+
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+ }
+
+ DBG("err %d ipconfig %p type %d method %d state %s", err,
+ new_ipconfig, type, new_method,
+ !new_state ? "-" : state2string(*new_state));
+
+ return err;
+}
+
+static DBusMessage *set_property(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+ DBusMessageIter iter, value;
+ const char *name;
+ int type;
+
+ DBG("service %p", service);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ if (g_str_equal(name, "AutoConnect")) {
+ dbus_bool_t autoconnect;
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
+
+ if (!service->favorite)
+ return __connman_error_invalid_service(msg);
+
+ dbus_message_iter_get_basic(&value, &autoconnect);
+
+ if (service->autoconnect == autoconnect)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ service->autoconnect = autoconnect;
+
+ autoconnect_changed(service);
+
+ if (autoconnect)
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+
+ service_save(service);
+ } else if (g_str_equal(name, "Order")) {
+ dbus_uint32_t order;
+
+ if (type != DBUS_TYPE_INT32)
+ {
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ dbus_message_iter_get_basic(&value, &order);
+
+ if (service->order == order)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ service->order = order;
+
+ __connman_connection_update_gateway();
+ service_save(service);
+ } else if (g_str_equal(name, "Nameservers.Configuration")) {
+ DBusMessageIter entry;
+ GString *str;
+ int index;
+ const char *gw;
+
+ if (__connman_provider_is_immutable(service->provider) ||
+ service->immutable)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ str = g_string_new(NULL);
+ if (!str)
+ return __connman_error_invalid_arguments(msg);
+
+ index = __connman_service_get_index(service);
+ gw = __connman_ipconfig_get_gateway_from_index(index,
+ CONNMAN_IPCONFIG_TYPE_ALL);
+
+ if (gw && strlen(gw))
+ __connman_service_nameserver_del_routes(service,
+ CONNMAN_IPCONFIG_TYPE_ALL);
+
+ dbus_message_iter_recurse(&value, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *val;
+ dbus_message_iter_get_basic(&entry, &val);
+ dbus_message_iter_next(&entry);
+ if (connman_inet_check_ipaddress(val) > 0) {
+ if (str->len > 0)
+ g_string_append_printf(str, " %s", val);
+ else
+ g_string_append(str, val);
+ }
+ }
+
+ nameserver_remove_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
+ g_strfreev(service->nameservers_config);
+
+ if (str->len > 0) {
+ service->nameservers_config =
+ g_strsplit_set(str->str, " ", 0);
+ } else {
+ service->nameservers_config = NULL;
+ }
+
+ g_string_free(str, TRUE);
+
+ if (gw && strlen(gw))
+ __connman_service_nameserver_add_routes(service, gw);
+
+ nameserver_add_all(service, CONNMAN_IPCONFIG_TYPE_ALL);
+ dns_configuration_changed(service);
+
+ if (__connman_service_is_connected_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV4))
+ __connman_wispr_start(service,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ if (__connman_service_is_connected_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6))
+ __connman_wispr_start(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ service_save(service);
+ } else if (g_str_equal(name, "Timeservers.Configuration")) {
+ DBusMessageIter entry;
+ GSList *list = NULL;
+ int count = 0;
+
+ if (service->immutable)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&value, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *val;
+ GSList *new_head;
+
+ dbus_message_iter_get_basic(&entry, &val);
+
+ new_head = __connman_timeserver_add_list(list, val);
+ if (list != new_head) {
+ count++;
+ list = new_head;
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ g_strfreev(service->timeservers_config);
+ service->timeservers_config = NULL;
+
+ if (list) {
+ service->timeservers_config = g_new0(char *, count+1);
+
+ while (list) {
+ count--;
+ service->timeservers_config[count] = list->data;
+ list = g_slist_delete_link(list, list);
+ };
+ }
+
+ service_save(service);
+ timeservers_configuration_changed(service);
+
+ if (service == __connman_service_get_default())
+ __connman_timeserver_sync(service);
+
+ } else if (g_str_equal(name, "Domains.Configuration")) {
+ DBusMessageIter entry;
+ GString *str;
+
+ if (service->immutable)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ str = g_string_new(NULL);
+ if (!str)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&value, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_STRING) {
+ const char *val;
+ dbus_message_iter_get_basic(&entry, &val);
+ dbus_message_iter_next(&entry);
+ if (str->len > 0)
+ g_string_append_printf(str, " %s", val);
+ else
+ g_string_append(str, val);
+ }
+
+ searchdomain_remove_all(service);
+ g_strfreev(service->domains);
+
+ if (str->len > 0)
+ service->domains = g_strsplit_set(str->str, " ", 0);
+ else
+ service->domains = NULL;
+
+ g_string_free(str, TRUE);
+
+ searchdomain_add_all(service);
+ domain_configuration_changed(service);
+ domain_changed(service);
+
+ service_save(service);
+ } else if (g_str_equal(name, "Proxy.Configuration")) {
+ int err;
+
+ if (service->immutable)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ err = update_proxy_configuration(service, &value);
+
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ proxy_configuration_changed(service);
+
+ __connman_notifier_proxy_changed(service);
+
+ service_save(service);
+ } else if (g_str_equal(name, "IPv4.Configuration") ||
+ g_str_equal(name, "IPv6.Configuration")) {
+
+ enum connman_service_state state =
+ CONNMAN_SERVICE_STATE_UNKNOWN;
+ enum connman_ipconfig_type type =
+ CONNMAN_IPCONFIG_TYPE_UNKNOWN;
+ int err = 0;
+
+ if (service->type == CONNMAN_SERVICE_TYPE_VPN ||
+ service->immutable)
+ return __connman_error_not_supported(msg);
+
+ DBG("%s", name);
+
+ if (!service->ipconfig_ipv4 &&
+ !service->ipconfig_ipv6)
+ return __connman_error_invalid_property(msg);
+
+ if (g_str_equal(name, "IPv4.Configuration"))
+ type = CONNMAN_IPCONFIG_TYPE_IPV4;
+ else
+ type = CONNMAN_IPCONFIG_TYPE_IPV6;
+
+ err = __connman_service_reset_ipconfig(service, type, &value,
+ &state);
+
+ if (err < 0) {
+ if (is_connected_state(service, state) ||
+ is_connecting_state(service, state)) {
+ __connman_network_enable_ipconfig(service->network,
+ service->ipconfig_ipv4);
+ __connman_network_enable_ipconfig(service->network,
+ service->ipconfig_ipv6);
+ }
+
+ return __connman_error_failed(msg, -err);
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ ipv4_configuration_changed(service);
+ else
+ ipv6_configuration_changed(service);
+
+ if (is_connecting(service) || is_connected(service)) {
+ __connman_network_enable_ipconfig(service->network,
+ service->ipconfig_ipv4);
+ __connman_network_enable_ipconfig(service->network,
+ service->ipconfig_ipv6);
+ }
+
+ service_save(service);
+ } else
+ return __connman_error_invalid_property(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static void set_error(struct connman_service *service,
+ enum connman_service_error error)
+{
+ const char *str;
+
+ if (service->error == error)
+ return;
+
+ service->error = error;
+
+ if (!service->path)
+ return;
+
+ if (!allow_property_changed(service))
+ return;
+
+ str = error2string(service->error);
+
+ if (!str)
+ str = "";
+
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Error",
+ DBUS_TYPE_STRING, &str);
+}
+
+static DBusMessage *clear_property(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+ const char *name;
+
+ DBG("service %p", service);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+
+ if (g_str_equal(name, "Error")) {
+ set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
+
+ g_get_current_time(&service->modified);
+ service_save(service);
+ __connman_service_clear_error(service);
+ } else
+ return __connman_error_invalid_property(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static bool is_ipconfig_usable(struct connman_service *service)
+{
+ if (!__connman_ipconfig_is_usable(service->ipconfig_ipv4) &&
+ !__connman_ipconfig_is_usable(service->ipconfig_ipv6))
+ return false;
+
+ return true;
+}
+
+static bool is_ignore(struct connman_service *service)
+{
+ if (!service->autoconnect)
+ return true;
+
+ if (service->roaming)
+ return true;
+
+ if (service->ignore)
+ return true;
+
+ if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
+ return true;
+
+ if (!is_ipconfig_usable(service))
+ return true;
+
+ return false;
+}
+
+static void disconnect_on_last_session(enum connman_service_type type)
+{
+ GList *list;
+
+ for (list = service_list; list; list = list->next) {
+ struct connman_service *service = list->data;
+
+ if (service->type != type)
+ continue;
+
+ if (service->connect_reason != CONNMAN_SERVICE_CONNECT_REASON_SESSION)
+ continue;
+
+ __connman_service_disconnect(service);
+ return;
+ }
+}
+
+static int active_sessions[MAX_CONNMAN_SERVICE_TYPES] = {};
+static int active_count = 0;
+
+void __connman_service_set_active_session(bool enable, GSList *list)
+{
+ if (!list)
+ return;
+
+ if (enable)
+ active_count++;
+ else
+ active_count--;
+
+ while (list != NULL) {
+ enum connman_service_type type = GPOINTER_TO_INT(list->data);
+
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ if (enable)
+ active_sessions[type]++;
+ else
+ active_sessions[type]--;
+ break;
+
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ }
+
+ if (active_sessions[type] == 0)
+ disconnect_on_last_session(type);
+
+ list = g_slist_next(list);
+ }
+
+ DBG("eth %d wifi %d bt %d cellular %d gadget %d sessions %d",
+ active_sessions[CONNMAN_SERVICE_TYPE_ETHERNET],
+ active_sessions[CONNMAN_SERVICE_TYPE_WIFI],
+ active_sessions[CONNMAN_SERVICE_TYPE_BLUETOOTH],
+ active_sessions[CONNMAN_SERVICE_TYPE_CELLULAR],
+ active_sessions[CONNMAN_SERVICE_TYPE_GADGET],
+ active_count);
+}
+
+struct preferred_tech_data {
+ GList *preferred_list;
+ enum connman_service_type type;
+};
+
+static void preferred_tech_add_by_type(gpointer data, gpointer user_data)
+{
+ struct connman_service *service = data;
+ struct preferred_tech_data *tech_data = user_data;
+
+ if (service->type == tech_data->type) {
+ tech_data->preferred_list =
+ g_list_append(tech_data->preferred_list, service);
+
+ DBG("type %d service %p %s", tech_data->type, service,
+ service->name);
+ }
+}
+
+static GList *preferred_tech_list_get(void)
+{
+ unsigned int *tech_array;
+ struct preferred_tech_data tech_data = { 0, };
+ int i;
+
+ tech_array = connman_setting_get_uint_list("PreferredTechnologies");
+ if (!tech_array)
+ return NULL;
+
+ if (connman_setting_get_bool("SingleConnectedTechnology")) {
+ GList *list;
+ for (list = service_list; list; list = list->next) {
+ struct connman_service *service = list->data;
+
+ if (!is_connected(service))
+ break;
+
+ if (service->connect_reason ==
+ CONNMAN_SERVICE_CONNECT_REASON_USER) {
+ DBG("service %p name %s is user connected",
+ service, service->name);
+ return NULL;
+ }
+ }
+ }
+
+ for (i = 0; tech_array[i] != 0; i += 1) {
+ tech_data.type = tech_array[i];
+ g_list_foreach(service_list, preferred_tech_add_by_type,
+ &tech_data);
+ }
+
+ return tech_data.preferred_list;
+}
+
+static bool auto_connect_service(GList *services,
+ enum connman_service_connect_reason reason,
+ bool preferred)
+{
+ struct connman_service *service = NULL;
+ bool ignore[MAX_CONNMAN_SERVICE_TYPES] = { };
+ bool autoconnecting = false;
+ GList *list;
+
+ DBG("preferred %d sessions %d reason %s", preferred, active_count,
+ reason2string(reason));
+
+ ignore[CONNMAN_SERVICE_TYPE_VPN] = true;
+
+ for (list = services; list; list = list->next) {
+ service = list->data;
+
+ if (ignore[service->type]) {
+ DBG("service %p type %s ignore", service,
+ __connman_service_type2string(service->type));
+ continue;
+ }
+
+ if (service->pending ||
+ is_connecting(service) ||
+ is_connected(service)) {
+ if (!active_count)
+ return true;
+
+ ignore[service->type] = true;
+ autoconnecting = true;
+
+ DBG("service %p type %s busy", service,
+ __connman_service_type2string(service->type));
+
+ continue;
+ }
+
+ if (!service->favorite) {
+ if (preferred)
+ continue;
+
+ return autoconnecting;
+ }
+
+ if (is_ignore(service) || service->state !=
+ CONNMAN_SERVICE_STATE_IDLE)
+ continue;
+
+ if (autoconnecting && !active_sessions[service->type]) {
+ DBG("service %p type %s has no users", service,
+ __connman_service_type2string(service->type));
+ continue;
+ }
+
+ DBG("service %p %s %s", service, service->name,
+ (preferred) ? "preferred" : reason2string(reason));
+
+ __connman_service_connect(service, reason);
+
+ if (!active_count)
+ return true;
+
+ ignore[service->type] = true;
+ }
+
+ return autoconnecting;
+}
+
+static gboolean run_auto_connect(gpointer data)
+{
+ enum connman_service_connect_reason reason = GPOINTER_TO_UINT(data);
+ bool autoconnecting = false;
+ GList *preferred_tech;
+
+ autoconnect_timeout = 0;
+
+ DBG("");
+
+ preferred_tech = preferred_tech_list_get();
+ if (preferred_tech) {
+ autoconnecting = auto_connect_service(preferred_tech, reason,
+ true);
+ g_list_free(preferred_tech);
+ }
+
+ if (!autoconnecting || active_count)
+ auto_connect_service(service_list, reason, false);
+
+ return FALSE;
+}
+
+void __connman_service_auto_connect(enum connman_service_connect_reason reason)
+{
+ DBG("");
+
+ if (autoconnect_timeout != 0)
+ return;
+
+ if (!__connman_session_policy_autoconnect(reason))
+ return;
+
+ autoconnect_timeout = g_timeout_add_seconds(0, run_auto_connect,
+ GUINT_TO_POINTER(reason));
+}
+
+static gboolean run_vpn_auto_connect(gpointer data) {
+ GList *list;
+ bool need_split = false;
+
+ vpn_autoconnect_timeout = 0;
+
+ for (list = service_list; list; list = list->next) {
+ struct connman_service *service = list->data;
+ int res;
+
+ if (service->type != CONNMAN_SERVICE_TYPE_VPN)
+ continue;
+
+ if (is_connected(service) || is_connecting(service)) {
+ if (!service->do_split_routing)
+ need_split = true;
+ continue;
+ }
+
+ if (is_ignore(service) || !service->favorite)
+ continue;
+
+ if (need_split && !service->do_split_routing) {
+ DBG("service %p no split routing", service);
+ continue;
+ }
+
+ DBG("service %p %s %s", service, service->name,
+ service->do_split_routing ?
+ "split routing" : "");
+
+ res = __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+ if (res < 0 && res != -EINPROGRESS)
+ continue;
+
+ if (!service->do_split_routing)
+ need_split = true;
+ }
+
+ return FALSE;
+}
+
+static void vpn_auto_connect(void)
+{
+ if (vpn_autoconnect_timeout)
+ return;
+
+ vpn_autoconnect_timeout =
+ g_timeout_add_seconds(0, run_vpn_auto_connect, NULL);
+}
+
+static void remove_timeout(struct connman_service *service)
+{
+ if (service->timeout > 0) {
+ g_source_remove(service->timeout);
+ service->timeout = 0;
+ }
+}
+
+static void reply_pending(struct connman_service *service, int error)
+{
+ remove_timeout(service);
+
+ if (service->pending) {
+ connman_dbus_reply_pending(service->pending, error, NULL);
+ service->pending = NULL;
+ }
+
+ if (service->provider_pending) {
+ connman_dbus_reply_pending(service->provider_pending,
+ error, service->path);
+ service->provider_pending = NULL;
+ }
+}
+
+bool
+__connman_service_is_provider_pending(struct connman_service *service)
+{
+ if (!service)
+ return false;
+
+ if (service->provider_pending)
+ return true;
+
+ return false;
+}
+
+void __connman_service_set_provider_pending(struct connman_service *service,
+ DBusMessage *msg)
+{
+ if (service->provider_pending) {
+ DBG("service %p provider pending msg %p already exists",
+ service, service->provider_pending);
+ return;
+ }
+
+ service->provider_pending = msg;
+ return;
+}
+
+static void check_pending_msg(struct connman_service *service)
+{
+ if (!service->pending)
+ return;
+
+ DBG("service %p pending msg %p already exists", service,
+ service->pending);
+ dbus_message_unref(service->pending);
+}
+
+void __connman_service_set_hidden_data(struct connman_service *service,
+ gpointer user_data)
+{
+ DBusMessage *pending = user_data;
+
+ DBG("service %p pending %p", service, pending);
+
+ if (!pending)
+ return;
+
+ check_pending_msg(service);
+
+ service->pending = pending;
+}
+
+void __connman_service_return_error(struct connman_service *service,
+ int error, gpointer user_data)
+{
+ DBG("service %p error %d user_data %p", service, error, user_data);
+
+ __connman_service_set_hidden_data(service, user_data);
+
+ reply_pending(service, error);
+}
+
+static gboolean connect_timeout(gpointer user_data)
+{
+ struct connman_service *service = user_data;
+ bool autoconnect = false;
+
+ DBG("service %p", service);
+
+ service->timeout = 0;
+
+ if (service->network)
+ __connman_network_disconnect(service->network, FALSE);
+ else if (service->provider)
+ connman_provider_disconnect(service->provider);
+
+ __connman_ipconfig_disable(service->ipconfig_ipv4);
+ __connman_ipconfig_disable(service->ipconfig_ipv6);
+
+ __connman_stats_service_unregister(service);
+
+ if (service->pending) {
+ DBusMessage *reply;
+
+ reply = __connman_error_operation_timeout(service->pending);
+ if (reply)
+ g_dbus_send_message(connection, reply);
+
+ dbus_message_unref(service->pending);
+ service->pending = NULL;
+ } else
+ autoconnect = true;
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_FAILURE,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_FAILURE,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ if (autoconnect &&
+ service->connect_reason !=
+ CONNMAN_SERVICE_CONNECT_REASON_USER)
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+
+ return FALSE;
+}
+
+static DBusMessage *connect_service(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+ int index, err = 0;
+ GList *list;
+
+ DBG("service %p", service);
+
+ if (service->pending)
+ return __connman_error_in_progress(msg);
+
+ index = __connman_service_get_index(service);
+
+ for (list = service_list; list; list = list->next) {
+ struct connman_service *temp = list->data;
+
+ if (!is_connecting(temp) && !is_connected(temp))
+ break;
+
+ if (service == temp)
+ continue;
+
+ if (service->type != temp->type)
+ continue;
+
+ if (__connman_service_get_index(temp) == index &&
+ __connman_service_disconnect(temp) == -EINPROGRESS)
+ err = -EINPROGRESS;
+
+ }
+ if (err == -EINPROGRESS)
+ return __connman_error_operation_timeout(msg);
+
+ service->ignore = false;
+
+ service->pending = dbus_message_ref(msg);
+
+ err = __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_USER);
+
+ if (err == -EINPROGRESS)
+ return NULL;
+
+ if (service->pending) {
+ dbus_message_unref(service->pending);
+ service->pending = NULL;
+ }
+
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *disconnect_service(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+ int err;
+
+ DBG("service %p", service);
+
+ service->ignore = true;
+
+ err = __connman_service_disconnect(service);
+ if (err < 0 && err != -EINPROGRESS)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+bool __connman_service_remove(struct connman_service *service)
+{
+ if (service->type == CONNMAN_SERVICE_TYPE_ETHERNET ||
+ service->type == CONNMAN_SERVICE_TYPE_GADGET)
+ return false;
+
+ if (service->immutable || service->hidden ||
+ __connman_provider_is_immutable(service->provider))
+ return false;
+
+ if (!service->favorite && service->state !=
+ CONNMAN_SERVICE_STATE_FAILURE)
+ return false;
+
+ __connman_service_disconnect(service);
+
+ g_free(service->passphrase);
+ service->passphrase = NULL;
+
+ g_free(service->identity);
+ service->identity = NULL;
+
+ g_free(service->agent_identity);
+ service->agent_identity = NULL;
+
+ g_free(service->eap);
+ service->eap = NULL;
+
+ service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
+
+ __connman_service_set_favorite(service, false);
+
+ /*
+ * if favorite state changed successful, autoconnect property
+ * is also updated. Need to keep network management in sync.
+ */
+ if (!service->favorite) {
+ connman_info("autoconnect_changed %d", service->autoconnect);
+ autoconnect_changed(service);
+ }
+
+ __connman_ipconfig_ipv6_reset_privacy(service->ipconfig_ipv6);
+
+ service_save(service);
+
+ return true;
+}
+
+static DBusMessage *remove_service(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ DBG("service %p", service);
+
+ if (!__connman_service_remove(service))
+ return __connman_error_not_supported(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static bool check_suitable_state(enum connman_service_state a,
+ enum connman_service_state b)
+{
+ /*
+ * Special check so that "ready" service can be moved before
+ * "online" one.
+ */
+ if ((a == CONNMAN_SERVICE_STATE_ONLINE &&
+ b == CONNMAN_SERVICE_STATE_READY) ||
+ (b == CONNMAN_SERVICE_STATE_ONLINE &&
+ a == CONNMAN_SERVICE_STATE_READY))
+ return true;
+
+ return a == b;
+}
+
+static void downgrade_state(struct connman_service *service)
+{
+ if (!service)
+ return;
+
+ DBG("service %p state4 %d state6 %d", service, service->state_ipv4,
+ service->state_ipv6);
+
+ if (service->state_ipv4 == CONNMAN_SERVICE_STATE_ONLINE)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_READY,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ if (service->state_ipv6 == CONNMAN_SERVICE_STATE_ONLINE)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_READY,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+}
+
+static void apply_relevant_default_downgrade(struct connman_service *service)
+{
+ struct connman_service *def_service;
+
+ def_service = __connman_service_get_default();
+ if (!def_service)
+ return;
+
+ if (def_service == service &&
+ def_service->state == CONNMAN_SERVICE_STATE_ONLINE) {
+ def_service->state = CONNMAN_SERVICE_STATE_READY;
+ __connman_notifier_leave_online(def_service->type);
+ state_changed(def_service);
+ }
+}
+
+static void switch_default_service(struct connman_service *default_service,
+ struct connman_service *downgrade_service)
+{
+ struct connman_service *service;
+ GList *src, *dst;
+
+ apply_relevant_default_downgrade(default_service);
+ src = g_list_find(service_list, downgrade_service);
+ dst = g_list_find(service_list, default_service);
+
+ /* Nothing to do */
+ if (src == dst || src->next == dst)
+ return;
+
+ service = src->data;
+ service_list = g_list_delete_link(service_list, src);
+ service_list = g_list_insert_before(service_list, dst, service);
+
+ downgrade_state(downgrade_service);
+}
+
+static DBusMessage *move_service(DBusConnection *conn,
+ DBusMessage *msg, void *user_data,
+ bool before)
+{
+ struct connman_service *service = user_data;
+ struct connman_service *target;
+ const char *path;
+ enum connman_ipconfig_method target4, target6;
+ enum connman_ipconfig_method service4, service6;
+
+ DBG("service %p", service);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ if (!service->favorite)
+ return __connman_error_not_supported(msg);
+
+ target = find_service(path);
+ if (!target || !target->favorite || target == service)
+ return __connman_error_invalid_service(msg);
+
+ if (target->type == CONNMAN_SERVICE_TYPE_VPN) {
+ /*
+ * We only allow VPN route splitting if there are
+ * routes defined for a given VPN.
+ */
+ if (!__connman_provider_check_routes(target->provider)) {
+ connman_info("Cannot move service. "
+ "No routes defined for provider %s",
+ __connman_provider_get_ident(target->provider));
+ return __connman_error_invalid_service(msg);
+ }
+
+ target->do_split_routing = true;
+ } else
+ target->do_split_routing = false;
+
+ service->do_split_routing = false;
+
+ target4 = __connman_ipconfig_get_method(target->ipconfig_ipv4);
+ target6 = __connman_ipconfig_get_method(target->ipconfig_ipv6);
+ service4 = __connman_ipconfig_get_method(service->ipconfig_ipv4);
+ service6 = __connman_ipconfig_get_method(service->ipconfig_ipv6);
+
+ DBG("target %s method %d/%d state %d/%d split %d", target->identifier,
+ target4, target6, target->state_ipv4, target->state_ipv6,
+ target->do_split_routing);
+
+ DBG("service %s method %d/%d state %d/%d", service->identifier,
+ service4, service6,
+ service->state_ipv4, service->state_ipv6);
+
+ /*
+ * If method is OFF, then we do not need to check the corresponding
+ * ipconfig state.
+ */
+ if (target4 == CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (service6 != CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (!check_suitable_state(target->state_ipv6,
+ service->state_ipv6))
+ return __connman_error_invalid_service(msg);
+ }
+ }
+
+ if (target6 == CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (service4 != CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (!check_suitable_state(target->state_ipv4,
+ service->state_ipv4))
+ return __connman_error_invalid_service(msg);
+ }
+ }
+
+ if (service4 == CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (target6 != CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (!check_suitable_state(target->state_ipv6,
+ service->state_ipv6))
+ return __connman_error_invalid_service(msg);
+ }
+ }
+
+ if (service6 == CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (target4 != CONNMAN_IPCONFIG_METHOD_OFF) {
+ if (!check_suitable_state(target->state_ipv4,
+ service->state_ipv4))
+ return __connman_error_invalid_service(msg);
+ }
+ }
+
+ g_get_current_time(&service->modified);
+ service_save(service);
+ service_save(target);
+
+ /*
+ * If the service which goes down is the default service and is
+ * online, we downgrade directly its state to ready so:
+ * the service which goes up, needs to recompute its state which
+ * is triggered via downgrading it - if relevant - to state ready.
+ */
+ if (before)
+ switch_default_service(target, service);
+ else
+ switch_default_service(service, target);
+
+ __connman_connection_update_gateway();
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *move_before(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ return move_service(conn, msg, user_data, true);
+}
+
+static DBusMessage *move_after(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ return move_service(conn, msg, user_data, false);
+}
+
+static DBusMessage *reset_counters(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_service *service = user_data;
+
+ reset_stats(service);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static struct _services_notify {
+ int id;
+ GHashTable *add;
+ GHashTable *remove;
+} *services_notify;
+
+static void service_append_added_foreach(gpointer data, gpointer user_data)
+{
+ struct connman_service *service = data;
+ DBusMessageIter *iter = user_data;
+
+ if (!service || !service->path) {
+ DBG("service %p or path is NULL", service);
+ return;
+ }
+
+ if (g_hash_table_lookup(services_notify->add, service->path)) {
+ DBG("new %s", service->path);
+
+ append_struct(service, iter);
+ g_hash_table_remove(services_notify->add, service->path);
+ } else {
+ DBG("changed %s", service->path);
+
+ append_struct_service(iter, NULL, service);
+ }
+}
+
+static void service_append_ordered(DBusMessageIter *iter, void *user_data)
+{
+ g_list_foreach(service_list, service_append_added_foreach, iter);
+}
+
+static void append_removed(gpointer key, gpointer value, gpointer user_data)
+{
+ char *objpath = key;
+ DBusMessageIter *iter = user_data;
+
+ DBG("removed %s", objpath);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, &objpath);
+}
+
+static void service_append_removed(DBusMessageIter *iter, void *user_data)
+{
+ g_hash_table_foreach(services_notify->remove, append_removed, iter);
+}
+
+static gboolean service_send_changed(gpointer data)
+{
+ DBusMessage *signal;
+
+ DBG("");
+
+ services_notify->id = 0;
+
+ signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "ServicesChanged");
+ if (!signal)
+ return FALSE;
+
+ __connman_dbus_append_objpath_dict_array(signal,
+ service_append_ordered, NULL);
+ __connman_dbus_append_objpath_array(signal,
+ service_append_removed, NULL);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+
+ g_hash_table_remove_all(services_notify->remove);
+ g_hash_table_remove_all(services_notify->add);
+
+ return FALSE;
+}
+
+static void service_schedule_changed(void)
+{
+ if (services_notify->id != 0)
+ return;
+
+ services_notify->id = g_timeout_add(100, service_send_changed, NULL);
+}
+
+static void service_schedule_added(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ g_hash_table_remove(services_notify->remove, service->path);
+ g_hash_table_replace(services_notify->add, service->path, service);
+
+ service_schedule_changed();
+}
+
+static void service_schedule_removed(struct connman_service *service)
+{
+ if (!service || !service->path) {
+ DBG("service %p or path is NULL", service);
+ return;
+ }
+
+ DBG("service %p %s", service, service->path);
+
+ g_hash_table_remove(services_notify->add, service->path);
+ g_hash_table_replace(services_notify->remove, g_strdup(service->path),
+ NULL);
+
+ service_schedule_changed();
+}
+
+static bool allow_property_changed(struct connman_service *service)
+{
+ if (g_hash_table_lookup_extended(services_notify->add, service->path,
+ NULL, NULL)) {
+ DBG("no property updates for service %p", service);
+ return false;
+ }
+
+ return true;
+}
+
+static const GDBusMethodTable service_methods[] = {
+ { GDBUS_DEPRECATED_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ get_properties) },
+ { GDBUS_METHOD("SetProperty",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+ NULL, set_property) },
+ { GDBUS_METHOD("ClearProperty",
+ GDBUS_ARGS({ "name", "s" }), NULL,
+ clear_property) },
+ { GDBUS_ASYNC_METHOD("Connect", NULL, NULL,
+ connect_service) },
+ { GDBUS_METHOD("Disconnect", NULL, NULL,
+ disconnect_service) },
+ { GDBUS_METHOD("Remove", NULL, NULL, remove_service) },
+ { GDBUS_METHOD("MoveBefore",
+ GDBUS_ARGS({ "service", "o" }), NULL,
+ move_before) },
+ { GDBUS_METHOD("MoveAfter",
+ GDBUS_ARGS({ "service", "o" }), NULL,
+ move_after) },
+ { GDBUS_METHOD("ResetCounters", NULL, NULL, reset_counters) },
+ { },
+};
+
+static const GDBusSignalTable service_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { },
+};
+
+static void service_free(gpointer user_data)
+{
+ struct connman_service *service = user_data;
+ char *path = service->path;
+
+ DBG("service %p", service);
+
+ reply_pending(service, ENOENT);
+
+ if (service->nameservers_timeout) {
+ g_source_remove(service->nameservers_timeout);
+ dns_changed(service);
+ }
+ __connman_notifier_service_remove(service);
+ service_schedule_removed(service);
+
+ __connman_wispr_stop(service);
+ stats_stop(service);
+
+ service->path = NULL;
+
+ if (path) {
+ __connman_connection_update_gateway();
+
+ g_dbus_unregister_interface(connection, path,
+ CONNMAN_SERVICE_INTERFACE);
+ g_free(path);
+ }
+
+ g_hash_table_destroy(service->counter_table);
+
+ if (service->network) {
+ __connman_network_disconnect(service->network, FALSE);
+ connman_network_unref(service->network);
+ service->network = NULL;
+ }
+
+ if (service->provider)
+ connman_provider_unref(service->provider);
+
+ if (service->ipconfig_ipv4) {
+ __connman_ipconfig_set_ops(service->ipconfig_ipv4, NULL);
+ __connman_ipconfig_set_data(service->ipconfig_ipv4, NULL);
+ __connman_ipconfig_unref(service->ipconfig_ipv4);
+ service->ipconfig_ipv4 = NULL;
+ }
+
+ if (service->ipconfig_ipv6) {
+ __connman_ipconfig_set_ops(service->ipconfig_ipv6, NULL);
+ __connman_ipconfig_set_data(service->ipconfig_ipv6, NULL);
+ __connman_ipconfig_unref(service->ipconfig_ipv6);
+ service->ipconfig_ipv6 = NULL;
+ }
+
+ g_strfreev(service->timeservers);
+ g_strfreev(service->timeservers_config);
+ g_strfreev(service->nameservers);
+ g_strfreev(service->nameservers_config);
+ g_strfreev(service->nameservers_auto);
+ g_strfreev(service->domains);
+ g_strfreev(service->proxies);
+ g_strfreev(service->excludes);
+
+ g_free(service->hostname);
+ g_free(service->domainname);
+ g_free(service->pac);
+ g_free(service->name);
+ g_free(service->passphrase);
+ g_free(service->identifier);
+ g_free(service->eap);
+ g_free(service->identity);
+ g_free(service->agent_identity);
+ g_free(service->ca_cert_file);
+ g_free(service->client_cert_file);
+ g_free(service->private_key_file);
+ g_free(service->private_key_passphrase);
+ g_free(service->phase2);
+ g_free(service->config_file);
+ g_free(service->config_entry);
+
+ if (service->stats.timer)
+ g_timer_destroy(service->stats.timer);
+ if (service->stats_roaming.timer)
+ g_timer_destroy(service->stats_roaming.timer);
+
+ if (current_default == service)
+ current_default = NULL;
+
+ g_free(service);
+}
+
+static void stats_init(struct connman_service *service)
+{
+ /* home */
+ service->stats.valid = false;
+ service->stats.enabled = false;
+ service->stats.timer = g_timer_new();
+
+ /* roaming */
+ service->stats_roaming.valid = false;
+ service->stats_roaming.enabled = false;
+ service->stats_roaming.timer = g_timer_new();
+}
+
+static void service_initialize(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ service->refcount = 1;
+
+ service->error = CONNMAN_SERVICE_ERROR_UNKNOWN;
+
+ service->type = CONNMAN_SERVICE_TYPE_UNKNOWN;
+ service->security = CONNMAN_SERVICE_SECURITY_UNKNOWN;
+
+ service->state = CONNMAN_SERVICE_STATE_UNKNOWN;
+ service->state_ipv4 = CONNMAN_SERVICE_STATE_UNKNOWN;
+ service->state_ipv6 = CONNMAN_SERVICE_STATE_UNKNOWN;
+
+ service->favorite = false;
+ service->immutable = false;
+ service->hidden = false;
+
+ service->ignore = false;
+
+ service->connect_reason = CONNMAN_SERVICE_CONNECT_REASON_NONE;
+
+ service->order = 0;
+
+ stats_init(service);
+
+ service->provider = NULL;
+
+ service->wps = false;
+}
+
+/**
+ * connman_service_create:
+ *
+ * Allocate a new service.
+ *
+ * Returns: a newly-allocated #connman_service structure
+ */
+struct connman_service *connman_service_create(void)
+{
+ GSList *list;
+ struct connman_stats_counter *counters;
+ const char *counter;
+
+ struct connman_service *service;
+
+ service = g_try_new0(struct connman_service, 1);
+ if (!service)
+ return NULL;
+
+ DBG("service %p", service);
+
+ service->counter_table = g_hash_table_new_full(g_str_hash,
+ g_str_equal, NULL, g_free);
+
+ for (list = counter_list; list; list = list->next) {
+ counter = list->data;
+
+ counters = g_try_new0(struct connman_stats_counter, 1);
+ if (!counters) {
+ g_hash_table_destroy(service->counter_table);
+ g_free(service);
+ return NULL;
+ }
+
+ counters->append_all = true;
+
+ g_hash_table_replace(service->counter_table, (gpointer)counter,
+ counters);
+ }
+
+ service_initialize(service);
+
+ return service;
+}
+
+/**
+ * connman_service_ref:
+ * @service: service structure
+ *
+ * Increase reference counter of service
+ */
+struct connman_service *
+connman_service_ref_debug(struct connman_service *service,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", service, service->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&service->refcount, 1);
+
+ return service;
+}
+
+/**
+ * connman_service_unref:
+ * @service: service structure
+ *
+ * Decrease reference counter of service and release service if no
+ * longer needed.
+ */
+void connman_service_unref_debug(struct connman_service *service,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", service, service->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&service->refcount, 1) != 1)
+ return;
+
+ service_list = g_list_remove(service_list, service);
+
+ __connman_service_disconnect(service);
+
+ g_hash_table_remove(service_hash, service->identifier);
+}
+
+static gint service_compare(gconstpointer a, gconstpointer b)
+{
+ struct connman_service *service_a = (void *) a;
+ struct connman_service *service_b = (void *) b;
+ enum connman_service_state state_a, state_b;
+ bool a_connected, b_connected;
+ gint strength;
+
+ state_a = service_a->state;
+ state_b = service_b->state;
+ a_connected = is_connected(service_a);
+ b_connected = is_connected(service_b);
+
+ if (a_connected && b_connected) {
+ if (service_a->order > service_b->order)
+ return -1;
+
+ if (service_a->order < service_b->order)
+ return 1;
+ }
+
+ if (state_a != state_b) {
+ if (a_connected && b_connected) {
+ /* We prefer online over ready state */
+ if (state_a == CONNMAN_SERVICE_STATE_ONLINE)
+ return -1;
+
+ if (state_b == CONNMAN_SERVICE_STATE_ONLINE)
+ return 1;
+ }
+
+ if (a_connected)
+ return -1;
+ if (b_connected)
+ return 1;
+
+ if (is_connecting(service_a))
+ return -1;
+ if (is_connecting(service_b))
+ return 1;
+ }
+
+ if (service_a->favorite && !service_b->favorite)
+ return -1;
+
+ if (!service_a->favorite && service_b->favorite)
+ return 1;
+
+ if (service_a->type != service_b->type) {
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_ETHERNET)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_ETHERNET)
+ return 1;
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_WIFI)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_WIFI)
+ return 1;
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_CELLULAR)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_CELLULAR)
+ return 1;
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_BLUETOOTH)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_BLUETOOTH)
+ return 1;
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_VPN)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_VPN)
+ return 1;
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_GADGET)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_GADGET)
+ return 1;
+
+ if (service_a->type == CONNMAN_SERVICE_TYPE_LOWPAN)
+ return -1;
+ if (service_b->type == CONNMAN_SERVICE_TYPE_LOWPAN)
+ return 1;
+ }
+
+ strength = (gint) service_b->strength - (gint) service_a->strength;
+ if (strength)
+ return strength;
+
+ return g_strcmp0(service_a->name, service_b->name);
+}
+
+static void service_list_sort(void)
+{
+ if (service_list && service_list->next) {
+ service_list = g_list_sort(service_list, service_compare);
+ service_schedule_changed();
+ }
+}
+
+/**
+ * connman_service_get_type:
+ * @service: service structure
+ *
+ * Get the type of service
+ */
+enum connman_service_type connman_service_get_type(struct connman_service *service)
+{
+ if (!service)
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+
+ return service->type;
+}
+
+/**
+ * connman_service_get_interface:
+ * @service: service structure
+ *
+ * Get network interface of service
+ */
+char *connman_service_get_interface(struct connman_service *service)
+{
+ int index;
+
+ if (!service)
+ return NULL;
+
+ index = __connman_service_get_index(service);
+
+ return connman_inet_ifname(index);
+}
+
+/**
+ * connman_service_get_network:
+ * @service: service structure
+ *
+ * Get the service network
+ */
+struct connman_network *
+__connman_service_get_network(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->network;
+}
+
+struct connman_ipconfig *
+__connman_service_get_ip4config(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->ipconfig_ipv4;
+}
+
+struct connman_ipconfig *
+__connman_service_get_ip6config(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->ipconfig_ipv6;
+}
+
+struct connman_ipconfig *
+__connman_service_get_ipconfig(struct connman_service *service, int family)
+{
+ if (family == AF_INET)
+ return __connman_service_get_ip4config(service);
+ else if (family == AF_INET6)
+ return __connman_service_get_ip6config(service);
+ else
+ return NULL;
+
+}
+
+bool __connman_service_is_connected_state(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ if (!service)
+ return false;
+
+ switch (type) {
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ break;
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ return is_connected_state(service, service->state_ipv4);
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ return is_connected_state(service, service->state_ipv6);
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ return is_connected_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV4) &&
+ is_connected_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ }
+
+ return false;
+}
+enum connman_service_security __connman_service_get_security(
+ struct connman_service *service)
+{
+ if (!service)
+ return CONNMAN_SERVICE_SECURITY_UNKNOWN;
+
+ return service->security;
+}
+
+const char *__connman_service_get_phase2(struct connman_service *service)
+{
+ if (!service)
+ return NULL;
+
+ return service->phase2;
+}
+
+bool __connman_service_wps_enabled(struct connman_service *service)
+{
+ if (!service)
+ return false;
+
+ return service->wps;
+}
+
+void __connman_service_mark_dirty(void)
+{
+ services_dirty = true;
+}
+
+/**
+ * __connman_service_set_favorite_delayed:
+ * @service: service structure
+ * @favorite: favorite value
+ * @delay_ordering: do not order service sequence
+ *
+ * Change the favorite setting of service
+ */
+int __connman_service_set_favorite_delayed(struct connman_service *service,
+ bool favorite,
+ bool delay_ordering)
+{
+ if (service->hidden)
+ return -EOPNOTSUPP;
+
+ if (service->favorite == favorite)
+ return -EALREADY;
+
+ service->favorite = favorite;
+
+ if (!delay_ordering)
+ __connman_service_get_order(service);
+
+ favorite_changed(service);
+
+ if (!delay_ordering) {
+
+ service_list_sort();
+
+ __connman_connection_update_gateway();
+ }
+
+ return 0;
+}
+
+/**
+ * __connman_service_set_favorite:
+ * @service: service structure
+ * @favorite: favorite value
+ *
+ * Change the favorite setting of service
+ */
+int __connman_service_set_favorite(struct connman_service *service,
+ bool favorite)
+{
+ return __connman_service_set_favorite_delayed(service, favorite,
+ false);
+}
+
+bool connman_service_get_favorite(struct connman_service *service)
+{
+ return service->favorite;
+}
+
+bool connman_service_get_autoconnect(struct connman_service *service)
+{
+ return service->autoconnect;
+}
+
+int __connman_service_set_immutable(struct connman_service *service,
+ bool immutable)
+{
+ if (service->hidden)
+ return -EOPNOTSUPP;
+
+ if (service->immutable == immutable)
+ return 0;
+
+ service->immutable = immutable;
+
+ immutable_changed(service);
+
+ return 0;
+}
+
+int __connman_service_set_ignore(struct connman_service *service,
+ bool ignore)
+{
+ if (!service)
+ return -EINVAL;
+
+ service->ignore = ignore;
+
+ return 0;
+}
+
+void __connman_service_set_string(struct connman_service *service,
+ const char *key, const char *value)
+{
+ if (service->hidden)
+ return;
+ if (g_str_equal(key, "EAP")) {
+ g_free(service->eap);
+ service->eap = g_strdup(value);
+ } else if (g_str_equal(key, "Identity")) {
+ g_free(service->identity);
+ service->identity = g_strdup(value);
+ } else if (g_str_equal(key, "CACertFile")) {
+ g_free(service->ca_cert_file);
+ service->ca_cert_file = g_strdup(value);
+ } else if (g_str_equal(key, "ClientCertFile")) {
+ g_free(service->client_cert_file);
+ service->client_cert_file = g_strdup(value);
+ } else if (g_str_equal(key, "PrivateKeyFile")) {
+ g_free(service->private_key_file);
+ service->private_key_file = g_strdup(value);
+ } else if (g_str_equal(key, "PrivateKeyPassphrase")) {
+ g_free(service->private_key_passphrase);
+ service->private_key_passphrase = g_strdup(value);
+ } else if (g_str_equal(key, "Phase2")) {
+ g_free(service->phase2);
+ service->phase2 = g_strdup(value);
+ } else if (g_str_equal(key, "Passphrase"))
+ __connman_service_set_passphrase(service, value);
+}
+
+void __connman_service_set_search_domains(struct connman_service *service,
+ char **domains)
+{
+ searchdomain_remove_all(service);
+
+ if (service->domains)
+ g_strfreev(service->domains);
+
+ service->domains = g_strdupv(domains);
+
+ searchdomain_add_all(service);
+}
+
+static void service_complete(struct connman_service *service)
+{
+ reply_pending(service, EIO);
+
+ if (service->connect_reason != CONNMAN_SERVICE_CONNECT_REASON_USER)
+ __connman_service_auto_connect(service->connect_reason);
+
+ g_get_current_time(&service->modified);
+ service_save(service);
+}
+
+static void report_error_cb(void *user_context, bool retry,
+ void *user_data)
+{
+ struct connman_service *service = user_context;
+
+ if (retry)
+ __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_USER);
+ else {
+ /* It is not relevant to stay on Failure state
+ * when failing is due to wrong user input */
+ __connman_service_clear_error(service);
+
+ service_complete(service);
+ __connman_connection_update_gateway();
+ }
+}
+
+static int check_wpspin(struct connman_service *service, const char *wpspin)
+{
+ int length;
+ guint i;
+
+ if (!wpspin)
+ return 0;
+
+ length = strlen(wpspin);
+
+ /* If 0, it will mean user wants to use PBC method */
+ if (length == 0) {
+ connman_network_set_string(service->network,
+ "WiFi.PinWPS", NULL);
+ return 0;
+ }
+
+ /* A WPS PIN is always 8 chars length,
+ * its content is in digit representation.
+ */
+ if (length != 8)
+ return -ENOKEY;
+
+ for (i = 0; i < 8; i++)
+ if (!isdigit((unsigned char) wpspin[i]))
+ return -ENOKEY;
+
+ connman_network_set_string(service->network, "WiFi.PinWPS", wpspin);
+
+ return 0;
+}
+
+static void request_input_cb(struct connman_service *service,
+ bool values_received,
+ const char *name, int name_len,
+ const char *identity, const char *passphrase,
+ bool wps, const char *wpspin,
+ const char *error, void *user_data)
+{
+ struct connman_device *device;
+ const char *security;
+ int err = 0;
+
+ DBG("RequestInput return, %p", service);
+
+ if (error) {
+ DBG("error: %s", error);
+
+ if (g_strcmp0(error,
+ "net.connman.Agent.Error.Canceled") == 0) {
+ err = -EINVAL;
+
+ if (service->hidden)
+ __connman_service_return_error(service,
+ ECANCELED, user_data);
+ goto done;
+ } else {
+ if (service->hidden)
+ __connman_service_return_error(service,
+ ETIMEDOUT, user_data);
+ }
+ }
+
+ if (service->hidden && name_len > 0 && name_len <= 32) {
+ device = connman_network_get_device(service->network);
+ security = connman_network_get_string(service->network,
+ "WiFi.Security");
+ err = __connman_device_request_hidden_scan(device,
+ name, name_len,
+ identity, passphrase,
+ security, user_data);
+ if (err < 0)
+ __connman_service_return_error(service, -err,
+ user_data);
+ }
+
+ if (!values_received || service->hidden) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ if (wps && service->network) {
+ err = check_wpspin(service, wpspin);
+ if (err < 0)
+ goto done;
+
+ connman_network_set_bool(service->network, "WiFi.UseWPS", wps);
+ }
+
+ if (identity)
+ __connman_service_set_agent_identity(service, identity);
+
+ if (passphrase)
+ err = __connman_service_set_passphrase(service, passphrase);
+
+ done:
+ if (err >= 0) {
+ /* We forget any previous error. */
+ set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
+
+ /* If this input request was initiated asynchronously,
+ * then we will be in the associating state. We need to
+ * make sure we are in the idle state before we try calling
+ * connect, otherwise connect() will fail with -EALREADY.
+ *
+ * If this input request was NOT initiated asynchronously,
+ * (Which is the case for most technology types at this point)
+ * we will already be in the idle state---making this
+ * a NO-OP.
+ */
+ service->state = CONNMAN_SERVICE_STATE_IDLE;
+
+ __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_USER);
+
+ } else if (err == -ENOKEY) {
+ __connman_service_indicate_error(service,
+ CONNMAN_SERVICE_ERROR_INVALID_KEY);
+ } else {
+ /* It is not relevant to stay on Failure state
+ * when failing is due to wrong user input */
+ service->state = CONNMAN_SERVICE_STATE_IDLE;
+
+ if (!service->hidden) {
+ /*
+ * If there was a real error when requesting
+ * hidden scan, then that error is returned already
+ * to the user somewhere above so do not try to
+ * do this again.
+ */
+ __connman_service_return_error(service, -err,
+ user_data);
+ }
+
+ service_complete(service);
+ __connman_connection_update_gateway();
+ }
+}
+
+static void downgrade_connected_services(void)
+{
+ struct connman_service *up_service;
+ GList *list;
+
+ for (list = service_list; list; list = list->next) {
+ up_service = list->data;
+
+ if (!is_connected(up_service))
+ continue;
+
+ if (up_service->state == CONNMAN_SERVICE_STATE_ONLINE)
+ return;
+
+ downgrade_state(up_service);
+ }
+}
+
+static int service_update_preferred_order(struct connman_service *default_service,
+ struct connman_service *new_service,
+ enum connman_service_state new_state)
+{
+ unsigned int *tech_array;
+ int i;
+
+ if (!default_service || default_service == new_service ||
+ default_service->state != new_state)
+ return 0;
+
+ tech_array = connman_setting_get_uint_list("PreferredTechnologies");
+ if (tech_array) {
+
+ for (i = 0; tech_array[i] != 0; i += 1) {
+ if (default_service->type == tech_array[i])
+ return -EALREADY;
+
+ if (new_service->type == tech_array[i]) {
+ switch_default_service(default_service,
+ new_service);
+ __connman_connection_update_gateway();
+ return 0;
+ }
+ }
+ }
+
+ return -EALREADY;
+}
+
+static void single_connected_tech(struct connman_service *allowed)
+{
+ struct connman_service *service;
+ GSList *services = NULL, *list;
+ GList *iter;
+
+ DBG("keeping %p %s", allowed, allowed->path);
+
+ for (iter = service_list; iter; iter = iter->next) {
+ service = iter->data;
+
+ if (!is_connected(service))
+ break;
+
+ if (service == allowed)
+ continue;
+
+ services = g_slist_prepend(services, service);
+ }
+
+ for (list = services; list; list = list->next) {
+ service = list->data;
+
+ DBG("disconnecting %p %s", service, service->path);
+ __connman_service_disconnect(service);
+ }
+
+ g_slist_free(services);
+}
+
+static const char *get_dbus_sender(struct connman_service *service)
+{
+ if (!service->pending)
+ return NULL;
+
+ return dbus_message_get_sender(service->pending);
+}
+
+static int service_indicate_state(struct connman_service *service)
+{
+ enum connman_service_state old_state, new_state;
+ struct connman_service *def_service;
+ enum connman_ipconfig_method method;
+ int result;
+
+ if (!service)
+ return -EINVAL;
+
+ old_state = service->state;
+ new_state = combine_state(service->state_ipv4, service->state_ipv6);
+
+ DBG("service %p old %s - new %s/%s => %s",
+ service,
+ state2string(old_state),
+ state2string(service->state_ipv4),
+ state2string(service->state_ipv6),
+ state2string(new_state));
+
+ if (old_state == new_state)
+ return -EALREADY;
+
+ def_service = __connman_service_get_default();
+
+ if (new_state == CONNMAN_SERVICE_STATE_ONLINE) {
+ result = service_update_preferred_order(def_service,
+ service, new_state);
+ if (result == -EALREADY)
+ return result;
+ }
+
+ if (old_state == CONNMAN_SERVICE_STATE_ONLINE)
+ __connman_notifier_leave_online(service->type);
+
+ if (is_connected_state(service, old_state) &&
+ !is_connected_state(service, new_state))
+ searchdomain_remove_all(service);
+
+ service->state = new_state;
+ state_changed(service);
+
+ switch(new_state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+
+ break;
+
+ case CONNMAN_SERVICE_STATE_IDLE:
+ if (old_state != CONNMAN_SERVICE_STATE_DISCONNECT)
+ __connman_service_disconnect(service);
+
+ break;
+
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+
+ break;
+
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ if (!service->new_service &&
+ __connman_stats_service_register(service) == 0) {
+ /*
+ * For new services the statistics are updated after
+ * we have successfully connected.
+ */
+ __connman_stats_get(service, false,
+ &service->stats.data);
+ __connman_stats_get(service, true,
+ &service->stats_roaming.data);
+ }
+
+ break;
+
+ case CONNMAN_SERVICE_STATE_READY:
+ set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
+
+ if (service->new_service &&
+ __connman_stats_service_register(service) == 0) {
+ /*
+ * This is normally done after configuring state
+ * but for new service do this after we have connected
+ * successfully.
+ */
+ __connman_stats_get(service, false,
+ &service->stats.data);
+ __connman_stats_get(service, true,
+ &service->stats_roaming.data);
+ }
+
+ service->new_service = false;
+
+ default_changed();
+
+ def_service = __connman_service_get_default();
+
+ service_update_preferred_order(def_service, service, new_state);
+
+ __connman_service_set_favorite(service, true);
+
+ /*
+ * if favorite state changed successful, autoconnect property
+ * is also updated. Need to keep network management in sync.
+ */
+ if (service->favorite) {
+ connman_info("autoconnect_changed %d", service->autoconnect);
+ autoconnect_changed(service);
+ }
+
+ reply_pending(service, 0);
+
+ g_get_current_time(&service->modified);
+ service_save(service);
+
+ searchdomain_add_all(service);
+ domain_changed(service);
+ proxy_changed(service);
+
+ if (old_state != CONNMAN_SERVICE_STATE_ONLINE)
+ __connman_notifier_connect(service->type);
+
+ if (service->type == CONNMAN_SERVICE_TYPE_WIFI &&
+ connman_network_get_bool(service->network,
+ "WiFi.UseWPS")) {
+ const char *pass;
+
+ pass = connman_network_get_string(service->network,
+ "WiFi.Passphrase");
+
+ __connman_service_set_passphrase(service, pass);
+
+ connman_network_set_bool(service->network,
+ "WiFi.UseWPS", false);
+ }
+
+ method = __connman_ipconfig_get_method(service->ipconfig_ipv6);
+ if (method == CONNMAN_IPCONFIG_METHOD_OFF)
+ __connman_ipconfig_disable_ipv6(
+ service->ipconfig_ipv6);
+
+ if (connman_setting_get_bool("SingleConnectedTechnology"))
+ single_connected_tech(service);
+ else if (service->type != CONNMAN_SERVICE_TYPE_VPN)
+ vpn_auto_connect();
+
+ break;
+
+ case CONNMAN_SERVICE_STATE_ONLINE:
+
+ break;
+
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
+
+ reply_pending(service, ECONNABORTED);
+
+ def_service = __connman_service_get_default();
+
+ if (!__connman_notifier_is_connected() &&
+ def_service &&
+ def_service->provider)
+ connman_provider_disconnect(def_service->provider);
+
+ default_changed();
+
+ __connman_wispr_stop(service);
+
+ __connman_wpad_stop(service);
+
+ domain_changed(service);
+ proxy_changed(service);
+
+ /*
+ * Previous services which are connected and which states
+ * are set to online should reset relevantly ipconfig_state
+ * to ready so wispr/portal will be rerun on those
+ */
+ downgrade_connected_services();
+
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+ break;
+
+ case CONNMAN_SERVICE_STATE_FAILURE:
+
+ if (service->connect_reason == CONNMAN_SERVICE_CONNECT_REASON_USER &&
+ connman_agent_report_error(service, service->path,
+ error2string(service->error),
+ report_error_cb,
+ get_dbus_sender(service),
+ NULL) == -EINPROGRESS)
+ return 0;
+ service_complete(service);
+
+ break;
+ }
+
+ service_list_sort();
+
+ __connman_connection_update_gateway();
+
+ if ((old_state == CONNMAN_SERVICE_STATE_ONLINE &&
+ new_state != CONNMAN_SERVICE_STATE_READY) ||
+ (old_state == CONNMAN_SERVICE_STATE_READY &&
+ new_state != CONNMAN_SERVICE_STATE_ONLINE)) {
+ __connman_notifier_disconnect(service->type);
+ }
+
+ if (new_state == CONNMAN_SERVICE_STATE_ONLINE) {
+ __connman_notifier_enter_online(service->type);
+ default_changed();
+ }
+
+ return 0;
+}
+
+int __connman_service_indicate_error(struct connman_service *service,
+ enum connman_service_error error)
+{
+ DBG("service %p error %d", service, error);
+
+ if (!service)
+ return -EINVAL;
+
+ if (service->state == CONNMAN_SERVICE_STATE_FAILURE)
+ return -EALREADY;
+
+ set_error(service, error);
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_FAILURE,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_FAILURE,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ return 0;
+}
+
+int __connman_service_clear_error(struct connman_service *service)
+{
+ DBusMessage *pending, *provider_pending;
+
+ DBG("service %p", service);
+
+ if (!service)
+ return -EINVAL;
+
+ if (service->state != CONNMAN_SERVICE_STATE_FAILURE)
+ return -EINVAL;
+
+ pending = service->pending;
+ service->pending = NULL;
+ provider_pending = service->provider_pending;
+ service->provider_pending = NULL;
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_IDLE,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_IDLE,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ service->pending = pending;
+ service->provider_pending = provider_pending;
+
+ return 0;
+}
+
+int __connman_service_indicate_default(struct connman_service *service)
+{
+ DBG("service %p state %s", service, state2string(service->state));
+
+ if (!is_connected(service)) {
+ /*
+ * If service is not yet fully connected, then we must not
+ * change the default yet. The default gw will be changed
+ * after the service state is in ready.
+ */
+ return -EINPROGRESS;
+ }
+
+ default_changed();
+
+ return 0;
+}
+
+enum connman_service_state __connman_service_ipconfig_get_state(
+ struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ if (!service)
+ return CONNMAN_SERVICE_STATE_UNKNOWN;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ return service->state_ipv4;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ return service->state_ipv6;
+
+ return CONNMAN_SERVICE_STATE_UNKNOWN;
+}
+
+static void check_proxy_setup(struct connman_service *service)
+{
+ /*
+ * We start WPAD if we haven't got a PAC URL from DHCP and
+ * if our proxy manual configuration is either empty or set
+ * to AUTO with an empty URL.
+ */
+
+ if (service->proxy != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN)
+ goto done;
+
+ if (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN &&
+ (service->proxy_config != CONNMAN_SERVICE_PROXY_METHOD_AUTO ||
+ service->pac))
+ goto done;
+
+ if (__connman_wpad_start(service) < 0) {
+ service->proxy = CONNMAN_SERVICE_PROXY_METHOD_DIRECT;
+ __connman_notifier_proxy_changed(service);
+ goto done;
+ }
+
+ return;
+
+done:
+ __connman_wispr_start(service, CONNMAN_IPCONFIG_TYPE_IPV4);
+}
+
+/*
+ * How many networks are connected at the same time. If more than 1,
+ * then set the rp_filter setting properly (loose mode routing) so that network
+ * connectivity works ok. This is only done for IPv4 networks as IPv6
+ * does not have rp_filter knob.
+ */
+static int connected_networks_count;
+static int original_rp_filter;
+
+static void service_rp_filter(struct connman_service *service,
+ bool connected)
+{
+ enum connman_ipconfig_method method;
+
+ method = __connman_ipconfig_get_method(service->ipconfig_ipv4);
+
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ return;
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ break;
+ }
+
+ if (connected) {
+ if (connected_networks_count == 1) {
+ int filter_value;
+ filter_value = __connman_ipconfig_set_rp_filter();
+ if (filter_value < 0)
+ return;
+
+ original_rp_filter = filter_value;
+ }
+ connected_networks_count++;
+
+ } else {
+ if (connected_networks_count == 2)
+ __connman_ipconfig_unset_rp_filter(original_rp_filter);
+
+ connected_networks_count--;
+ if (connected_networks_count < 0)
+ connected_networks_count = 0;
+ }
+
+ DBG("%s %s ipconfig %p method %d count %d filter %d",
+ connected ? "connected" : "disconnected", service->identifier,
+ service->ipconfig_ipv4, method,
+ connected_networks_count, original_rp_filter);
+}
+
+static gboolean redo_wispr(gpointer user_data)
+{
+ struct connman_service *service = user_data;
+ int refcount = service->refcount - 1;
+
+ connman_service_unref(service);
+ if (refcount == 0) {
+ DBG("Service %p already removed", service);
+ return FALSE;
+ }
+
+ __connman_wispr_start(service, CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ return FALSE;
+}
+
+int __connman_service_online_check_failed(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ DBG("service %p type %d count %d", service, type,
+ service->online_check_count);
+
+ /* currently we only retry IPv6 stuff */
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4 ||
+ service->online_check_count != 1) {
+ connman_warn("Online check failed for %p %s", service,
+ service->name);
+ return 0;
+ }
+
+ service->online_check_count = 0;
+
+ /*
+ * We set the timeout to 1 sec so that we have a chance to get
+ * necessary IPv6 router advertisement messages that might have
+ * DNS data etc.
+ */
+ g_timeout_add_seconds(1, redo_wispr, connman_service_ref(service));
+
+ return EAGAIN;
+}
+
+int __connman_service_ipconfig_indicate_state(struct connman_service *service,
+ enum connman_service_state new_state,
+ enum connman_ipconfig_type type)
+{
+ struct connman_ipconfig *ipconfig = NULL;
+ enum connman_service_state old_state;
+ enum connman_ipconfig_method method;
+
+ if (!service)
+ return -EINVAL;
+
+ switch (type) {
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ return -EINVAL;
+
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ old_state = service->state_ipv4;
+ ipconfig = service->ipconfig_ipv4;
+
+ break;
+
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ old_state = service->state_ipv6;
+ ipconfig = service->ipconfig_ipv6;
+
+ break;
+ }
+
+ if (!ipconfig)
+ return -EINVAL;
+
+ method = __connman_ipconfig_get_method(ipconfig);
+
+ switch (method) {
+ case CONNMAN_IPCONFIG_METHOD_UNKNOWN:
+ case CONNMAN_IPCONFIG_METHOD_OFF:
+ if (new_state != CONNMAN_SERVICE_STATE_IDLE)
+ connman_warn("ipconfig state %d ipconfig method %d",
+ new_state, method);
+
+ new_state = CONNMAN_SERVICE_STATE_IDLE;
+ break;
+
+ case CONNMAN_IPCONFIG_METHOD_FIXED:
+ case CONNMAN_IPCONFIG_METHOD_MANUAL:
+ case CONNMAN_IPCONFIG_METHOD_DHCP:
+ case CONNMAN_IPCONFIG_METHOD_AUTO:
+ break;
+
+ }
+
+ /* Any change? */
+ if (old_state == new_state)
+ return -EALREADY;
+
+ DBG("service %p (%s) old state %d (%s) new state %d (%s) type %d (%s)",
+ service, service ? service->identifier : NULL,
+ old_state, state2string(old_state),
+ new_state, state2string(new_state),
+ type, __connman_ipconfig_type2string(type));
+
+ switch (new_state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ break;
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ __connman_ipconfig_enable(ipconfig);
+ break;
+ case CONNMAN_SERVICE_STATE_READY:
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ check_proxy_setup(service);
+ service_rp_filter(service, true);
+ } else {
+ service->online_check_count = 1;
+ __connman_wispr_start(service, type);
+ }
+ break;
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ break;
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ if (service->state == CONNMAN_SERVICE_STATE_IDLE)
+ return -EINVAL;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ service_rp_filter(service, false);
+
+ break;
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ break;
+ }
+
+ if (is_connected_state(service, old_state) &&
+ !is_connected_state(service, new_state))
+ nameserver_remove_all(service, type);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ service->state_ipv4 = new_state;
+ else
+ service->state_ipv6 = new_state;
+
+ if (!is_connected_state(service, old_state) &&
+ is_connected_state(service, new_state))
+ nameserver_add_all(service, type);
+
+ __connman_timeserver_sync(service);
+
+ return service_indicate_state(service);
+}
+
+static bool prepare_network(struct connman_service *service)
+{
+ enum connman_network_type type;
+ unsigned int ssid_len;
+
+ type = connman_network_get_type(service->network);
+
+ switch (type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ return false;
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ if (!connman_network_get_blob(service->network, "WiFi.SSID",
+ &ssid_len))
+ return false;
+
+ if (service->passphrase)
+ connman_network_set_string(service->network,
+ "WiFi.Passphrase", service->passphrase);
+ break;
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ break;
+ }
+
+ return true;
+}
+
+static void prepare_8021x(struct connman_service *service)
+{
+ if (service->eap)
+ connman_network_set_string(service->network, "WiFi.EAP",
+ service->eap);
+
+ if (service->identity)
+ connman_network_set_string(service->network, "WiFi.Identity",
+ service->identity);
+
+ if (service->ca_cert_file)
+ connman_network_set_string(service->network, "WiFi.CACertFile",
+ service->ca_cert_file);
+
+ if (service->client_cert_file)
+ connman_network_set_string(service->network,
+ "WiFi.ClientCertFile",
+ service->client_cert_file);
+
+ if (service->private_key_file)
+ connman_network_set_string(service->network,
+ "WiFi.PrivateKeyFile",
+ service->private_key_file);
+
+ if (service->private_key_passphrase)
+ connman_network_set_string(service->network,
+ "WiFi.PrivateKeyPassphrase",
+ service->private_key_passphrase);
+
+ if (service->phase2)
+ connman_network_set_string(service->network, "WiFi.Phase2",
+ service->phase2);
+}
+
+static int service_connect(struct connman_service *service)
+{
+ int err;
+
+ if (service->hidden)
+ return -EPERM;
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ return -EINVAL;
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ break;
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ switch (service->security) {
+ case CONNMAN_SERVICE_SECURITY_UNKNOWN:
+ case CONNMAN_SERVICE_SECURITY_NONE:
+ break;
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ case CONNMAN_SERVICE_SECURITY_WPA:
+ case CONNMAN_SERVICE_SECURITY_RSN:
+ if (service->error == CONNMAN_SERVICE_ERROR_INVALID_KEY)
+ return -ENOKEY;
+
+ if (!service->passphrase) {
+ if (!service->network)
+ return -EOPNOTSUPP;
+
+ if (!service->wps ||
+ !connman_network_get_bool(service->network, "WiFi.UseWPS"))
+ return -ENOKEY;
+ }
+ break;
+
+ case CONNMAN_SERVICE_SECURITY_8021X:
+ if (!service->eap)
+ return -EINVAL;
+
+ /*
+ * never request credentials if using EAP-TLS
+ * (EAP-TLS networks need to be fully provisioned)
+ */
+ if (g_str_equal(service->eap, "tls"))
+ break;
+
+ /*
+ * Return -ENOKEY if either identity or passphrase is
+ * missing. Agent provided credentials can be used as
+ * fallback if needed.
+ */
+ if (((!service->identity &&
+ !service->agent_identity) ||
+ !service->passphrase) ||
+ service->error == CONNMAN_SERVICE_ERROR_INVALID_KEY)
+ return -ENOKEY;
+
+ break;
+ }
+ break;
+ }
+
+ if (service->network) {
+ if (!prepare_network(service))
+ return -EINVAL;
+
+ switch (service->security) {
+ case CONNMAN_SERVICE_SECURITY_UNKNOWN:
+ case CONNMAN_SERVICE_SECURITY_NONE:
+ case CONNMAN_SERVICE_SECURITY_WEP:
+ case CONNMAN_SERVICE_SECURITY_PSK:
+ case CONNMAN_SERVICE_SECURITY_WPA:
+ case CONNMAN_SERVICE_SECURITY_RSN:
+ break;
+ case CONNMAN_SERVICE_SECURITY_8021X:
+ prepare_8021x(service);
+ break;
+ }
+
+ if (__connman_stats_service_register(service) == 0) {
+ __connman_stats_get(service, false,
+ &service->stats.data);
+ __connman_stats_get(service, true,
+ &service->stats_roaming.data);
+ }
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_enable(service->ipconfig_ipv4);
+ if (service->ipconfig_ipv6)
+ __connman_ipconfig_enable(service->ipconfig_ipv6);
+
+ err = __connman_network_connect(service->network);
+ } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
+ service->provider)
+ err = __connman_provider_connect(service->provider);
+ else
+ return -EOPNOTSUPP;
+
+ if (err < 0) {
+ if (err != -EINPROGRESS) {
+ __connman_ipconfig_disable(service->ipconfig_ipv4);
+ __connman_ipconfig_disable(service->ipconfig_ipv6);
+ __connman_stats_service_unregister(service);
+ }
+ }
+
+ return err;
+}
+
+int connman_service_connect(struct connman_service *service,
+ enum connman_service_connect_reason reason)
+{
+ set_error(service, CONNMAN_SERVICE_ERROR_UNKNOWN);
+ service->ignore = FALSE;
+
+ return __connman_service_connect(service, reason);
+}
+
+int connman_service_disconnect(struct connman_service *service)
+{
+ reply_pending(service, ECONNABORTED);
+ service->ignore = TRUE;
+
+ return __connman_service_disconnect(service);
+}
+
+int __connman_service_connect(struct connman_service *service,
+ enum connman_service_connect_reason reason)
+{
+ int err;
+
+ DBG("service %p state %s connect reason %s -> %s",
+ service, state2string(service->state),
+ reason2string(service->connect_reason),
+ reason2string(reason));
+
+ if (is_connected(service))
+ return -EISCONN;
+
+ if (is_connecting(service))
+ return -EALREADY;
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ DBG("service %p Bad service type \"%s\"", service, __connman_service_type2string(service->type));
+ return -EINVAL;
+
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ break;
+ }
+
+ if (!is_ipconfig_usable(service))
+ return -ENOLINK;
+
+ __connman_service_clear_error(service);
+
+ err = service_connect(service);
+
+ service->connect_reason = reason;
+
+ if (err >= 0)
+ return 0;
+
+ if (err == -EINPROGRESS) {
+ if (service->timeout == 0)
+ service->timeout = g_timeout_add_seconds(
+ CONNECT_TIMEOUT, connect_timeout, service);
+
+ return -EINPROGRESS;
+ }
+
+ if (service->network)
+ __connman_network_disconnect(service->network, FALSE);
+ else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
+ service->provider)
+ connman_provider_disconnect(service->provider);
+
+ if (service->connect_reason == CONNMAN_SERVICE_CONNECT_REASON_USER) {
+ if (err == -ENOKEY || err == -EPERM) {
+ err = __connman_service_needs_input(service);
+ } else {
+ reply_pending(service, -err);
+ }
+ }
+
+ return err;
+}
+
+int __connman_service_needs_input(struct connman_service *service)
+{
+ int err;
+ DBusMessage *pending = NULL;
+
+ DBG("service %p state %s", service, state2string(service->state));
+
+ /*
+ * We steal the reply here. The idea is that the
+ * connecting client will see the connection status
+ * after the real hidden network is connected or
+ * connection failed.
+ */
+ if (service->hidden) {
+ pending = service->pending;
+ service->pending = NULL;
+ }
+
+ err = __connman_agent_request_passphrase_input(service,
+ request_input_cb,
+ get_dbus_sender(service),
+ pending);
+
+ DBG("service %p state %s err %d", service, state2string(service->state), err);
+
+ if (service->hidden && err != -EINPROGRESS)
+ service->pending = pending;
+
+ if (err && (err != -EINPROGRESS)) {
+ reply_pending(service, -err);
+ }
+
+ return err;
+}
+
+int __connman_service_disconnect(struct connman_service *service)
+{
+ int err;
+
+ connman_info("__connman_service_disconnect(): service %p", service);
+
+ service->connect_reason = CONNMAN_SERVICE_CONNECT_REASON_NONE;
+ service->proxy = CONNMAN_SERVICE_PROXY_METHOD_UNKNOWN;
+
+ connman_agent_cancel(service);
+
+ reply_pending(service, ECONNABORTED);
+
+ if (service->network) {
+ err = __connman_network_disconnect(service->network, service->ignore);
+ } else if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
+ service->provider)
+ err = connman_provider_disconnect(service->provider);
+ else
+ return -EOPNOTSUPP;
+
+ if (err < 0 && err != -EINPROGRESS)
+ return err;
+
+ __connman_6to4_remove(service->ipconfig_ipv4);
+
+ if (service->ipconfig_ipv4)
+ __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv4,
+ NULL);
+ else
+ __connman_ipconfig_set_proxy_autoconfig(service->ipconfig_ipv6,
+ NULL);
+
+ __connman_ipconfig_address_remove(service->ipconfig_ipv4);
+ settings_changed(service, service->ipconfig_ipv4);
+
+ __connman_ipconfig_address_remove(service->ipconfig_ipv6);
+ settings_changed(service, service->ipconfig_ipv6);
+
+ __connman_ipconfig_disable(service->ipconfig_ipv4);
+ __connman_ipconfig_disable(service->ipconfig_ipv6);
+
+ __connman_stats_service_unregister(service);
+
+ return err;
+}
+
+int __connman_service_disconnect_all(void)
+{
+ struct connman_service *service;
+ GSList *services = NULL, *list;
+ GList *iter;
+
+ DBG("");
+
+ for (iter = service_list; iter; iter = iter->next) {
+ service = iter->data;
+
+ if (!is_connected(service))
+ break;
+
+ services = g_slist_prepend(services, service);
+ }
+
+ for (list = services; list; list = list->next) {
+ struct connman_service *service = list->data;
+
+ service->ignore = true;
+
+ __connman_service_disconnect(service);
+ }
+
+ g_slist_free(services);
+
+ return 0;
+}
+
+/**
+ * lookup_by_identifier:
+ * @identifier: service identifier
+ *
+ * Look up a service by identifier (reference count will not be increased)
+ */
+static struct connman_service *lookup_by_identifier(const char *identifier)
+{
+ return g_hash_table_lookup(service_hash, identifier);
+}
+
+struct provision_user_data {
+ const char *ident;
+ int ret;
+};
+
+static void provision_changed(gpointer value, gpointer user_data)
+{
+ struct connman_service *service = value;
+ struct provision_user_data *data = user_data;
+ const char *path = data->ident;
+ int ret;
+
+ ret = __connman_config_provision_service_ident(service, path,
+ service->config_file, service->config_entry);
+ if (ret > 0)
+ data->ret = ret;
+}
+
+int __connman_service_provision_changed(const char *ident)
+{
+ struct provision_user_data data = {
+ .ident = ident,
+ .ret = 0
+ };
+
+ g_list_foreach(service_list, provision_changed, (void *)&data);
+
+ /*
+ * Because the provision_changed() might have set some services
+ * as favorite, we must sort the sequence now.
+ */
+ if (services_dirty) {
+ services_dirty = false;
+
+ service_list_sort();
+
+ __connman_connection_update_gateway();
+ }
+
+ return data.ret;
+}
+
+void __connman_service_set_config(struct connman_service *service,
+ const char *file_id, const char *entry)
+{
+ if (!service)
+ return;
+
+ g_free(service->config_file);
+ service->config_file = g_strdup(file_id);
+
+ g_free(service->config_entry);
+ service->config_entry = g_strdup(entry);
+}
+
+/**
+ * __connman_service_get:
+ * @identifier: service identifier
+ *
+ * Look up a service by identifier or create a new one if not found
+ */
+static struct connman_service *service_get(const char *identifier)
+{
+ struct connman_service *service;
+
+ service = g_hash_table_lookup(service_hash, identifier);
+ if (service) {
+ connman_service_ref(service);
+ return service;
+ }
+
+ service = connman_service_create();
+ if (!service)
+ return NULL;
+
+ DBG("service %p", service);
+
+ service->identifier = g_strdup(identifier);
+
+ service_list = g_list_insert_sorted(service_list, service,
+ service_compare);
+
+ g_hash_table_insert(service_hash, service->identifier, service);
+
+ return service;
+}
+
+static int service_register(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ if (service->path)
+ return -EALREADY;
+
+ service->path = g_strdup_printf("%s/service/%s", CONNMAN_PATH,
+ service->identifier);
+
+ DBG("path %s", service->path);
+
+ if (__connman_config_provision_service(service) < 0)
+ service_load(service);
+
+ g_dbus_register_interface(connection, service->path,
+ CONNMAN_SERVICE_INTERFACE,
+ service_methods, service_signals,
+ NULL, service, NULL);
+
+ service_list_sort();
+
+ __connman_connection_update_gateway();
+
+ return 0;
+}
+
+static void service_up(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s up", ifname);
+
+ link_changed(service);
+
+ service->stats.valid = false;
+ service->stats_roaming.valid = false;
+}
+
+static void service_down(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ DBG("%s down", ifname);
+}
+
+static void service_lower_up(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s lower up", ifname);
+
+ stats_start(service);
+}
+
+static void service_lower_down(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s lower down", ifname);
+
+ if (!is_idle_state(service, service->state_ipv4))
+ __connman_ipconfig_disable(service->ipconfig_ipv4);
+
+ if (!is_idle_state(service, service->state_ipv6))
+ __connman_ipconfig_disable(service->ipconfig_ipv6);
+
+ stats_stop(service);
+ service_save(service);
+}
+
+static void service_ip_bound(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
+ enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
+
+ DBG("%s ip bound", ifname);
+
+ type = __connman_ipconfig_get_config_type(ipconfig);
+ method = __connman_ipconfig_get_method(ipconfig);
+
+ DBG("service %p ipconfig %p type %d method %d", service, ipconfig,
+ type, method);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+ method == CONNMAN_IPCONFIG_METHOD_AUTO)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_READY,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ settings_changed(service, ipconfig);
+}
+
+static void service_ip_release(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
+ enum connman_ipconfig_method method = CONNMAN_IPCONFIG_METHOD_UNKNOWN;
+ enum connman_ipconfig_type type = CONNMAN_IPCONFIG_TYPE_UNKNOWN;
+
+ DBG("%s ip release", ifname);
+
+ type = __connman_ipconfig_get_config_type(ipconfig);
+ method = __connman_ipconfig_get_method(ipconfig);
+
+ DBG("service %p ipconfig %p type %d method %d", service, ipconfig,
+ type, method);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV6 &&
+ method == CONNMAN_IPCONFIG_METHOD_OFF)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_DISCONNECT,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4 &&
+ method == CONNMAN_IPCONFIG_METHOD_OFF)
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_DISCONNECT,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ settings_changed(service, ipconfig);
+}
+
+static void service_route_changed(struct connman_ipconfig *ipconfig,
+ const char *ifname)
+{
+ struct connman_service *service = __connman_ipconfig_get_data(ipconfig);
+
+ DBG("%s route changed", ifname);
+
+ settings_changed(service, ipconfig);
+ /* update gateway ip address info through dbus message */
+ service_list_sort();
+}
+
+static const struct connman_ipconfig_ops service_ops = {
+ .up = service_up,
+ .down = service_down,
+ .lower_up = service_lower_up,
+ .lower_down = service_lower_down,
+ .ip_bound = service_ip_bound,
+ .ip_release = service_ip_release,
+ .route_set = service_route_changed,
+ .route_unset = service_route_changed,
+};
+
+static struct connman_ipconfig *create_ip4config(struct connman_service *service,
+ int index, enum connman_ipconfig_method method)
+{
+ struct connman_ipconfig *ipconfig_ipv4;
+
+ ipconfig_ipv4 = __connman_ipconfig_create(index,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+ if (!ipconfig_ipv4)
+ return NULL;
+
+ __connman_ipconfig_set_method(ipconfig_ipv4, method);
+
+ __connman_ipconfig_set_data(ipconfig_ipv4, service);
+
+ __connman_ipconfig_set_ops(ipconfig_ipv4, &service_ops);
+
+ return ipconfig_ipv4;
+}
+
+static struct connman_ipconfig *create_ip6config(struct connman_service *service,
+ int index)
+{
+ struct connman_ipconfig *ipconfig_ipv6;
+
+ ipconfig_ipv6 = __connman_ipconfig_create(index,
+ CONNMAN_IPCONFIG_TYPE_IPV6);
+ if (!ipconfig_ipv6)
+ return NULL;
+
+ __connman_ipconfig_set_data(ipconfig_ipv6, service);
+
+ __connman_ipconfig_set_ops(ipconfig_ipv6, &service_ops);
+
+ return ipconfig_ipv6;
+}
+
+void __connman_service_read_ip4config(struct connman_service *service)
+{
+ GKeyFile *keyfile;
+
+ if (!service->ipconfig_ipv4)
+ return;
+
+ keyfile = connman_storage_load_service(service->identifier);
+ if (!keyfile)
+ return;
+
+ __connman_ipconfig_load(service->ipconfig_ipv4, keyfile,
+ service->identifier, "IPv4.");
+
+ g_key_file_free(keyfile);
+}
+
+void connman_service_create_ip4config(struct connman_service *service,
+ int index)
+{
+ DBG("ipv4 %p", service->ipconfig_ipv4);
+
+ if (service->ipconfig_ipv4)
+ return;
+
+ service->ipconfig_ipv4 = create_ip4config(service, index,
+ CONNMAN_IPCONFIG_METHOD_DHCP);
+ __connman_service_read_ip4config(service);
+}
+
+void __connman_service_read_ip6config(struct connman_service *service)
+{
+ GKeyFile *keyfile;
+
+ if (!service->ipconfig_ipv6)
+ return;
+
+ keyfile = connman_storage_load_service(service->identifier);
+ if (!keyfile)
+ return;
+
+ __connman_ipconfig_load(service->ipconfig_ipv6, keyfile,
+ service->identifier, "IPv6.");
+
+ g_key_file_free(keyfile);
+}
+
+void connman_service_create_ip6config(struct connman_service *service,
+ int index)
+{
+ DBG("ipv6 %p", service->ipconfig_ipv6);
+
+ if (service->ipconfig_ipv6)
+ return;
+
+ service->ipconfig_ipv6 = create_ip6config(service, index);
+
+ __connman_service_read_ip6config(service);
+}
+
+/**
+ * connman_service_lookup_from_network:
+ * @network: network structure
+ *
+ * Look up a service by network (reference count will not be increased)
+ */
+struct connman_service *connman_service_lookup_from_network(struct connman_network *network)
+{
+ struct connman_service *service;
+ const char *ident, *group;
+ char *name;
+
+ if (!network)
+ return NULL;
+
+ ident = __connman_network_get_ident(network);
+ if (!ident) {
+ DBG("network %p is missing ident", network);
+ return NULL;
+ }
+
+ group = connman_network_get_group(network);
+ if (!group) {
+ DBG("network %p is missing group", network);
+ return NULL;
+ }
+
+ name = g_strdup_printf("%s_%s_%s",
+ __connman_network_get_type(network), ident, group);
+ service = lookup_by_identifier(name);
+
+ DBG("service_name %s",name);
+ DBG("service %p", service);
+
+ g_free(name);
+
+ return service;
+}
+
+struct connman_service *__connman_service_lookup_from_index(int index)
+{
+ struct connman_service *service;
+ GList *list;
+
+ for (list = service_list; list; list = list->next) {
+ service = list->data;
+
+ if (__connman_ipconfig_is_usable(service->ipconfig_ipv4) &&
+ __connman_ipconfig_get_index(service->ipconfig_ipv4) == index)
+ return service;
+
+ if (__connman_ipconfig_is_usable(service->ipconfig_ipv6) &&
+ __connman_ipconfig_get_index(service->ipconfig_ipv6) == index)
+ return service;
+ }
+
+ return NULL;
+}
+
+struct connman_service *__connman_service_lookup_from_ident(const char *identifier)
+{
+ return lookup_by_identifier(identifier);
+}
+
+const char *__connman_service_get_ident(struct connman_service *service)
+{
+ return service->identifier;
+}
+
+const char *__connman_service_get_path(struct connman_service *service)
+{
+ return service->path;
+}
+
+const char *__connman_service_get_name(struct connman_service *service)
+{
+ return service->name;
+}
+
+enum connman_service_state __connman_service_get_state(struct connman_service *service)
+{
+ return service->state;
+}
+
+unsigned int __connman_service_get_order(struct connman_service *service)
+{
+ unsigned int order = 0;
+
+ if (!service)
+ return 0;
+
+ if (!service->favorite)
+ return 0;
+
+ if (service->type == CONNMAN_SERVICE_TYPE_VPN &&
+ !service->do_split_routing) {
+ service->order = 10;
+ order = 10;
+ } else {
+ order = service->order;
+ if (service == service_list->data)
+ order += 1;
+
+ if (is_connected(service))
+ order += 2;
+ }
+
+ DBG("service %p name %s order %d split %d", service, service->name,
+ order, service->do_split_routing);
+
+ return order;
+}
+
+void __connman_service_update_ordering(void)
+{
+ struct connman_service *prev_default_list;
+
+ prev_default_list = __connman_service_get_default();
+
+ if (service_list && service_list->next) {
+
+ service_list = g_list_sort(service_list, service_compare);
+
+ // If default service is changed, downgrade the previous
+ // default service from Online to Ready.
+ if (prev_default_list &&
+ (prev_default_list != __connman_service_get_default()) &&
+ (prev_default_list->state == CONNMAN_SERVICE_STATE_ONLINE)) {
+ prev_default_list->state = CONNMAN_SERVICE_STATE_READY;
+ __connman_notifier_leave_online(prev_default_list->type);
+ state_changed(prev_default_list);
+ }
+
+ }
+}
+
+static enum connman_service_type convert_network_type(struct connman_network *network)
+{
+ enum connman_network_type type = connman_network_get_type(network);
+
+ switch (type) {
+ case CONNMAN_NETWORK_TYPE_UNKNOWN:
+ case CONNMAN_NETWORK_TYPE_VENDOR:
+ break;
+ case CONNMAN_NETWORK_TYPE_ETHERNET:
+ return CONNMAN_SERVICE_TYPE_ETHERNET;
+ case CONNMAN_NETWORK_TYPE_WIFI:
+ return CONNMAN_SERVICE_TYPE_WIFI;
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_PAN:
+ case CONNMAN_NETWORK_TYPE_BLUETOOTH_DUN:
+ return CONNMAN_SERVICE_TYPE_BLUETOOTH;
+ case CONNMAN_NETWORK_TYPE_CELLULAR:
+ return CONNMAN_SERVICE_TYPE_CELLULAR;
+ case CONNMAN_NETWORK_TYPE_GADGET:
+ return CONNMAN_SERVICE_TYPE_GADGET;
+ case CONNMAN_NETWORK_TYPE_LOWPAN:
+ return CONNMAN_SERVICE_TYPE_LOWPAN;
+ }
+
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+}
+
+static enum connman_service_security convert_wifi_security(const char *security)
+{
+ if (!security)
+ return CONNMAN_SERVICE_SECURITY_UNKNOWN;
+ else if (g_str_equal(security, "none"))
+ return CONNMAN_SERVICE_SECURITY_NONE;
+ else if (g_str_equal(security, "wep"))
+ return CONNMAN_SERVICE_SECURITY_WEP;
+ else if (g_str_equal(security, "psk"))
+ return CONNMAN_SERVICE_SECURITY_PSK;
+ else if (g_str_equal(security, "ieee8021x"))
+ return CONNMAN_SERVICE_SECURITY_8021X;
+ else if (g_str_equal(security, "wpa"))
+ return CONNMAN_SERVICE_SECURITY_WPA;
+ else if (g_str_equal(security, "rsn"))
+ return CONNMAN_SERVICE_SECURITY_RSN;
+ else
+ return CONNMAN_SERVICE_SECURITY_UNKNOWN;
+}
+
+static void update_from_network(struct connman_service *service,
+ struct connman_network *network)
+{
+ uint8_t strength = service->strength;
+ const char *str;
+
+ DBG("service %p network %p", service, network);
+
+ if (is_connected(service))
+ return;
+
+ if (is_connecting(service))
+ return;
+
+ str = connman_network_get_string(network, "Name");
+ if (str) {
+ g_free(service->name);
+ service->name = g_strdup(str);
+ service->hidden = false;
+ } else {
+ g_free(service->name);
+ service->name = NULL;
+ service->hidden = true;
+ }
+
+ service->strength = connman_network_get_strength(network);
+ service->roaming = connman_network_get_bool(network, "Roaming");
+
+ if (service->strength == 0) {
+ /*
+ * Filter out 0-values; it's unclear what they mean
+ * and they cause anomalous sorting of the priority list.
+ */
+ service->strength = strength;
+ }
+
+ str = connman_network_get_string(network, "WiFi.Security");
+ service->security = convert_wifi_security(str);
+
+ if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
+ service->wps = connman_network_get_bool(network, "WiFi.WPS");
+
+ if (service->strength > strength && service->network) {
+ connman_network_unref(service->network);
+ service->network = connman_network_ref(network);
+
+ strength_changed(service);
+ }
+
+ if (!service->network)
+ service->network = connman_network_ref(network);
+
+ service_list_sort();
+}
+
+/**
+ * __connman_service_create_from_network:
+ * @network: network structure
+ *
+ * Look up service by network and if not found, create one
+ */
+struct connman_service * __connman_service_create_from_network(struct connman_network *network)
+{
+ struct connman_service *service;
+ struct connman_device *device;
+ const char *ident, *group;
+ char *name;
+ unsigned int *auto_connect_types;
+ int i, index;
+
+ DBG("network %p", network);
+
+ if (!network)
+ return NULL;
+
+ ident = __connman_network_get_ident(network);
+ if (!ident)
+ return NULL;
+
+ group = connman_network_get_group(network);
+ if (!group)
+ return NULL;
+
+ name = g_strdup_printf("%s_%s_%s",
+ __connman_network_get_type(network), ident, group);
+ service = service_get(name);
+ g_free(name);
+
+ if (!service)
+ return NULL;
+
+ if (__connman_network_get_weakness(network))
+ return service;
+
+ if (service->path) {
+ update_from_network(service, network);
+ __connman_connection_update_gateway();
+ return service;
+ }
+
+ service->type = convert_network_type(network);
+
+ auto_connect_types = connman_setting_get_uint_list("DefaultAutoConnectTechnologies");
+ service->autoconnect = false;
+ for (i = 0; auto_connect_types &&
+ auto_connect_types[i] != 0; i++) {
+ if (service->type == auto_connect_types[i]) {
+ service->autoconnect = true;
+ break;
+ }
+ }
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ break;
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ service->favorite = true;
+ break;
+ }
+
+ service->state_ipv4 = service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
+ service->state = combine_state(service->state_ipv4, service->state_ipv6);
+
+ update_from_network(service, network);
+
+ index = connman_network_get_index(network);
+
+ if (!service->ipconfig_ipv4)
+ service->ipconfig_ipv4 = create_ip4config(service, index,
+ CONNMAN_IPCONFIG_METHOD_DHCP);
+
+ if (!service->ipconfig_ipv6)
+ service->ipconfig_ipv6 = create_ip6config(service, index);
+
+ service_register(service);
+
+ if (service->favorite) {
+ device = connman_network_get_device(service->network);
+ if (device && !connman_device_get_scanning(device)) {
+
+ switch (service->type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ if (service->autoconnect) {
+ __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+ break;
+ }
+
+ /* fall through */
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO);
+ break;
+ }
+ }
+ }
+
+ __connman_notifier_service_add(service, service->name);
+ service_schedule_added(service);
+
+ return service;
+}
+
+void __connman_service_update_from_network(struct connman_network *network)
+{
+ bool need_sort = false;
+ struct connman_service *service;
+ uint8_t strength;
+ bool roaming;
+ const char *name;
+ const char *passphrase;
+ bool stats_enable;
+
+ service = connman_service_lookup_from_network(network);
+ if (!service)
+ return;
+
+ if (!service->network)
+ return;
+
+ name = connman_network_get_string(service->network, "Name");
+ if (g_strcmp0(service->name, name) != 0) {
+ g_free(service->name);
+ service->name = g_strdup(name);
+
+ if (allow_property_changed(service))
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Name",
+ DBUS_TYPE_STRING, &service->name);
+ }
+
+ if (service->type == CONNMAN_SERVICE_TYPE_WIFI)
+ service->wps = connman_network_get_bool(network, "WiFi.WPS");
+
+ if (service->type == CONNMAN_SERVICE_TYPE_LOWPAN) {
+ passphrase = connman_network_get_string(service->network, "WiFi.Passphrase");
+ if (passphrase) {
+ __connman_service_set_string(service, "Passphrase", passphrase);
+ __connman_service_save(service);
+
+ // This will eventually trigger a service changed event.
+ // We need to do this so that we can be sure that
+ // the client has received the most recent passphrase
+ // on 6LoWPAN networks.
+ // This can be removed once the code to fetch the
+ // passphrase explicitly has been added.
+ if (allow_property_changed(service) == TRUE)
+ {
+ connman_dbus_property_changed_basic(service->path,
+ CONNMAN_SERVICE_INTERFACE, "Passphrase",
+ DBUS_TYPE_STRING, &service->passphrase);
+ service_schedule_changed();
+ }
+ }
+ }
+
+ strength = connman_network_get_strength(service->network);
+ if (strength == service->strength)
+ goto roaming;
+
+ service->strength = strength;
+ need_sort = true;
+
+ strength_changed(service);
+
+roaming:
+ roaming = connman_network_get_bool(service->network, "Roaming");
+ if (roaming == service->roaming)
+ goto sorting;
+
+ stats_enable = stats_enabled(service);
+ if (stats_enable)
+ stats_stop(service);
+
+ service->roaming = roaming;
+ need_sort = true;
+
+ if (stats_enable)
+ stats_start(service);
+
+ roaming_changed(service);
+
+sorting:
+ if (need_sort) {
+ service_list_sort();
+ }
+}
+
+void __connman_service_remove_from_network(struct connman_network *network)
+{
+ struct connman_service *service;
+
+ service = connman_service_lookup_from_network(network);
+
+ DBG("network %p service %p", network, service);
+
+ if (!service)
+ return;
+
+ service->ignore = true;
+
+ __connman_connection_gateway_remove(service,
+ CONNMAN_IPCONFIG_TYPE_ALL);
+
+ connman_service_unref(service);
+}
+
+/**
+ * __connman_service_create_from_provider:
+ * @provider: provider structure
+ *
+ * Look up service by provider and if not found, create one
+ */
+struct connman_service *
+__connman_service_create_from_provider(struct connman_provider *provider)
+{
+ struct connman_service *service;
+ const char *ident, *str;
+ char *name;
+ int index = connman_provider_get_index(provider);
+
+ DBG("provider %p", provider);
+
+ ident = __connman_provider_get_ident(provider);
+ if (!ident)
+ return NULL;
+
+ name = g_strdup_printf("vpn_%s", ident);
+ service = service_get(name);
+ g_free(name);
+
+ if (!service)
+ return NULL;
+
+ service->type = CONNMAN_SERVICE_TYPE_VPN;
+ service->provider = connman_provider_ref(provider);
+ service->autoconnect = false;
+ service->favorite = true;
+
+ service->state_ipv4 = service->state_ipv6 = CONNMAN_SERVICE_STATE_IDLE;
+ service->state = combine_state(service->state_ipv4, service->state_ipv6);
+
+ str = connman_provider_get_string(provider, "Name");
+ if (str) {
+ g_free(service->name);
+ service->name = g_strdup(str);
+ service->hidden = false;
+ } else {
+ g_free(service->name);
+ service->name = NULL;
+ service->hidden = true;
+ }
+
+ service->strength = 0;
+
+ if (!service->ipconfig_ipv4)
+ service->ipconfig_ipv4 = create_ip4config(service, index,
+ CONNMAN_IPCONFIG_METHOD_MANUAL);
+
+ if (!service->ipconfig_ipv6)
+ service->ipconfig_ipv6 = create_ip6config(service, index);
+
+ service_register(service);
+
+ __connman_notifier_service_add(service, service->name);
+ service_schedule_added(service);
+
+ return service;
+}
+
+static void remove_unprovisioned_services(void)
+{
+ gchar **services;
+ GKeyFile *keyfile, *configkeyfile;
+ char *file, *section;
+ int i = 0;
+
+ services = connman_storage_get_services();
+ if (!services)
+ return;
+
+ for (; services[i]; i++) {
+ file = section = NULL;
+ keyfile = configkeyfile = NULL;
+
+ keyfile = connman_storage_load_service(services[i]);
+ if (!keyfile)
+ continue;
+
+ file = g_key_file_get_string(keyfile, services[i],
+ "Config.file", NULL);
+ if (!file)
+ goto next;
+
+ section = g_key_file_get_string(keyfile, services[i],
+ "Config.ident", NULL);
+ if (!section)
+ goto next;
+
+ configkeyfile = __connman_storage_load_config(file);
+ if (!configkeyfile) {
+ /*
+ * Config file is missing, remove the provisioned
+ * service.
+ */
+ __connman_storage_remove_service(services[i]);
+ goto next;
+ }
+
+ if (!g_key_file_has_group(configkeyfile, section))
+ /*
+ * Config section is missing, remove the provisioned
+ * service.
+ */
+ __connman_storage_remove_service(services[i]);
+
+ next:
+ if (keyfile)
+ g_key_file_free(keyfile);
+
+ if (configkeyfile)
+ g_key_file_free(configkeyfile);
+
+ g_free(section);
+ g_free(file);
+ }
+
+ g_strfreev(services);
+}
+
+static int agent_probe(struct connman_agent *agent)
+{
+ DBG("agent %p", agent);
+ return 0;
+}
+
+static void agent_remove(struct connman_agent *agent)
+{
+ DBG("agent %p", agent);
+}
+
+static void *agent_context_ref(void *context)
+{
+ struct connman_service *service = context;
+
+ return (void *)connman_service_ref(service);
+}
+
+static void agent_context_unref(void *context)
+{
+ struct connman_service *service = context;
+
+ connman_service_unref(service);
+}
+
+static struct connman_agent_driver agent_driver = {
+ .name = "service",
+ .interface = CONNMAN_AGENT_INTERFACE,
+ .probe = agent_probe,
+ .remove = agent_remove,
+ .context_ref = agent_context_ref,
+ .context_unref = agent_context_unref,
+};
+
+int __connman_service_init(void)
+{
+ int err;
+
+ DBG("");
+
+ err = connman_agent_driver_register(&agent_driver);
+ if (err < 0) {
+ connman_error("Cannot register agent driver for %s",
+ agent_driver.name);
+ return err;
+ }
+
+ connection = connman_dbus_get_connection();
+
+ service_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, service_free);
+
+ services_notify = g_new0(struct _services_notify, 1);
+ services_notify->remove = g_hash_table_new_full(g_str_hash,
+ g_str_equal, g_free, NULL);
+ services_notify->add = g_hash_table_new(g_str_hash, g_str_equal);
+
+ remove_unprovisioned_services();
+
+ return 0;
+}
+
+// TODO: Remove at some point
+int connman_service_ipconfig_indicate_state(struct connman_service *service,
+ enum connman_service_state new_state,
+ enum connman_ipconfig_type type)
+{
+ return __connman_service_ipconfig_indicate_state(service,new_state,type);
+}
+
+void connman_service_force_notify(void)
+{
+ if (services_notify->id != 0) {
+ g_source_remove(services_notify->id);
+ service_send_changed(NULL);
+ }
+}
+
+void __connman_service_cleanup(void)
+{
+ DBG("");
+
+ if (vpn_autoconnect_timeout) {
+ g_source_remove(vpn_autoconnect_timeout);
+ vpn_autoconnect_timeout = 0;
+ }
+
+ if (autoconnect_timeout != 0) {
+ g_source_remove(autoconnect_timeout);
+ autoconnect_timeout = 0;
+ }
+
+ connman_agent_driver_unregister(&agent_driver);
+
+ g_list_free(service_list);
+ service_list = NULL;
+
+ g_hash_table_destroy(service_hash);
+ service_hash = NULL;
+
+ g_slist_free(counter_list);
+ counter_list = NULL;
+
+ if (services_notify->id != 0) {
+ g_source_remove(services_notify->id);
+ service_send_changed(NULL);
+ g_hash_table_destroy(services_notify->remove);
+ g_hash_table_destroy(services_notify->add);
+ }
+ g_free(services_notify);
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/session.c b/src/session.c
new file mode 100644
index 0000000..4dff930
--- /dev/null
+++ b/src/session.c
@@ -0,0 +1,1760 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2014 Intel Corporation. All rights reserved.
+ * Copyright (C) 2011-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <gdbus.h>
+
+#include <connman/session.h>
+
+#include "connman.h"
+
+static DBusConnection *connection;
+static GHashTable *session_hash;
+static GHashTable *service_hash;
+static struct connman_session *ecall_session;
+static uint32_t session_mark = 256;
+static struct firewall_context *global_firewall = NULL;
+
+enum connman_session_state {
+ CONNMAN_SESSION_STATE_DISCONNECTED = 0,
+ CONNMAN_SESSION_STATE_CONNECTED = 1,
+ CONNMAN_SESSION_STATE_ONLINE = 2,
+};
+
+struct session_info {
+ struct connman_session_config config;
+ enum connman_session_state state;
+};
+
+struct connman_session {
+ char *owner;
+ char *session_path;
+ char *notify_path;
+ guint notify_watch;
+
+ bool active;
+ bool append_all;
+ struct session_info *info;
+ struct session_info *info_last;
+ struct connman_service *service;
+ struct connman_service *service_last;
+ struct connman_session_config *policy_config;
+ GSList *user_allowed_bearers;
+
+ bool ecall;
+
+ enum connman_session_id_type id_type;
+ struct firewall_context *fw;
+ uint32_t mark;
+ int index;
+ char *gateway;
+ bool policy_routing;
+};
+
+struct connman_service_info {
+ struct connman_service *service;
+ GSList *sessions;
+};
+
+static struct connman_session_policy *policy;
+static void session_activate(struct connman_session *session);
+static void session_deactivate(struct connman_session *session);
+static void update_session_state(struct connman_session *session);
+
+static void cleanup_service(gpointer data)
+{
+ struct connman_service_info *info = data;
+
+ g_slist_free(info->sessions);
+ g_free(info);
+}
+
+static const char *state2string(enum connman_session_state state)
+{
+ switch (state) {
+ case CONNMAN_SESSION_STATE_DISCONNECTED:
+ return "disconnected";
+ case CONNMAN_SESSION_STATE_CONNECTED:
+ return "connected";
+ case CONNMAN_SESSION_STATE_ONLINE:
+ return "online";
+ }
+
+ return NULL;
+}
+
+static const char *type2string(enum connman_session_type type)
+{
+ switch (type) {
+ case CONNMAN_SESSION_TYPE_UNKNOWN:
+ return "";
+ case CONNMAN_SESSION_TYPE_ANY:
+ return "any";
+ case CONNMAN_SESSION_TYPE_LOCAL:
+ return "local";
+ case CONNMAN_SESSION_TYPE_INTERNET:
+ return "internet";
+ }
+
+ return NULL;
+}
+
+enum connman_session_roaming_policy connman_session_parse_roaming_policy(const char *policy)
+{
+ if (g_strcmp0(policy, "default") == 0)
+ return CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
+ else if (g_strcmp0(policy, "always") == 0)
+ return CONNMAN_SESSION_ROAMING_POLICY_ALWAYS;
+ else if (g_strcmp0(policy, "forbidden") == 0)
+ return CONNMAN_SESSION_ROAMING_POLICY_FORBIDDEN;
+ else if (g_strcmp0(policy, "national") == 0)
+ return CONNMAN_SESSION_ROAMING_POLICY_NATIONAL;
+ else if (g_strcmp0(policy, "international") == 0)
+ return CONNMAN_SESSION_ROAMING_POLICY_INTERNATIONAL;
+ else
+ return CONNMAN_SESSION_ROAMING_POLICY_UNKNOWN;
+}
+
+enum connman_session_type connman_session_parse_connection_type(const char *type)
+{
+ if (g_strcmp0(type, "any") == 0)
+ return CONNMAN_SESSION_TYPE_ANY;
+ if (g_strcmp0(type, "local") == 0)
+ return CONNMAN_SESSION_TYPE_LOCAL;
+ else if (g_strcmp0(type, "internet") == 0)
+ return CONNMAN_SESSION_TYPE_INTERNET;
+
+ return CONNMAN_SESSION_TYPE_UNKNOWN;
+}
+
+static int bearer2service(const char *bearer, enum connman_service_type *type)
+{
+ if (g_strcmp0(bearer, "ethernet") == 0)
+ *type = CONNMAN_SERVICE_TYPE_ETHERNET;
+ else if (g_strcmp0(bearer, "wifi") == 0)
+ *type = CONNMAN_SERVICE_TYPE_WIFI;
+ else if (g_strcmp0(bearer, "gadget") == 0)
+ *type = CONNMAN_SERVICE_TYPE_GADGET;
+ else if (g_strcmp0(bearer, "bluetooth") == 0)
+ *type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
+ else if (g_strcmp0(bearer, "cellular") == 0)
+ *type = CONNMAN_SERVICE_TYPE_CELLULAR;
+ else if (g_strcmp0(bearer, "vpn") == 0)
+ *type = CONNMAN_SERVICE_TYPE_VPN;
+ else if (g_strcmp0(bearer, "lowpan") == 0)
+ *type = CONNMAN_SERVICE_TYPE_LOWPAN;
+ else
+ return -EINVAL;
+
+ return 0;
+}
+
+static char *service2bearer(enum connman_service_type type)
+{
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ return "ethernet";
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ return "gadget";
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ return "wifi";
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ return "bluetooth";
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ return "cellular";
+ case CONNMAN_SERVICE_TYPE_VPN:
+ return "vpn";
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ return "lowpan";
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ return "";
+ }
+
+ return "";
+}
+
+static int init_firewall(void)
+{
+ struct firewall_context *fw;
+ int err;
+
+ if (global_firewall)
+ return 0;
+
+ fw = __connman_firewall_create();
+
+ err = __connman_firewall_add_rule(fw, "mangle", "INPUT",
+ "-j CONNMARK --restore-mark");
+ if (err < 0)
+ goto err;
+
+ err = __connman_firewall_add_rule(fw, "mangle", "POSTROUTING",
+ "-j CONNMARK --save-mark");
+ if (err < 0)
+ goto err;
+
+ err = __connman_firewall_enable(fw);
+ if (err < 0)
+ goto err;
+
+ global_firewall = fw;
+
+ return 0;
+
+err:
+ __connman_firewall_destroy(fw);
+
+ return err;
+}
+
+static void cleanup_firewall(void)
+{
+ if (!global_firewall)
+ return;
+
+ __connman_firewall_disable(global_firewall);
+ __connman_firewall_destroy(global_firewall);
+}
+
+static int init_firewall_session(struct connman_session *session)
+{
+ struct firewall_context *fw;
+ int err;
+
+ if (session->policy_config->id_type == CONNMAN_SESSION_ID_TYPE_UNKNOWN)
+ return 0;
+
+ DBG("");
+
+ err = init_firewall();
+ if (err < 0)
+ return err;
+
+ fw = __connman_firewall_create();
+ if (!fw)
+ return -ENOMEM;
+
+ switch (session->policy_config->id_type) {
+ case CONNMAN_SESSION_ID_TYPE_UID:
+ err = __connman_firewall_add_rule(fw, "mangle", "OUTPUT",
+ "-m owner --uid-owner %s -j MARK --set-mark %d",
+ session->policy_config->id,
+ session->mark);
+ break;
+ case CONNMAN_SESSION_ID_TYPE_GID:
+ err = __connman_firewall_add_rule(fw, "mangle", "OUTPUT",
+ "-m owner --gid-owner %s -j MARK --set-mark %d",
+ session->policy_config->id,
+ session->mark);
+ break;
+ case CONNMAN_SESSION_ID_TYPE_LSM:
+ default:
+ err = -EINVAL;
+ }
+
+ if (err < 0)
+ goto err;
+
+ session->id_type = session->policy_config->id_type;
+
+ err = __connman_firewall_enable(fw);
+ if (err)
+ goto err;
+
+ session->fw = fw;
+
+ return 0;
+
+err:
+ __connman_firewall_destroy(fw);
+
+ return err;
+}
+
+static void cleanup_firewall_session(struct connman_session *session)
+{
+ if (!session->fw)
+ return;
+
+ __connman_firewall_disable(session->fw);
+ __connman_firewall_destroy(session->fw);
+
+ session->fw = NULL;
+}
+
+static int init_routing_table(struct connman_session *session)
+{
+ int err;
+
+ if (session->policy_config->id_type == CONNMAN_SESSION_ID_TYPE_UNKNOWN)
+ return 0;
+
+ DBG("");
+
+ err = __connman_inet_add_fwmark_rule(session->mark,
+ AF_INET, session->mark);
+ if (err < 0)
+ return err;
+
+ err = __connman_inet_add_fwmark_rule(session->mark,
+ AF_INET6, session->mark);
+ if (err < 0)
+ __connman_inet_del_fwmark_rule(session->mark,
+ AF_INET, session->mark);
+ session->policy_routing = true;
+
+ return err;
+}
+
+static void del_default_route(struct connman_session *session)
+{
+ if (!session->gateway)
+ return;
+
+ DBG("index %d routing table %d default gateway %s",
+ session->index, session->mark, session->gateway);
+
+ __connman_inet_del_default_from_table(session->mark,
+ session->index, session->gateway);
+ g_free(session->gateway);
+ session->gateway = NULL;
+ session->index = -1;
+}
+
+static void add_default_route(struct connman_session *session)
+{
+ struct connman_ipconfig *ipconfig;
+ int err;
+
+ if (!session->service)
+ return;
+
+ ipconfig = __connman_service_get_ip4config(session->service);
+ session->index = __connman_ipconfig_get_index(ipconfig);
+ session->gateway = g_strdup(__connman_ipconfig_get_gateway(ipconfig));
+
+ DBG("index %d routing table %d default gateway %s",
+ session->index, session->mark, session->gateway);
+
+ err = __connman_inet_add_default_to_table(session->mark,
+ session->index, session->gateway);
+ if (err < 0)
+ DBG("session %p %s", session, strerror(-err));
+}
+
+static void cleanup_routing_table(struct connman_session *session)
+{
+ DBG("");
+
+ if (session->policy_routing) {
+ __connman_inet_del_fwmark_rule(session->mark,
+ AF_INET6, session->mark);
+
+ __connman_inet_del_fwmark_rule(session->mark,
+ AF_INET, session->mark);
+ session->policy_routing = false;
+ }
+
+ del_default_route(session);
+}
+
+static void update_routing_table(struct connman_session *session)
+{
+ del_default_route(session);
+ add_default_route(session);
+}
+
+static void destroy_policy_config(struct connman_session *session)
+{
+ if (!policy) {
+ g_free(session->policy_config);
+ return;
+ }
+
+ policy->destroy(session);
+}
+
+static void free_session(struct connman_session *session)
+{
+ if (!session)
+ return;
+
+ if (session->notify_watch > 0)
+ g_dbus_remove_watch(connection, session->notify_watch);
+
+ destroy_policy_config(session);
+ g_slist_free(session->info->config.allowed_bearers);
+ g_free(session->owner);
+ g_free(session->session_path);
+ g_free(session->notify_path);
+ g_free(session->info);
+ g_free(session->info_last);
+ g_free(session->gateway);
+
+ g_free(session);
+}
+
+static void set_active_session(struct connman_session *session, bool enable)
+{
+
+ if (policy && policy->session_changed)
+ policy->session_changed(session, enable,
+ session->info->config.allowed_bearers);
+
+ __connman_service_set_active_session(enable,
+ session->info->config.allowed_bearers);
+}
+
+static void cleanup_session(gpointer user_data)
+{
+ struct connman_session *session = user_data;
+
+ DBG("remove %s", session->session_path);
+
+ cleanup_routing_table(session);
+ cleanup_firewall_session(session);
+
+ if (session->active)
+ set_active_session(session, false);
+
+ session_deactivate(session);
+ update_session_state(session);
+
+ g_slist_free(session->user_allowed_bearers);
+
+ free_session(session);
+}
+
+struct creation_data {
+ DBusMessage *pending;
+ struct connman_session *session;
+
+ /* user config */
+ enum connman_session_type type;
+ GSList *allowed_bearers;
+};
+
+static void cleanup_creation_data(struct creation_data *creation_data)
+{
+ if (!creation_data)
+ return;
+
+ if (creation_data->pending)
+ dbus_message_unref(creation_data->pending);
+
+ g_slist_free(creation_data->allowed_bearers);
+ g_free(creation_data);
+}
+
+static int create_policy_config(struct connman_session *session,
+ connman_session_config_func_t cb,
+ struct creation_data *creation_data)
+{
+ struct connman_session_config *config;
+
+ if (!policy) {
+ config = connman_session_create_default_config();
+ if (!config) {
+ free_session(session);
+ cleanup_creation_data(creation_data);
+ return -ENOMEM;
+ }
+
+ return cb(session, config, creation_data, 0);
+ }
+
+ return policy->create(session, cb, creation_data);
+}
+
+int connman_session_policy_register(struct connman_session_policy *plugin)
+{
+ if (policy)
+ return -EINVAL;
+
+ if (!plugin->create || !plugin->destroy)
+ return -EINVAL;
+
+ DBG("name %s", plugin->name);
+
+ policy = plugin;
+
+ return 0;
+}
+
+void connman_session_policy_unregister(struct connman_session_policy *plugin)
+{
+ if (plugin != policy)
+ return;
+
+ DBG("name %s", policy->name);
+
+ policy = NULL;
+}
+
+static int default_bearers[] = {
+ CONNMAN_SERVICE_TYPE_ETHERNET,
+ CONNMAN_SERVICE_TYPE_WIFI,
+ CONNMAN_SERVICE_TYPE_BLUETOOTH,
+ CONNMAN_SERVICE_TYPE_CELLULAR,
+ CONNMAN_SERVICE_TYPE_GADGET,
+ CONNMAN_SERVICE_TYPE_LOWPAN,
+};
+
+static void add_default_bearer_types(GSList **list)
+{
+ unsigned int i;
+
+ for (i = 0; i < G_N_ELEMENTS(default_bearers); i++)
+ *list = g_slist_append(*list,
+ GINT_TO_POINTER(default_bearers[i]));
+}
+
+void connman_session_set_default_config(struct connman_session_config *config)
+{
+ config->id_type = CONNMAN_SESSION_ID_TYPE_UNKNOWN;
+ g_free(config->id);
+ config->id = NULL;
+
+ config->priority = FALSE;
+ config->roaming_policy = CONNMAN_SESSION_ROAMING_POLICY_DEFAULT;
+ config->type = CONNMAN_SESSION_TYPE_ANY;
+ config->ecall = FALSE;
+
+ g_slist_free(config->allowed_bearers);
+ add_default_bearer_types(&config->allowed_bearers);
+}
+
+struct connman_session_config *connman_session_create_default_config(void)
+{
+ struct connman_session_config *config;
+
+ config = g_new0(struct connman_session_config, 1);
+ connman_session_set_default_config(config);
+
+ return config;
+}
+
+static enum connman_session_type apply_policy_on_type(
+ enum connman_session_type policy,
+ enum connman_session_type type)
+{
+ if (type == CONNMAN_SESSION_TYPE_UNKNOWN)
+ return CONNMAN_SESSION_TYPE_UNKNOWN;
+
+ if (policy == CONNMAN_SESSION_TYPE_ANY)
+ return type;
+
+ if (policy == CONNMAN_SESSION_TYPE_LOCAL)
+ return CONNMAN_SESSION_TYPE_LOCAL;
+
+ return CONNMAN_SESSION_TYPE_INTERNET;
+}
+
+int connman_session_parse_bearers(const char *token, GSList **list)
+{
+ enum connman_service_type bearer;
+ int err;
+
+ if (g_strcmp0(token, "") == 0)
+ return 0;
+
+ if (g_strcmp0(token, "*") == 0) {
+ add_default_bearer_types(list);
+ return 0;
+ }
+
+ err = bearer2service(token, &bearer);
+ if (err < 0)
+ return err;
+
+ *list = g_slist_append(*list, GINT_TO_POINTER(bearer));
+
+ return 0;
+}
+
+static int parse_bearers(DBusMessageIter *iter, GSList **list)
+{
+ DBusMessageIter array;
+ int type, err;
+
+ dbus_message_iter_recurse(iter, &array);
+
+ *list = NULL;
+
+ while ((type = dbus_message_iter_get_arg_type(&array)) !=
+ DBUS_TYPE_INVALID) {
+ char *bearer_name = NULL;
+
+ if (type != DBUS_TYPE_STRING) {
+ g_slist_free(*list);
+ *list = NULL;
+ return -EINVAL;
+ }
+
+ dbus_message_iter_get_basic(&array, &bearer_name);
+
+ err = connman_session_parse_bearers(bearer_name, list);
+ if (err < 0) {
+ g_slist_free(*list);
+ *list = NULL;
+ return err;
+ }
+
+ dbus_message_iter_next(&array);
+ }
+
+ return 0;
+}
+
+static void filter_bearer(GSList *policy_bearers,
+ enum connman_service_type bearer,
+ GSList **list)
+{
+ enum connman_service_type policy;
+ GSList *it;
+
+ if (!policy_bearers)
+ return;
+
+ for (it = policy_bearers; it; it = it->next) {
+ policy = GPOINTER_TO_INT(it->data);
+
+ if (policy != bearer)
+ continue;
+
+ *list = g_slist_append(*list, GINT_TO_POINTER(bearer));
+ return;
+ }
+}
+
+static void apply_policy_on_bearers(GSList *policy_bearers, GSList *bearers,
+ GSList **list)
+{
+ enum connman_service_type bearer;
+ GSList *it;
+
+ *list = NULL;
+
+ for (it = bearers; it; it = it->next) {
+ bearer = GPOINTER_TO_INT(it->data);
+
+ filter_bearer(policy_bearers, bearer, list);
+ }
+}
+
+const char *connman_session_get_owner(struct connman_session *session)
+{
+ return session->owner;
+}
+
+static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
+{
+ struct session_info *info = user_data;
+ GSList *list;
+
+ for (list = info->config.allowed_bearers;
+ list; list = list->next) {
+ enum connman_service_type bearer = GPOINTER_TO_INT(list->data);
+ const char *name = __connman_service_type2string(bearer);
+
+ if (!name)
+ name = "";
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &name);
+ }
+}
+
+static void append_ipconfig_ipv4(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ struct connman_ipconfig *ipconfig_ipv4;
+
+ if (!service)
+ return;
+
+ if (!__connman_service_is_connected_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV4))
+ return;
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+ if (!ipconfig_ipv4)
+ return;
+
+ __connman_ipconfig_append_ipv4(ipconfig_ipv4, iter);
+}
+
+static void append_ipconfig_ipv6(DBusMessageIter *iter, void *user_data)
+{
+ struct connman_service *service = user_data;
+ struct connman_ipconfig *ipconfig_ipv4, *ipconfig_ipv6;
+
+ if (!service)
+ return;
+
+ if (!__connman_service_is_connected_state(service,
+ CONNMAN_IPCONFIG_TYPE_IPV6))
+ return;
+
+ ipconfig_ipv4 = __connman_service_get_ip4config(service);
+ ipconfig_ipv6 = __connman_service_get_ip6config(service);
+ if (!ipconfig_ipv6)
+ return;
+
+ __connman_ipconfig_append_ipv6(ipconfig_ipv6, iter, ipconfig_ipv4);
+}
+
+static void append_notify(DBusMessageIter *dict,
+ struct connman_session *session)
+{
+ struct session_info *info = session->info;
+ struct session_info *info_last = session->info_last;
+ struct connman_service *service;
+ enum connman_service_type type;
+ const char *name, *bearer;
+ char *ifname;
+ int idx;
+
+ if (session->append_all || info->state != info_last->state) {
+ const char *state = state2string(info->state);
+
+ connman_dbus_dict_append_basic(dict, "State",
+ DBUS_TYPE_STRING,
+ &state);
+ info_last->state = info->state;
+ }
+
+ if (session->append_all || session->service != session->service_last) {
+ if (session->service) {
+ service = session->service;
+ name = __connman_service_get_name(service);
+ idx = __connman_service_get_index(service);
+
+ ifname = connman_inet_ifname(idx);
+ if (!ifname)
+ ifname = g_strdup("");
+
+ type = connman_service_get_type(service);
+ bearer = service2bearer(type);
+ } else {
+ service = NULL;
+ name = "";
+ ifname = g_strdup("");
+ bearer = "";
+ }
+
+ connman_dbus_dict_append_basic(dict, "Name",
+ DBUS_TYPE_STRING,
+ &name);
+
+ connman_dbus_dict_append_dict(dict, "IPv4",
+ append_ipconfig_ipv4,
+ service);
+
+ connman_dbus_dict_append_dict(dict, "IPv6",
+ append_ipconfig_ipv6,
+ service);
+
+ connman_dbus_dict_append_basic(dict, "Interface",
+ DBUS_TYPE_STRING,
+ &ifname);
+
+ connman_dbus_dict_append_basic(dict, "Bearer",
+ DBUS_TYPE_STRING,
+ &bearer);
+
+ g_free(ifname);
+
+ session->service_last = session->service;
+ }
+
+ if (session->append_all ||
+ info->config.type != info_last->config.type) {
+ const char *type = type2string(info->config.type);
+
+ connman_dbus_dict_append_basic(dict, "ConnectionType",
+ DBUS_TYPE_STRING,
+ &type);
+ info_last->config.type = info->config.type;
+ }
+
+ if (session->append_all ||
+ info->config.allowed_bearers != info_last->config.allowed_bearers) {
+ connman_dbus_dict_append_array(dict, "AllowedBearers",
+ DBUS_TYPE_STRING,
+ append_allowed_bearers,
+ info);
+ info_last->config.allowed_bearers = info->config.allowed_bearers;
+ }
+
+ session->append_all = false;
+}
+
+static bool compute_notifiable_changes(struct connman_session *session)
+{
+ struct session_info *info_last = session->info_last;
+ struct session_info *info = session->info;
+
+ if (session->append_all)
+ return true;
+
+ if (info->state != info_last->state)
+ return true;
+
+ if (session->service != session->service_last &&
+ info->state >= CONNMAN_SESSION_STATE_CONNECTED)
+ return true;
+
+ if (info->config.allowed_bearers != info_last->config.allowed_bearers ||
+ info->config.type != info_last->config.type)
+ return true;
+
+ return false;
+}
+
+static gboolean session_notify(gpointer user_data)
+{
+ struct connman_session *session = user_data;
+ DBusMessage *msg;
+ DBusMessageIter array, dict;
+
+ if (!compute_notifiable_changes(session))
+ return FALSE;
+
+ DBG("session %p owner %s notify_path %s", session,
+ session->owner, session->notify_path);
+
+ msg = dbus_message_new_method_call(session->owner, session->notify_path,
+ CONNMAN_NOTIFICATION_INTERFACE,
+ "Update");
+ if (!msg)
+ return FALSE;
+
+ dbus_message_iter_init_append(msg, &array);
+ connman_dbus_dict_open(&array, &dict);
+
+ append_notify(&dict, session);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ g_dbus_send_message(connection, msg);
+
+ return FALSE;
+}
+
+static void ipconfig_ipv4_changed(struct connman_session *session)
+{
+ connman_dbus_setting_changed_dict(session->owner, session->notify_path,
+ "IPv4", append_ipconfig_ipv4,
+ session->service);
+}
+
+static void ipconfig_ipv6_changed(struct connman_session *session)
+{
+ connman_dbus_setting_changed_dict(session->owner, session->notify_path,
+ "IPv6", append_ipconfig_ipv6,
+ session->service);
+}
+
+int connman_session_config_update(struct connman_session *session)
+{
+ struct session_info *info = session->info;
+ GSList *allowed_bearers;
+ int err;
+
+ DBG("session %p", session);
+
+ /*
+ * We update all configuration even though only one entry
+ * might have changed. We can still optimize this later.
+ */
+
+ if (session->id_type != session->policy_config->id_type) {
+ cleanup_firewall_session(session);
+ err = init_firewall_session(session);
+ if (err < 0) {
+ connman_session_destroy(session);
+ return err;
+ }
+
+ session->id_type = session->policy_config->id_type;
+ }
+
+ apply_policy_on_bearers(
+ session->policy_config->allowed_bearers,
+ session->user_allowed_bearers,
+ &allowed_bearers);
+
+ if (session->active)
+ set_active_session(session, false);
+
+ session->active = false;
+ session_deactivate(session);
+
+ g_slist_free(info->config.allowed_bearers);
+ info->config.allowed_bearers = allowed_bearers;
+
+ session_activate(session);
+
+ info->config.type = apply_policy_on_type(
+ session->policy_config->type,
+ info->config.type);
+
+ info->config.roaming_policy = session->policy_config->roaming_policy;
+
+ info->config.ecall = session->policy_config->ecall;
+ if (info->config.ecall)
+ ecall_session = session;
+
+ info->config.priority = session->policy_config->priority;
+
+ session_notify(session);
+
+ return 0;
+}
+
+static DBusMessage *connect_session(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_session *session = user_data;
+
+ DBG("session %p", session);
+
+ if (ecall_session) {
+ if (ecall_session->ecall && ecall_session != session)
+ return __connman_error_failed(msg, EBUSY);
+
+ session->ecall = true;
+ }
+
+ if (!session->active) {
+ session->active = true;
+ set_active_session(session, true);
+ }
+
+ session_activate(session);
+
+ __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_SESSION);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *disconnect_session(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_session *session = user_data;
+
+ DBG("session %p", session);
+
+ if (ecall_session) {
+ if (ecall_session->ecall && ecall_session != session)
+ return __connman_error_failed(msg, EBUSY);
+
+ session->ecall = false;
+ }
+
+ if (session->active) {
+ session->active = false;
+ set_active_session(session, false);
+ }
+
+ session_deactivate(session);
+ update_session_state(session);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *change_session(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_session *session = user_data;
+ struct session_info *info = session->info;
+ DBusMessageIter iter, value;
+ const char *name;
+ const char *val;
+ GSList *allowed_bearers;
+ int err;
+
+ DBG("session %p", session);
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ switch (dbus_message_iter_get_arg_type(&value)) {
+ case DBUS_TYPE_ARRAY:
+ if (g_str_equal(name, "AllowedBearers")) {
+ err = parse_bearers(&value, &allowed_bearers);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ if (session->active)
+ set_active_session(session, false);
+
+ session->active = false;
+ session_deactivate(session);
+
+ g_slist_free(info->config.allowed_bearers);
+ session->user_allowed_bearers = allowed_bearers;
+
+ apply_policy_on_bearers(
+ session->policy_config->allowed_bearers,
+ session->user_allowed_bearers,
+ &info->config.allowed_bearers);
+
+ session_activate(session);
+ } else {
+ goto err;
+ }
+ break;
+ case DBUS_TYPE_STRING:
+ if (g_str_equal(name, "ConnectionType")) {
+ dbus_message_iter_get_basic(&value, &val);
+ info->config.type = apply_policy_on_type(
+ session->policy_config->type,
+ connman_session_parse_connection_type(val));
+ } else {
+ goto err;
+ }
+ break;
+ default:
+ goto err;
+ }
+
+ session_notify(session);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+err:
+ return __connman_error_invalid_arguments(msg);
+}
+
+static void release_session(gpointer key, gpointer value, gpointer user_data)
+{
+ struct connman_session *session = value;
+ DBusMessage *message;
+
+ DBG("owner %s path %s", session->owner, session->notify_path);
+
+ if (session->notify_watch > 0)
+ g_dbus_remove_watch(connection, session->notify_watch);
+
+ g_dbus_unregister_interface(connection, session->session_path,
+ CONNMAN_SESSION_INTERFACE);
+
+ message = dbus_message_new_method_call(session->owner,
+ session->notify_path,
+ CONNMAN_NOTIFICATION_INTERFACE,
+ "Release");
+ if (!message)
+ return;
+
+ dbus_message_set_no_reply(message, TRUE);
+
+ g_dbus_send_message(connection, message);
+}
+
+static int session_disconnect(struct connman_session *session)
+{
+ DBG("session %p, %s", session, session->owner);
+
+ if (session->notify_watch > 0)
+ g_dbus_remove_watch(connection, session->notify_watch);
+
+ g_dbus_unregister_interface(connection, session->session_path,
+ CONNMAN_SESSION_INTERFACE);
+
+ g_hash_table_remove(session_hash, session->session_path);
+
+ return 0;
+}
+
+static void owner_disconnect(DBusConnection *conn, void *user_data)
+{
+ struct connman_session *session = user_data;
+
+ DBG("session %p, %s died", session, session->owner);
+
+ session_disconnect(session);
+}
+
+static DBusMessage *destroy_session(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct connman_session *session = user_data;
+
+ DBG("session %p", session);
+
+ if (ecall_session && ecall_session != session)
+ return __connman_error_failed(msg, EBUSY);
+
+ session_disconnect(session);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable session_methods[] = {
+ { GDBUS_METHOD("Destroy", NULL, NULL, destroy_session) },
+ { GDBUS_METHOD("Connect", NULL, NULL, connect_session) },
+ { GDBUS_METHOD("Disconnect", NULL, NULL,
+ disconnect_session ) },
+ { GDBUS_METHOD("Change",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+ NULL, change_session) },
+ { },
+};
+
+static int session_policy_config_cb(struct connman_session *session,
+ struct connman_session_config *config,
+ void *user_data, int err)
+{
+ struct creation_data *creation_data = user_data;
+ struct session_info *info, *info_last;
+ DBusMessage *reply;
+
+ DBG("session %p config %p", session, config);
+
+ if (err < 0)
+ goto err;
+
+ session->policy_config = config;
+
+ session->mark = session_mark++;
+ session->index = -1;
+
+ err = init_firewall_session(session);
+ if (err < 0)
+ goto err;
+
+ err = init_routing_table(session);
+ if (err < 0)
+ goto err;
+
+ info = session->info;
+ info_last = session->info_last;
+
+ if (session->policy_config->ecall)
+ ecall_session = session;
+
+ info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
+ info->config.type = apply_policy_on_type(
+ session->policy_config->type,
+ creation_data->type);
+ info->config.priority = session->policy_config->priority;
+ info->config.roaming_policy = session->policy_config->roaming_policy;
+
+ session->user_allowed_bearers = creation_data->allowed_bearers;
+ creation_data->allowed_bearers = NULL;
+
+ apply_policy_on_bearers(
+ session->policy_config->allowed_bearers,
+ session->user_allowed_bearers,
+ &info->config.allowed_bearers);
+
+ g_hash_table_replace(session_hash, session->session_path, session);
+
+ DBG("add %s", session->session_path);
+
+ if (!g_dbus_register_interface(connection, session->session_path,
+ CONNMAN_SESSION_INTERFACE,
+ session_methods, NULL, NULL,
+ session, NULL)) {
+ connman_error("Failed to register %s", session->session_path);
+ g_hash_table_remove(session_hash, session->session_path);
+ err = -EINVAL;
+ goto err;
+ }
+
+ reply = g_dbus_create_reply(creation_data->pending,
+ DBUS_TYPE_OBJECT_PATH, &session->session_path,
+ DBUS_TYPE_INVALID);
+ g_dbus_send_message(connection, reply);
+ creation_data->pending = NULL;
+
+ info_last->state = info->state;
+ info_last->config.priority = info->config.priority;
+ info_last->config.roaming_policy = info->config.roaming_policy;
+ info_last->config.allowed_bearers = info->config.allowed_bearers;
+
+ session->append_all = true;
+
+ cleanup_creation_data(creation_data);
+
+ session_activate(session);
+
+ return 0;
+
+err:
+ reply = __connman_error_failed(creation_data->pending, -err);
+ g_dbus_send_message(connection, reply);
+ creation_data->pending = NULL;
+
+ cleanup_session(session);
+ cleanup_creation_data(creation_data);
+
+ return err;
+}
+
+int __connman_session_create(DBusMessage *msg)
+{
+ const char *owner, *notify_path;
+ char *session_path = NULL;
+ DBusMessageIter iter, array;
+ struct connman_session *session = NULL;
+ struct creation_data *creation_data = NULL;
+ bool user_allowed_bearers = false;
+ bool user_connection_type = false;
+ int err, i;
+ char *str;
+
+ owner = dbus_message_get_sender(msg);
+
+ DBG("owner %s", owner);
+
+ if (ecall_session && ecall_session->ecall) {
+ /*
+ * If there is an emergency call already going on,
+ * ignore session creation attempt
+ */
+ err = -EBUSY;
+ goto err;
+ }
+
+ creation_data = g_try_new0(struct creation_data, 1);
+ if (!creation_data) {
+ err = -ENOMEM;
+ goto err;
+ }
+
+ creation_data->pending = dbus_message_ref(msg);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key, *val;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ switch (dbus_message_iter_get_arg_type(&value)) {
+ case DBUS_TYPE_ARRAY:
+ if (g_str_equal(key, "AllowedBearers")) {
+ err = parse_bearers(&value,
+ &creation_data->allowed_bearers);
+ if (err < 0)
+ goto err;
+
+ user_allowed_bearers = true;
+ } else {
+ err = -EINVAL;
+ goto err;
+ }
+ break;
+ case DBUS_TYPE_STRING:
+ if (g_str_equal(key, "ConnectionType")) {
+ dbus_message_iter_get_basic(&value, &val);
+ creation_data->type =
+ connman_session_parse_connection_type(val);
+
+ user_connection_type = true;
+ } else {
+ err = -EINVAL;
+ goto err;
+ }
+ }
+ dbus_message_iter_next(&array);
+ }
+
+ /*
+ * If the user hasn't provided a configuration, we set
+ * the default configuration.
+ *
+ * For AllowedBearers this is '*', ...
+ */
+ if (!user_allowed_bearers) {
+ add_default_bearer_types(&creation_data->allowed_bearers);
+ if (!creation_data->allowed_bearers) {
+ err = -ENOMEM;
+ goto err;
+ }
+ }
+
+ /* ... and for ConnectionType it is 'any'. */
+ if (!user_connection_type)
+ creation_data->type = CONNMAN_SESSION_TYPE_ANY;
+
+ dbus_message_iter_next(&iter);
+ dbus_message_iter_get_basic(&iter, ¬ify_path);
+
+ if (!notify_path) {
+ err = -EINVAL;
+ goto err;
+ }
+
+ str = g_strdup(owner);
+ for (i = 0; str[i] != '\0'; i++)
+ if (str[i] == ':' || str[i] == '.')
+ str[i] = '_';
+ session_path = g_strdup_printf("/sessions/%s%s", str, notify_path);
+ g_free(str);
+
+ if (!session_path) {
+ err = -ENOMEM;
+ goto err;
+ }
+
+ session = g_hash_table_lookup(session_hash, session_path);
+ if (session) {
+ g_free(session_path);
+ session = NULL;
+ err = -EEXIST;
+ goto err;
+ }
+
+ session = g_try_new0(struct connman_session, 1);
+ if (!session) {
+ g_free(session_path);
+ err = -ENOMEM;
+ goto err;
+ }
+
+ creation_data->session = session;
+ session->session_path = session_path;
+
+ session->info = g_try_new0(struct session_info, 1);
+ if (!session->info) {
+ err = -ENOMEM;
+ goto err;
+ }
+
+ session->info_last = g_try_new0(struct session_info, 1);
+ if (!session->info_last) {
+ err = -ENOMEM;
+ goto err;
+ }
+
+ session->owner = g_strdup(owner);
+ session->notify_path = g_strdup(notify_path);
+ session->notify_watch =
+ g_dbus_add_disconnect_watch(connection, session->owner,
+ owner_disconnect, session, NULL);
+
+ err = create_policy_config(session, session_policy_config_cb,
+ creation_data);
+ if (err < 0 && err != -EINPROGRESS)
+ return err;
+
+ return -EINPROGRESS;
+
+err:
+ connman_error("Failed to create session");
+
+ free_session(session);
+
+ cleanup_creation_data(creation_data);
+ return err;
+}
+
+bool __connman_session_policy_autoconnect(enum connman_service_connect_reason reason)
+{
+ if (!policy || !policy->autoconnect)
+ return true;
+
+ return policy->autoconnect(reason);
+}
+
+void connman_session_destroy(struct connman_session *session)
+{
+ DBG("session %p", session);
+
+ session_disconnect(session);
+}
+
+int __connman_session_destroy(DBusMessage *msg)
+{
+ const char *owner, *session_path;
+ struct connman_session *session;
+
+ owner = dbus_message_get_sender(msg);
+
+ DBG("owner %s", owner);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &session_path,
+ DBUS_TYPE_INVALID);
+ if (!session_path)
+ return -EINVAL;
+
+ session = g_hash_table_lookup(session_hash, session_path);
+ if (!session)
+ return -EINVAL;
+
+ if (g_strcmp0(owner, session->owner) != 0)
+ return -EACCES;
+
+ connman_session_destroy(session);
+
+ return 0;
+}
+
+int connman_session_connect(struct connman_service *service)
+{
+ DBG("service %p name %s", service, __connman_service_get_name(service));
+
+ return __connman_service_connect(service,
+ CONNMAN_SERVICE_CONNECT_REASON_SESSION);
+}
+
+int connman_session_disconnect(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ return __connman_service_disconnect(service);
+}
+
+static enum connman_session_state service_to_session_state(
+ enum connman_service_state state)
+{
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ break;
+ case CONNMAN_SERVICE_STATE_READY:
+ return CONNMAN_SESSION_STATE_CONNECTED;
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ return CONNMAN_SESSION_STATE_ONLINE;
+ }
+
+ return CONNMAN_SESSION_STATE_DISCONNECTED;
+}
+
+static void update_session_state(struct connman_session *session)
+{
+ enum connman_service_state service_state;
+ enum connman_session_state state = CONNMAN_SESSION_STATE_DISCONNECTED;
+
+ if (session->service) {
+ service_state = __connman_service_get_state(session->service);
+ state = service_to_session_state(service_state);
+ session->info->state = state;
+ }
+ session->info->state = state;
+
+ DBG("session %p state %s", session, state2string(state));
+
+ update_routing_table(session);
+ session_notify(session);
+}
+
+static bool session_match_service(struct connman_session *session,
+ struct connman_service *service)
+{
+ enum connman_service_type bearer_type;
+ enum connman_service_type service_type;
+ GSList *list;
+
+ if (policy && policy->allowed)
+ return policy->allowed(session, service);
+
+ for (list = session->info->config.allowed_bearers; list; list = list->next) {
+ bearer_type = GPOINTER_TO_INT(list->data);
+ service_type = connman_service_get_type(service);
+
+ if (bearer_type == service_type)
+ return true;
+ }
+
+ return false;
+}
+
+static bool is_session_connected(struct connman_session *session,
+ enum connman_service_state state)
+
+{
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ break;
+ case CONNMAN_SERVICE_STATE_READY:
+ if (session->info->config.type == CONNMAN_SESSION_TYPE_INTERNET)
+ return false;
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ return true;
+ }
+
+ return false;
+}
+
+static void session_activate(struct connman_session *session)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ if (!service_hash)
+ return;
+
+ g_hash_table_iter_init(&iter, service_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_service_info *info = value;
+ enum connman_service_state state;
+
+ state = __connman_service_get_state(info->service);
+
+ if (is_session_connected(session, state) &&
+ session_match_service(session, info->service)) {
+ DBG("session %p add service %p", session, info->service);
+
+ info->sessions = g_slist_prepend(info->sessions,
+ session);
+ session->service = info->service;
+ update_session_state(session);
+
+ return;
+ }
+ }
+
+ session_notify(session);
+}
+
+static void session_deactivate(struct connman_session *session)
+{
+ struct connman_service_info *info;
+
+ if (!service_hash)
+ return;
+
+ if (!session->service)
+ return;
+
+ info = g_hash_table_lookup(service_hash, session->service);
+ if (!info)
+ return;
+
+ info->sessions = g_slist_remove(info->sessions, session);
+ session->service = NULL;
+
+ session->info->state = CONNMAN_SESSION_STATE_DISCONNECTED;
+}
+
+static void handle_service_state_online(struct connman_service *service,
+ enum connman_service_state state,
+ struct connman_service_info *info)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+
+ g_hash_table_iter_init(&iter, session_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct connman_session *session = value;
+ bool connected;
+
+ connected = is_session_connected(session, state);
+
+ if (session->service == service) {
+ if (!connected) {
+ DBG("session %p remove service %p", session, service);
+ info->sessions = g_slist_remove(info->sessions,
+ session);
+ session->service = NULL;
+ update_session_state(session);
+ }
+ } else if (connected && session_match_service(session, service)) {
+ DBG("session %p add service %p", session, service);
+
+ info->sessions = g_slist_prepend(info->sessions,
+ session);
+ session->service = service;
+ update_session_state(session);
+ }
+ }
+}
+
+static void handle_service_state_offline(struct connman_service *service,
+ struct connman_service_info *info)
+{
+ GSList *list;
+
+ for (list = info->sessions; list; list = list->next) {
+ struct connman_session *session = list->data;
+
+ if (session->service != service) {
+ connman_warn("session %p should have session %p assigned",
+ session, service);
+ continue;
+ }
+
+ DBG("session %p remove service %p", session, service);
+
+ session->service = NULL;
+ update_session_state(session);
+ }
+}
+
+
+static void service_state_changed(struct connman_service *service,
+ enum connman_service_state state)
+{
+ struct connman_service_info *info;
+
+ DBG("service %p state %d", service, state);
+
+ info = g_hash_table_lookup(service_hash, service);
+
+ switch (state) {
+ case CONNMAN_SERVICE_STATE_UNKNOWN:
+ case CONNMAN_SERVICE_STATE_IDLE:
+ case CONNMAN_SERVICE_STATE_ASSOCIATION:
+ case CONNMAN_SERVICE_STATE_CONFIGURATION:
+ case CONNMAN_SERVICE_STATE_FAILURE:
+ case CONNMAN_SERVICE_STATE_DISCONNECT:
+ if (!info)
+ return;
+
+ handle_service_state_offline(service, info);
+
+ g_hash_table_remove(service_hash, service);
+
+ return;
+ case CONNMAN_SERVICE_STATE_READY:
+ case CONNMAN_SERVICE_STATE_ONLINE:
+ if (!info) {
+ info = g_new0(struct connman_service_info, 1);
+ g_hash_table_replace(service_hash, service, info);
+ }
+
+ info->service = service;
+ handle_service_state_online(service, state, info);
+ }
+}
+
+static void ipconfig_changed(struct connman_service *service,
+ struct connman_ipconfig *ipconfig)
+{
+ GHashTableIter iter;
+ gpointer key, value;
+ struct connman_session *session;
+ struct session_info *info;
+ enum connman_ipconfig_type type;
+
+ DBG("service %p ipconfig %p", service, ipconfig);
+
+ type = __connman_ipconfig_get_config_type(ipconfig);
+
+ g_hash_table_iter_init(&iter, session_hash);
+
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ session = value;
+ info = session->info;
+
+ if (info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
+ continue;
+
+ if (session->service && session->service == service) {
+ update_routing_table(session);
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ ipconfig_ipv4_changed(session);
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ ipconfig_ipv6_changed(session);
+ }
+ }
+}
+
+static struct connman_notifier session_notifier = {
+ .name = "session",
+ .service_state_changed = service_state_changed,
+ .ipconfig_changed = ipconfig_changed,
+};
+
+int __connman_session_init(void)
+{
+ int err;
+
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ err = connman_notifier_register(&session_notifier);
+ if (err < 0) {
+ dbus_connection_unref(connection);
+ return err;
+ }
+
+ session_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, cleanup_session);
+
+ service_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, cleanup_service);
+
+ return 0;
+}
+
+void __connman_session_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ cleanup_firewall();
+
+ connman_notifier_unregister(&session_notifier);
+
+ g_hash_table_foreach(session_hash, release_session, NULL);
+ g_hash_table_destroy(session_hash);
+ session_hash = NULL;
+ g_hash_table_destroy(service_hash);
+ service_hash = NULL;
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/shared/debugfs.c b/src/shared/debugfs.c
new file mode 100644
index 0000000..f522c51
--- /dev/null
+++ b/src/shared/debugfs.c
@@ -0,0 +1,66 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <limits.h>
+
+#include "src/shared/debugfs.h"
+
+#define STRINGIFY(x) STRINGIFY_ARG(x)
+#define STRINGIFY_ARG(x) #x
+
+const char *debugfs_get_path(void)
+{
+ static char path[PATH_MAX + 1];
+ static bool found = false;
+ char type[100];
+ FILE *fp;
+
+ if (found)
+ return path;
+
+ fp = fopen("/proc/mounts", "r");
+ if (!fp)
+ return NULL;
+
+ while (fscanf(fp, "%*s %" STRINGIFY(PATH_MAX) "s %99s %*s %*d %*d\n",
+ path, type) == 2) {
+ if (!strcmp(type, "debugfs")) {
+ found = true;
+ break;
+ }
+ }
+
+ fclose(fp);
+
+ if (!found)
+ return NULL;
+
+ return path;
+}
diff --git a/src/shared/debugfs.h b/src/shared/debugfs.h
new file mode 100644
index 0000000..7f41ca7
--- /dev/null
+++ b/src/shared/debugfs.h
@@ -0,0 +1,24 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+const char *debugfs_get_path(void);
diff --git a/src/shared/netlink.c b/src/shared/netlink.c
new file mode 100644
index 0000000..cf54131
--- /dev/null
+++ b/src/shared/netlink.c
@@ -0,0 +1,665 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2013-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+/*
+ * This file is a copy from ELL which has been ported to use GLib's
+ * data structures.
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <linux/netlink.h>
+
+#include <gdbus.h>
+
+#include "src/shared/util.h"
+#include "src/shared/netlink.h"
+
+#ifndef SOL_NETLINK
+#define SOL_NETLINK 270
+#endif
+
+struct command {
+ unsigned int id;
+ uint32_t seq;
+ uint32_t len;
+ netlink_command_func_t handler;
+ netlink_destroy_func_t destroy;
+ void *user_data;
+};
+
+struct notify {
+ uint32_t group;
+ netlink_notify_func_t handler;
+ netlink_destroy_func_t destroy;
+ void *user_data;
+};
+
+struct netlink_info {
+ uint32_t pid;
+ GIOChannel *channel;
+ uint32_t next_seq;
+ GQueue *command_queue;
+ GHashTable *command_pending;
+ GHashTable *command_lookup;
+ unsigned int next_command_id;
+ GHashTable *notify_groups;
+ GHashTable *notify_lookup;
+ unsigned int next_notify_id;
+ netlink_debug_func_t debug_handler;
+ netlink_destroy_func_t debug_destroy;
+ void *debug_data;
+};
+
+
+static void destroy_command(struct command *command)
+{
+ if (command->destroy)
+ command->destroy(command->user_data);
+
+ g_free(command);
+}
+
+static void destroy_notify(struct notify *notify)
+{
+ if (notify->destroy)
+ notify->destroy(notify->user_data);
+
+ g_free(notify);
+}
+
+static gboolean can_write_data(GIOChannel *chan,
+ GIOCondition cond, gpointer user_data)
+{
+ struct netlink_info *netlink = user_data;
+ struct command *command;
+ struct sockaddr_nl addr;
+ const void *data;
+ ssize_t written;
+ int sk;
+
+ command = g_queue_pop_head(netlink->command_queue);
+ if (!command)
+ return FALSE;
+
+ sk = g_io_channel_unix_get_fd(chan);
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+ addr.nl_pid = 0;
+
+ data = ((void *) command) + NLMSG_ALIGN(sizeof(struct command));
+
+ written = sendto(sk, data, command->len, 0,
+ (struct sockaddr *) &addr, sizeof(addr));
+ if (written < 0 || (uint32_t) written != command->len) {
+ g_hash_table_remove(netlink->command_lookup,
+ GUINT_TO_POINTER(command->id));
+ destroy_command(command);
+ return FALSE;
+ }
+
+ util_hexdump('<', data, command->len,
+ netlink->debug_handler, netlink->debug_data);
+
+ g_hash_table_replace(netlink->command_pending,
+ GUINT_TO_POINTER(command->seq), command);
+
+ return g_queue_get_length(netlink->command_queue) > 0;
+}
+
+static void do_notify(gpointer key, gpointer value, gpointer user_data)
+{
+ struct nlmsghdr *nlmsg = user_data;
+ struct notify *notify = value;
+
+ if (notify->handler) {
+ notify->handler(nlmsg->nlmsg_type, NLMSG_DATA(nlmsg),
+ nlmsg->nlmsg_len - NLMSG_HDRLEN, notify->user_data);
+ }
+}
+
+static void process_broadcast(struct netlink_info *netlink, uint32_t group,
+ struct nlmsghdr *nlmsg)
+{
+ GHashTable *notify_list;
+
+ notify_list = g_hash_table_lookup(netlink->notify_groups,
+ GUINT_TO_POINTER(group));
+ if (!notify_list)
+ return;
+
+ g_hash_table_foreach(notify_list, do_notify, nlmsg);
+}
+
+static void process_message(struct netlink_info *netlink,
+ struct nlmsghdr *nlmsg)
+{
+ const void *data = nlmsg;
+ struct command *command;
+
+ command = g_hash_table_lookup(netlink->command_pending,
+ GUINT_TO_POINTER(nlmsg->nlmsg_seq));
+ if (!command)
+ return;
+
+ g_hash_table_remove(netlink->command_pending,
+ GUINT_TO_POINTER(nlmsg->nlmsg_seq));
+
+ if (!command->handler)
+ goto done;
+
+ if (nlmsg->nlmsg_type < NLMSG_MIN_TYPE) {
+ const struct nlmsgerr *err;
+
+ switch (nlmsg->nlmsg_type) {
+ case NLMSG_ERROR:
+ err = data + NLMSG_HDRLEN;
+
+ command->handler(-err->error, 0, NULL, 0,
+ command->user_data);
+ break;
+ }
+ } else {
+ command->handler(0, nlmsg->nlmsg_type, data + NLMSG_HDRLEN,
+ nlmsg->nlmsg_len - NLMSG_HDRLEN,
+ command->user_data);
+ }
+
+done:
+ g_hash_table_remove(netlink->command_lookup,
+ GUINT_TO_POINTER(command->id));
+
+ destroy_command(command);
+}
+
+static void process_multi(struct netlink_info *netlink, struct nlmsghdr *nlmsg)
+{
+ const void *data = nlmsg;
+ struct command *command;
+
+ command = g_hash_table_lookup(netlink->command_pending,
+ GUINT_TO_POINTER(nlmsg->nlmsg_seq));
+ if (!command)
+ return;
+
+ if (!command->handler)
+ goto done;
+
+ if (nlmsg->nlmsg_type < NLMSG_MIN_TYPE) {
+ const struct nlmsgerr *err;
+
+ switch (nlmsg->nlmsg_type) {
+ case NLMSG_DONE:
+ case NLMSG_ERROR:
+ err = data + NLMSG_HDRLEN;
+
+ command->handler(-err->error, 0, NULL, 0,
+ command->user_data);
+ break;
+ }
+ } else {
+ command->handler(0, nlmsg->nlmsg_type, data + NLMSG_HDRLEN,
+ nlmsg->nlmsg_len - NLMSG_HDRLEN,
+ command->user_data);
+ return;
+ }
+
+done:
+ g_hash_table_remove(netlink->command_pending,
+ GUINT_TO_POINTER(nlmsg->nlmsg_seq));
+
+ g_hash_table_remove(netlink->command_lookup,
+ GUINT_TO_POINTER(command->id));
+
+ destroy_command(command);
+}
+
+static gboolean can_read_data(GIOChannel *chan,
+ GIOCondition cond, gpointer data)
+{
+ struct netlink_info *netlink = data;
+ struct cmsghdr *cmsg;
+ struct msghdr msg;
+ struct iovec iov;
+ struct nlmsghdr *nlmsg;
+ unsigned char buffer[4096];
+ unsigned char control[32];
+ uint32_t group = 0;
+ ssize_t len;
+ int sk;
+
+ sk = g_io_channel_unix_get_fd(chan);
+
+ iov.iov_base = buffer;
+ iov.iov_len = sizeof(buffer);
+
+ memset(&msg, 0, sizeof(msg));
+ msg.msg_iov = &iov;
+ msg.msg_iovlen = 1;
+ msg.msg_control = control;
+ msg.msg_controllen = sizeof(control);
+
+ len = recvmsg(sk, &msg, 0);
+ if (len < 0)
+ return FALSE;
+
+ util_hexdump('>', buffer, len, netlink->debug_handler,
+ netlink->debug_data);
+
+ for (cmsg = CMSG_FIRSTHDR(&msg); cmsg;
+ cmsg = CMSG_NXTHDR(&msg, cmsg)) {
+ struct nl_pktinfo *pktinfo;
+
+ if (cmsg->cmsg_level != SOL_NETLINK)
+ continue;
+
+ if (cmsg->cmsg_type != NETLINK_PKTINFO)
+ continue;
+
+ pktinfo = (void *) CMSG_DATA(cmsg);
+
+ group = pktinfo->group;
+ }
+
+ for (nlmsg = iov.iov_base; NLMSG_OK(nlmsg, (uint32_t) len);
+ nlmsg = NLMSG_NEXT(nlmsg, len)) {
+ if (group > 0 && nlmsg->nlmsg_seq == 0) {
+ process_broadcast(netlink, group, nlmsg);
+ continue;
+ }
+
+ if (nlmsg->nlmsg_pid != netlink->pid)
+ continue;
+
+ if (nlmsg->nlmsg_flags & NLM_F_MULTI)
+ process_multi(netlink, nlmsg);
+ else
+ process_message(netlink, nlmsg);
+ }
+
+ return TRUE;
+}
+
+static gboolean netlink_event(GIOChannel *chan,
+ GIOCondition cond, gpointer data)
+{
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ return TRUE;
+}
+
+static int create_netlink_socket(int protocol, uint32_t *pid)
+{
+ struct sockaddr_nl addr;
+ socklen_t addrlen = sizeof(addr);
+ int sk, pktinfo = 1;
+
+ sk = socket(PF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK,
+ protocol);
+ if (sk < 0)
+ return -1;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+
+ if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ close(sk);
+ return -1;
+ }
+
+ if (getsockname(sk, (struct sockaddr *) &addr, &addrlen) < 0) {
+ close(sk);
+ return -1;
+ }
+
+ if (setsockopt(sk, SOL_NETLINK, NETLINK_PKTINFO,
+ &pktinfo, sizeof(pktinfo)) < 0) {
+ close(sk);
+ return -1;
+ }
+
+ if (pid)
+ *pid = addr.nl_pid;
+
+ return sk;
+}
+
+struct netlink_info *netlink_new(int protocol)
+{
+ struct netlink_info *netlink;
+ int sk;
+
+ netlink = g_try_new0(struct netlink_info, 1);
+ if (!netlink)
+ return NULL;
+
+ netlink->next_seq = 1;
+ netlink->next_command_id = 1;
+ netlink->next_notify_id = 1;
+
+ sk = create_netlink_socket(protocol, &netlink->pid);
+ if (sk < 0) {
+ g_free(netlink);
+ return NULL;
+ }
+
+ netlink->channel = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(netlink->channel, TRUE);
+
+ g_io_channel_set_encoding(netlink->channel, NULL, NULL);
+ g_io_channel_set_buffered(netlink->channel, FALSE);
+
+ g_io_add_watch(netlink->channel, G_IO_IN, can_read_data, netlink);
+ g_io_add_watch(netlink->channel, G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ netlink_event, netlink);
+
+ netlink->command_queue = g_queue_new();
+ netlink->command_pending = g_hash_table_new(g_direct_hash,
+ g_direct_equal);
+ netlink->command_lookup = g_hash_table_new(g_direct_hash,
+ g_direct_equal);
+
+ netlink->notify_groups = g_hash_table_new(g_direct_hash,
+ g_direct_equal);
+ netlink->notify_lookup = g_hash_table_new(g_direct_hash,
+ g_direct_equal);
+
+ return netlink;
+}
+
+static gboolean cleanup_notify(gpointer key, gpointer value, gpointer user_data)
+{
+ struct notify *notify = value;
+
+ destroy_notify(notify);
+
+ return TRUE;
+
+}
+
+static gboolean cleanup_notify_group(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ GHashTable *notify_list = value;
+
+ g_hash_table_foreach_remove(notify_list, cleanup_notify, user_data);
+ g_hash_table_destroy(notify_list);
+
+ return TRUE;
+}
+
+static gboolean cleanup_command(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct command *command = value;
+
+ destroy_command(command);
+
+ return TRUE;
+}
+
+void netlink_destroy(struct netlink_info *netlink)
+{
+ g_hash_table_destroy(netlink->notify_lookup);
+
+ g_hash_table_foreach_remove(netlink->notify_groups,
+ cleanup_notify_group, NULL);
+ g_hash_table_destroy(netlink->notify_groups);
+
+ g_queue_free(netlink->command_queue);
+
+ g_hash_table_destroy(netlink->command_pending);
+
+ g_hash_table_foreach_remove(netlink->command_lookup,
+ cleanup_command, NULL);
+ g_hash_table_destroy(netlink->command_lookup);
+
+ g_io_channel_shutdown(netlink->channel, TRUE, NULL);
+ g_io_channel_unref(netlink->channel);
+
+ g_free(netlink);
+}
+
+unsigned int netlink_send(struct netlink_info *netlink,
+ uint16_t type, uint16_t flags, const void *data,
+ uint32_t len, netlink_command_func_t function,
+ void *user_data, netlink_destroy_func_t destroy)
+{
+ struct command *command;
+ struct nlmsghdr *nlmsg;
+ size_t size;
+
+ if (!netlink)
+ return 0;
+
+ if (!netlink->command_queue ||
+ !netlink->command_pending ||
+ !netlink->command_lookup)
+ return 0;
+
+ size = NLMSG_ALIGN(sizeof(struct command)) +
+ NLMSG_HDRLEN + NLMSG_ALIGN(len);
+
+ command = g_try_malloc0(size);
+ if (!command)
+ return 0;
+
+ command->handler = function;
+ command->destroy = destroy;
+ command->user_data = user_data;
+
+ command->id = netlink->next_command_id;
+
+ g_hash_table_replace(netlink->command_lookup,
+ GUINT_TO_POINTER(command->id), command);
+
+ command->seq = netlink->next_seq++;
+ command->len = NLMSG_HDRLEN + NLMSG_ALIGN(len);
+
+ nlmsg = ((void *) command) + NLMSG_ALIGN(sizeof(struct command));
+
+ nlmsg->nlmsg_len = command->len;
+ nlmsg->nlmsg_type = type;
+ nlmsg->nlmsg_flags = NLM_F_REQUEST | flags;
+ nlmsg->nlmsg_seq = command->seq;
+ nlmsg->nlmsg_pid = netlink->pid;
+
+ if (data && len > 0)
+ memcpy(((void *) nlmsg) + NLMSG_HDRLEN, data, len);
+
+ g_queue_push_tail(netlink->command_queue, command);
+
+ netlink->next_command_id++;
+
+ /* Arm IOChannel to call can_write_data in case it is not armed yet. */
+ if (g_queue_get_length(netlink->command_queue) == 1)
+ g_io_add_watch(netlink->channel, G_IO_OUT, can_write_data,
+ netlink);
+
+ return command->id;
+}
+
+bool netlink_cancel(struct netlink_info *netlink, unsigned int id)
+{
+ struct command *command;
+
+ if (!netlink || id == 0)
+ return false;
+
+ if (!netlink->command_queue ||
+ !netlink->command_pending ||
+ !netlink->command_lookup)
+ return false;
+
+ command = g_hash_table_lookup(netlink->command_lookup,
+ GUINT_TO_POINTER(id));
+ if (!command)
+ return false;
+
+ g_hash_table_remove(netlink->command_lookup, GUINT_TO_POINTER(id));
+
+ g_queue_remove(netlink->command_queue, command);
+
+ g_hash_table_remove(netlink->command_pending, GUINT_TO_POINTER(command->seq));
+
+ destroy_command(command);
+
+ return true;
+}
+
+static bool add_membership(struct netlink_info *netlink, uint32_t group)
+{
+ int sk, value = group;
+
+ sk = g_io_channel_unix_get_fd(netlink->channel);
+
+ if (setsockopt(sk, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP,
+ &value, sizeof(value)) < 0)
+ return false;
+
+ return true;
+}
+
+static bool drop_membership(struct netlink_info *netlink, uint32_t group)
+{
+ int sk, value = group;
+
+ sk = g_io_channel_unix_get_fd(netlink->channel);
+
+ if (setsockopt(sk, SOL_NETLINK, NETLINK_DROP_MEMBERSHIP,
+ &value, sizeof(value)) < 0)
+ return false;
+
+ return true;
+}
+
+unsigned int netlink_register(struct netlink_info *netlink,
+ uint32_t group, netlink_notify_func_t function,
+ void *user_data, netlink_destroy_func_t destroy)
+{
+ GHashTable *notify_list;
+ struct notify *notify;
+ unsigned int id;
+
+ if (!netlink)
+ return 0;
+
+ if (!netlink->notify_groups || !netlink->notify_lookup)
+ return 0;
+
+ notify_list = g_hash_table_lookup(netlink->notify_groups,
+ GUINT_TO_POINTER(group));
+ if (!notify_list) {
+ notify_list = g_hash_table_new(g_direct_hash, g_direct_equal);
+ if (!notify_list)
+ return 0;
+
+ g_hash_table_replace(netlink->notify_groups,
+ GUINT_TO_POINTER(group), notify_list);
+ }
+
+ notify = g_new(struct notify, 1);
+
+ notify->group = group;
+ notify->handler = function;
+ notify->destroy = destroy;
+ notify->user_data = user_data;
+
+ id = netlink->next_notify_id;
+
+ g_hash_table_replace(netlink->notify_lookup,
+ GUINT_TO_POINTER(id), notify_list);
+ g_hash_table_replace(notify_list, GUINT_TO_POINTER(id), notify);
+
+ if (g_hash_table_size(notify_list) == 1) {
+ if (add_membership(netlink, notify->group) == false)
+ goto remove_notify;
+ }
+
+ netlink->next_notify_id++;
+
+ return id;
+
+remove_notify:
+ g_hash_table_remove(notify_list, GUINT_TO_POINTER(id));
+ g_hash_table_remove(netlink->notify_lookup, GUINT_TO_POINTER(id));
+ g_free(notify);
+
+ return 0;
+}
+
+bool netlink_unregister(struct netlink_info *netlink, unsigned int id)
+{
+ GHashTable *notify_list;
+ struct notify *notify;
+
+ if (!netlink || id == 0)
+ return false;
+
+ if (!netlink->notify_groups || !netlink->notify_lookup)
+ return false;
+
+ notify_list = g_hash_table_lookup(netlink->notify_lookup,
+ GUINT_TO_POINTER(id));
+
+ if (!notify_list)
+ return false;
+
+ g_hash_table_remove(netlink->notify_lookup, GUINT_TO_POINTER(id));
+
+ notify = g_hash_table_lookup(notify_list, GUINT_TO_POINTER(id));
+ if (!notify)
+ return false;
+
+ g_hash_table_remove(notify_list, GUINT_TO_POINTER(id));
+
+ if (g_hash_table_size(notify_list) == 0)
+ drop_membership(netlink, notify->group);
+
+ destroy_notify(notify);
+
+ return true;
+}
+
+bool netlink_set_debug(struct netlink_info *netlink,
+ netlink_debug_func_t function,
+ void *user_data, netlink_destroy_func_t destroy)
+{
+ if (!netlink)
+ return false;
+
+ if (netlink->debug_destroy)
+ netlink->debug_destroy(netlink->debug_data);
+
+ netlink->debug_handler = function;
+ netlink->debug_destroy = destroy;
+ netlink->debug_data = user_data;
+
+ return true;
+}
diff --git a/src/shared/netlink.h b/src/shared/netlink.h
new file mode 100644
index 0000000..62bb3e0
--- /dev/null
+++ b/src/shared/netlink.h
@@ -0,0 +1,53 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2013 BMW Car IT GbmH.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1 as published by the Free Software Foundation.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef void (*netlink_debug_func_t) (const char *str, void *user_data);
+typedef void (*netlink_command_func_t) (unsigned int error,
+ uint16_t type, const void *data,
+ uint32_t len, void *user_data);
+typedef void (*netlink_notify_func_t) (uint16_t type, const void *data,
+ uint32_t len, void *user_data);
+typedef void (*netlink_destroy_func_t) (void *user_data);
+
+struct netlink_info;
+
+struct netlink_info *netlink_new(int protocol);
+void netlink_destroy(struct netlink_info *netlink);
+
+unsigned int netlink_send(struct netlink_info *netlink,
+ uint16_t type, uint16_t flags, const void *data,
+ uint32_t len, netlink_command_func_t function,
+ void *user_data, netlink_destroy_func_t destroy);
+bool netlink_cancel(struct netlink_info *netlink, unsigned int id);
+
+unsigned int netlink_register(struct netlink_info *netlink,
+ uint32_t group, netlink_notify_func_t function,
+ void *user_data, netlink_destroy_func_t destroy);
+bool netlink_unregister(struct netlink_info *netlink, unsigned int id);
+
+bool netlink_set_debug(struct netlink_info *netlink,
+ netlink_debug_func_t function,
+ void *user_data, netlink_destroy_func_t destroy);
diff --git a/src/shared/util.c b/src/shared/util.c
new file mode 100644
index 0000000..df045c5
--- /dev/null
+++ b/src/shared/util.c
@@ -0,0 +1,90 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <stdarg.h>
+
+#include "src/shared/util.h"
+
+void util_debug(util_debug_func_t function, void *user_data,
+ const char *format, ...)
+{
+ char str[78];
+ va_list ap;
+
+ if (!function || !format)
+ return;
+
+ va_start(ap, format);
+ vsnprintf(str, sizeof(str), format, ap);
+ va_end(ap);
+
+ function(str, user_data);
+}
+
+void util_hexdump(const char dir, const unsigned char *buf, size_t len,
+ util_debug_func_t function, void *user_data)
+{
+ static const char hexdigits[] = "0123456789abcdef";
+ char str[68];
+ size_t i;
+
+ if (!function || !len)
+ return;
+
+ str[0] = dir;
+
+ for (i = 0; i < len; i++) {
+ str[((i % 16) * 3) + 1] = ' ';
+ str[((i % 16) * 3) + 2] = hexdigits[buf[i] >> 4];
+ str[((i % 16) * 3) + 3] = hexdigits[buf[i] & 0xf];
+ str[(i % 16) + 51] = isprint(buf[i]) ? buf[i] : '.';
+
+ if ((i + 1) % 16 == 0) {
+ str[49] = ' ';
+ str[50] = ' ';
+ str[67] = '\0';
+ function(str, user_data);
+ str[0] = ' ';
+ }
+ }
+
+ if (i % 16 > 0) {
+ size_t j;
+ for (j = (i % 16); j < 16; j++) {
+ str[(j * 3) + 1] = ' ';
+ str[(j * 3) + 2] = ' ';
+ str[(j * 3) + 3] = ' ';
+ str[j + 51] = ' ';
+ }
+ str[49] = ' ';
+ str[50] = ' ';
+ str[67] = '\0';
+ function(str, user_data);
+ }
+}
diff --git a/src/shared/util.h b/src/shared/util.h
new file mode 100644
index 0000000..293fb3a
--- /dev/null
+++ b/src/shared/util.h
@@ -0,0 +1,50 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <glib.h>
+
+typedef void (*util_debug_func_t)(const char *str, void *user_data);
+
+void util_debug(util_debug_func_t function, void *user_data,
+ const char *format, ...)
+ __attribute__((format(printf, 3, 4)));
+
+void util_hexdump(const char dir, const unsigned char *buf, size_t len,
+ util_debug_func_t function, void *user_data);
+
+struct cb_data {
+ void *cb;
+ void *user_data;
+ void *data;
+};
+
+static inline struct cb_data *cb_data_new(void *cb, void *user_data)
+{
+ struct cb_data *ret;
+
+ ret = g_new0(struct cb_data, 1);
+ ret->cb = cb;
+ ret->user_data = user_data;
+
+ return ret;
+}
diff --git a/src/stats.c b/src/stats.c
new file mode 100644
index 0000000..26343b1
--- /dev/null
+++ b/src/stats.c
@@ -0,0 +1,825 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2010-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <limits.h>
+#include <sys/stat.h>
+
+#include "connman.h"
+
+#define MODE (S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | \
+ S_IXGRP | S_IROTH | S_IXOTH)
+
+#ifdef TEMP_FAILURE_RETRY
+#define TFR TEMP_FAILURE_RETRY
+#else
+#define TFR
+#endif
+
+#define MAGIC 0xFA00B916
+
+/*
+ * Statistics counters are stored into a ring buffer which is stored
+ * into a file
+ *
+ * File properties:
+ * The ring buffer is mmap to a file
+ * Initialy only the smallest possible amount of disk space is allocated
+ * The files grow to the configured maximal size
+ * The grows by _SC_PAGESIZE step size
+ * For each service a file is created
+ * Each file has a header where the indexes are stored
+ *
+ * Entries properties:
+ * Each entry has a timestamp
+ * A flag to mark if the entry is either home (0) or roaming (1) entry
+ * The entries are fixed sized (stats_record)
+ *
+ * Ring buffer properties:
+ * There are to indexes 'begin', 'end', 'home' and 'roaming'
+ * 'begin' points to the oldest entry
+ * 'end' points to the newest/current entry
+ * 'home' points to the current home entry
+ * 'roaming' points to the current roaming entry
+ * If 'begin' == 'end' then the buffer is empty
+ * If 'end' + 1 == 'begin then it's full
+ * The ring buffer is valid in the range (begin, end]
+ * If 'home' has the value UINT_MAX', 'home' is invalid
+ * if 'roaming' has the value UINT_MAX', 'roaming' is invalid
+ * 'first' points to the first entry in the ring buffer
+ * 'last' points to the last entry in the ring buffer
+ *
+ * History file:
+ * Same format as the ring buffer file
+ * For a period of at least 2 months dayly records are keept
+ * If older, then only a monthly record is keept
+ */
+
+
+struct stats_file_header {
+ unsigned int magic;
+ unsigned int begin;
+ unsigned int end;
+ unsigned int home;
+ unsigned int roaming;
+};
+
+struct stats_record {
+ time_t ts;
+ unsigned int roaming;
+ struct connman_stats_data data;
+};
+
+struct stats_file {
+ int fd;
+ char *name;
+ char *addr;
+ size_t len;
+ size_t max_len;
+
+ /* cached values */
+ struct stats_record *first;
+ struct stats_record *last;
+ struct stats_record *home;
+ struct stats_record *roaming;
+
+ /* history */
+ char *history_name;
+ int account_period_offset;
+};
+
+struct stats_iter {
+ struct stats_file *file;
+ struct stats_record *begin;
+ struct stats_record *end;
+ struct stats_record *it;
+};
+
+static GHashTable *stats_hash = NULL;
+
+static struct stats_file_header *get_hdr(struct stats_file *file)
+{
+ return (struct stats_file_header *)file->addr;
+}
+
+static struct stats_record *get_begin(struct stats_file *file)
+{
+ unsigned int off = get_hdr(file)->begin;
+
+ return (struct stats_record *)(file->addr + off);
+}
+
+static struct stats_record *get_end(struct stats_file *file)
+{
+ unsigned int off = get_hdr(file)->end;
+
+ return (struct stats_record *)(file->addr + off);
+}
+
+static struct stats_record *get_home(struct stats_file *file)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+
+ if (hdr->home == UINT_MAX)
+ return NULL;
+
+ return (struct stats_record *)(file->addr + hdr->home);
+}
+
+static struct stats_record *get_roaming(struct stats_file *file)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+
+ if (hdr->roaming == UINT_MAX)
+ return NULL;
+
+ return (struct stats_record *)(file->addr + hdr->roaming);
+}
+
+static void set_end(struct stats_file *file, struct stats_record *end)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+ hdr->end = (char *)end - file->addr;
+}
+
+static void set_home(struct stats_file *file, struct stats_record *home)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+ hdr->home = (char *)home - file->addr;
+}
+
+static void set_roaming(struct stats_file *file, struct stats_record *roaming)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+ hdr->roaming = (char *)roaming - file->addr;
+}
+
+static struct stats_record *get_next(struct stats_file *file,
+ struct stats_record *cur)
+{
+ cur++;
+
+ if (cur > file->last)
+ cur = file->first;
+
+ return cur;
+}
+
+static struct stats_record *get_iterator_begin(struct stats_file *file)
+{
+ return get_next(file, get_begin(file));
+}
+
+static struct stats_record *get_iterator_end(struct stats_file *file)
+{
+ return get_next(file, get_end(file));
+}
+
+static void stats_free(gpointer user_data)
+{
+ struct stats_file *file = user_data;
+
+ if (!file)
+ return;
+
+ msync(file->addr, file->len, MS_SYNC);
+
+ munmap(file->addr, file->len);
+ file->addr = NULL;
+
+ TFR(close(file->fd));
+ file->fd = -1;
+
+ if (file->history_name) {
+ g_free(file->history_name);
+ file->history_name = NULL;
+ }
+
+ if (file->name) {
+ g_free(file->name);
+ file->name = NULL;
+ }
+
+ g_free(file);
+}
+
+static void update_first(struct stats_file *file)
+{
+ file->first = (struct stats_record *)
+ (file->addr + sizeof(struct stats_file_header));
+}
+
+static void update_last(struct stats_file *file)
+{
+ unsigned int max_entries;
+
+ max_entries = (file->len - sizeof(struct stats_file_header)) /
+ sizeof(struct stats_record);
+ file->last = file->first + max_entries - 1;
+}
+
+static void update_home(struct stats_file *file)
+{
+ file->home = get_home(file);
+}
+
+static void update_roaming(struct stats_file *file)
+{
+ file->roaming = get_roaming(file);
+}
+
+static void stats_file_update_cache(struct stats_file *file)
+{
+ update_first(file);
+ update_last(file);
+ update_home(file);
+ update_roaming(file);
+}
+
+static int stats_file_remap(struct stats_file *file, size_t size)
+{
+ size_t page_size, new_size;
+ void *addr;
+ int err;
+
+ DBG("file %p size %zu addr %p len %zu", file, size, file->addr,
+ file->len);
+
+ page_size = sysconf(_SC_PAGESIZE);
+ new_size = (size + page_size - 1) & ~(page_size - 1);
+
+ err = ftruncate(file->fd, new_size);
+ if (err < 0) {
+ connman_error("ftrunctate error %s for %s",
+ strerror(errno), file->name);
+ return -errno;
+ }
+
+ if (!file->addr) {
+ /*
+ * Though the buffer is not shared between processes, we still
+ * have to take MAP_SHARED because MAP_PRIVATE does not
+ * guarantee that writes will hit the file without an explicit
+ * call to munmap or msync. For more details please read the
+ * mmap man pages.
+ */
+ addr = mmap(NULL, new_size, PROT_READ | PROT_WRITE,
+ MAP_SHARED, file->fd, 0);
+ } else {
+ addr = mremap(file->addr, file->len, new_size, MREMAP_MAYMOVE);
+ }
+
+ if (addr == MAP_FAILED) {
+ connman_error("mmap error %s for %s",
+ strerror(errno), file->name);
+ if (errno == EINVAL) {
+ connman_error("%s might be on a file system, such as "
+ "JFFS2, that does not allow shared "
+ "writable mappings.", file->name);
+ }
+ return -errno;
+ }
+
+ file->addr = addr;
+ file->len = new_size;
+
+ stats_file_update_cache(file);
+
+ return 0;
+}
+
+static int stats_open(struct stats_file *file,
+ const char *name)
+{
+ DBG("file %p name %s", file, name);
+
+ file->name = g_strdup(name);
+
+ file->fd = TFR(open(file->name, O_RDWR | O_CREAT | O_CLOEXEC, 0644));
+ if (file->fd < 0) {
+ connman_error("open error %s for %s",
+ strerror(errno), file->name);
+ g_free(file->name);
+ file->name = NULL;
+ return -errno;
+ }
+
+ return 0;
+}
+
+static int stats_open_temp(struct stats_file *file)
+{
+ file->name = g_strdup_printf("%s/stats.XXXXXX.tmp",
+ STORAGEDIR);
+ file->fd = g_mkstemp_full(file->name, O_RDWR | O_CREAT, 0644);
+ if (file->fd < 0) {
+ connman_error("create tempory file error %s for %s",
+ strerror(errno), file->name);
+ g_free(file->name);
+ file->name = NULL;
+ return -errno;
+ }
+
+ return 0;
+}
+
+static int stats_file_setup(struct stats_file *file)
+{
+ struct stats_file_header *hdr;
+ struct stat st;
+ size_t size = 0;
+ int err;
+
+ DBG("file %p fd %d name %s", file, file->fd, file->name);
+
+ err = fstat(file->fd, &st);
+ if (err < 0) {
+ connman_error("fstat error %s for %s\n",
+ strerror(errno), file->name);
+
+ TFR(close(file->fd));
+ g_free(file->name);
+ file->name = NULL;
+
+ return -errno;
+ }
+
+ size = (size_t)st.st_size;
+ file->max_len = STATS_MAX_FILE_SIZE;
+
+ if (size < (size_t)sysconf(_SC_PAGESIZE))
+ size = sysconf(_SC_PAGESIZE);
+
+ err = stats_file_remap(file, size);
+ if (err < 0) {
+ TFR(close(file->fd));
+ g_free(file->name);
+ file->name = NULL;
+
+ return err;
+ }
+
+ hdr = get_hdr(file);
+
+ if (hdr->magic != MAGIC ||
+ hdr->begin < sizeof(struct stats_file_header) ||
+ hdr->end < sizeof(struct stats_file_header) ||
+ hdr->home < sizeof(struct stats_file_header) ||
+ hdr->roaming < sizeof(struct stats_file_header) ||
+ hdr->begin > file->len ||
+ hdr->end > file->len) {
+ hdr->magic = MAGIC;
+ hdr->begin = sizeof(struct stats_file_header);
+ hdr->end = sizeof(struct stats_file_header);
+ hdr->home = UINT_MAX;
+ hdr->roaming = UINT_MAX;
+
+ stats_file_update_cache(file);
+ }
+
+ return 0;
+}
+
+
+static struct stats_record *get_next_record(struct stats_iter *iter)
+{
+ if (iter->it != iter->end) {
+ struct stats_record *tmp;
+
+ tmp = iter->it;
+ iter->it = get_next(iter->file, iter->it);
+
+ return tmp;
+ }
+
+ return NULL;
+}
+
+static int append_record(struct stats_file *file,
+ struct stats_record *rec)
+{
+ struct stats_record *cur, *next;
+ int err;
+
+ if (file->last == get_end(file)) {
+ err = stats_file_remap(file, file->len +
+ sysconf(_SC_PAGESIZE));
+ if (err < 0)
+ return err;
+
+ stats_file_update_cache(file);
+ }
+
+ cur = get_end(file);
+ next = get_next(file, cur);
+
+ memcpy(next, rec, sizeof(struct stats_record));
+
+ set_end(file, next);
+
+ return 0;
+}
+
+static struct stats_record *process_file(struct stats_iter *iter,
+ struct stats_file *temp_file,
+ struct stats_record *cur,
+ GDate *date_change_step_size,
+ int account_period_offset)
+{
+ struct stats_record *home, *roaming;
+ struct stats_record *next;
+
+ home = NULL;
+ roaming = NULL;
+
+ if (!cur)
+ cur = get_next_record(iter);
+ next = get_next_record(iter);
+
+ while (next) {
+ GDate date_cur;
+ GDate date_next;
+ bool append;
+
+ append = false;
+
+ if (cur->roaming)
+ roaming = cur;
+ else
+ home = cur;
+
+ g_date_set_time_t(&date_cur, cur->ts);
+ g_date_set_time_t(&date_next, next->ts);
+
+ if (g_date_compare(&date_cur, date_change_step_size) < 0) {
+ /* month period size */
+ GDateDay day_cur, day_next;
+ GDateMonth month_cur, month_next;
+
+ month_cur = g_date_get_month(&date_cur);
+ month_next = g_date_get_month(&date_next);
+
+ day_cur = g_date_get_day(&date_cur);
+ day_next = g_date_get_day(&date_next);
+
+ if (day_cur == day_next && month_cur != month_next) {
+ append = true;
+ } else if (day_cur < account_period_offset &&
+ day_next >= account_period_offset) {
+ append = true;
+ }
+ } else {
+ /* day period size */
+ if (g_date_days_between(&date_cur, &date_next) > 0)
+ append = true;
+ }
+
+ if (append) {
+ if (home) {
+ append_record(temp_file, home);
+ home = NULL;
+ }
+
+ if (roaming) {
+ append_record(temp_file, roaming);
+ roaming = NULL;
+ }
+ }
+
+ cur = next;
+ next = get_next_record(iter);
+ }
+
+ return cur;
+}
+
+static int summarize(struct stats_file *data_file,
+ struct stats_file *history_file,
+ struct stats_file *temp_file)
+{
+ struct stats_iter data_iter;
+ struct stats_iter history_iter;
+ struct stats_record *cur, *next;
+
+ GDate today, date_change_step_size;
+
+ /*
+ * First calculate the date when switch from monthly
+ * accounting period size to daily size
+ */
+ g_date_set_time_t(&today, time(NULL));
+
+ date_change_step_size = today;
+ if (g_date_get_day(&today) - data_file->account_period_offset >= 0)
+ g_date_subtract_months(&date_change_step_size, 2);
+ else
+ g_date_subtract_months(&date_change_step_size, 3);
+
+ g_date_set_day(&date_change_step_size,
+ data_file->account_period_offset);
+
+
+ /* Now process history file */
+ cur = NULL;
+
+ if (history_file) {
+ history_iter.file = history_file;
+ history_iter.begin = get_iterator_begin(history_iter.file);
+ history_iter.end = get_iterator_end(history_iter.file);
+ history_iter.it = history_iter.begin;
+
+ cur = process_file(&history_iter, temp_file, NULL,
+ &date_change_step_size,
+ data_file->account_period_offset);
+ }
+
+ data_iter.file = data_file;
+ data_iter.begin = get_iterator_begin(data_iter.file);
+ data_iter.end = get_iterator_end(data_iter.file);
+ data_iter.it = data_iter.begin;
+
+ /*
+ * Ensure date_file records are newer than the history_file
+ * record
+ */
+ if (cur) {
+ next = get_next_record(&data_iter);
+ while (next && cur->ts > next->ts)
+ next = get_next_record(&data_iter);
+ }
+
+ /* And finally process the new data records */
+ cur = process_file(&data_iter, temp_file, cur,
+ &date_change_step_size,
+ data_file->account_period_offset);
+
+ if (cur)
+ append_record(temp_file, cur);
+
+ return 0;
+}
+
+static void stats_file_unmap(struct stats_file *file)
+{
+ msync(file->addr, file->len, MS_SYNC);
+ munmap(file->addr, file->len);
+ file->addr = NULL;
+}
+
+static void stats_file_cleanup(struct stats_file *file)
+{
+ file->fd = -1;
+ g_free(file->name);
+ file->name = NULL;
+}
+
+static int stats_file_close_swap(struct stats_file *history_file,
+ struct stats_file *temp_file)
+{
+ int err;
+
+ stats_file_unmap(history_file);
+ stats_file_unmap(temp_file);
+
+ TFR(close(temp_file->fd));
+
+ unlink(history_file->name);
+
+ err = link(temp_file->name, history_file->name);
+
+ unlink(temp_file->name);
+
+ TFR(close(history_file->fd));
+
+ stats_file_cleanup(history_file);
+ stats_file_cleanup(temp_file);
+
+ return err;
+}
+
+static int stats_file_history_update(struct stats_file *data_file)
+{
+ struct stats_file _history_file, *history_file;
+ struct stats_file _temp_file, *temp_file;
+ int err;
+
+ history_file = &_history_file;
+ temp_file = &_temp_file;
+
+ bzero(history_file, sizeof(struct stats_file));
+ bzero(temp_file, sizeof(struct stats_file));
+
+ err = stats_open(history_file, data_file->history_name);
+ if (err < 0)
+ return err;
+ stats_file_setup(history_file);
+
+ err = stats_open_temp(temp_file);
+ if (err < 0) {
+ stats_free(history_file);
+ return err;
+ }
+ stats_file_setup(temp_file);
+
+ summarize(data_file, history_file, temp_file);
+
+ err = stats_file_close_swap(history_file, temp_file);
+
+ return err;
+}
+
+int __connman_stats_service_register(struct connman_service *service)
+{
+ struct stats_file *file;
+ char *name, *dir;
+ int err;
+
+ DBG("service %p", service);
+
+ file = g_hash_table_lookup(stats_hash, service);
+ if (!file) {
+ file = g_try_new0(struct stats_file, 1);
+ if (!file)
+ return -ENOMEM;
+
+ g_hash_table_insert(stats_hash, service, file);
+ } else {
+ return -EALREADY;
+ }
+
+ dir = g_strdup_printf("%s/%s", STORAGEDIR,
+ __connman_service_get_ident(service));
+
+ /* If the dir doesn't exist, create it */
+ if (!g_file_test(dir, G_FILE_TEST_IS_DIR)) {
+ if (mkdir(dir, MODE) < 0) {
+ if (errno != EEXIST) {
+ g_free(dir);
+
+ err = -errno;
+ goto err;
+ }
+ }
+ }
+
+ g_free(dir);
+
+ name = g_strdup_printf("%s/%s/data", STORAGEDIR,
+ __connman_service_get_ident(service));
+ file->history_name = g_strdup_printf("%s/%s/history", STORAGEDIR,
+ __connman_service_get_ident(service));
+
+ /* TODO: Use a global config file instead of hard coded value. */
+ file->account_period_offset = 1;
+
+ err = stats_open(file, name);
+ g_free(name);
+ if (err < 0)
+ goto err;
+
+ err = stats_file_setup(file);
+ if (err < 0)
+ goto err;
+
+ return 0;
+
+err:
+ g_hash_table_remove(stats_hash, service);
+
+ return err;
+}
+
+void __connman_stats_service_unregister(struct connman_service *service)
+{
+ DBG("service %p", service);
+
+ g_hash_table_remove(stats_hash, service);
+}
+
+int __connman_stats_update(struct connman_service *service,
+ bool roaming,
+ struct connman_stats_data *data)
+{
+ struct stats_file *file;
+ struct stats_record *next;
+ int err;
+
+ file = g_hash_table_lookup(stats_hash, service);
+ if (!file)
+ return -EEXIST;
+
+ if (file->len < file->max_len &&
+ file->last == get_end(file)) {
+ DBG("grow file %s", file->name);
+
+ err = stats_file_remap(file, file->len + sysconf(_SC_PAGESIZE));
+ if (err < 0)
+ return err;
+ }
+
+ next = get_next(file, get_end(file));
+
+ if (next == get_begin(file)) {
+ DBG("ring buffer is full, update history file");
+
+ if (stats_file_history_update(file) < 0) {
+ connman_warn("history file update failed %s",
+ file->history_name);
+ }
+ }
+
+ next->ts = time(NULL);
+ next->roaming = roaming;
+ memcpy(&next->data, data, sizeof(struct connman_stats_data));
+
+ if (!roaming)
+ set_home(file, next);
+ else
+ set_roaming(file, next);
+
+ set_end(file, next);
+
+ return 0;
+}
+
+int __connman_stats_get(struct connman_service *service,
+ bool roaming,
+ struct connman_stats_data *data)
+{
+ struct stats_file *file;
+ struct stats_record *rec;
+
+ file = g_hash_table_lookup(stats_hash, service);
+ if (!file)
+ return -EEXIST;
+
+ if (!roaming)
+ rec = file->home;
+ else
+ rec = file->roaming;
+
+ if (rec) {
+ memcpy(data, &rec->data,
+ sizeof(struct connman_stats_data));
+ }
+
+ return 0;
+}
+
+int __connman_stats_init(void)
+{
+ DBG("");
+
+ stats_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, stats_free);
+
+ return 0;
+}
+
+void __connman_stats_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(stats_hash);
+ stats_hash = NULL;
+}
diff --git a/src/storage.c b/src/storage.c
new file mode 100644
index 0000000..7d03130
--- /dev/null
+++ b/src/storage.c
@@ -0,0 +1,478 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <dirent.h>
+
+#include <connman/storage.h>
+
+#include "connman.h"
+
+#define SETTINGS "settings"
+#define DEFAULT "default.profile"
+
+#define MODE (S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | \
+ S_IXGRP | S_IROTH | S_IXOTH)
+
+static GKeyFile *storage_load(const char *pathname)
+{
+ GKeyFile *keyfile = NULL;
+ GError *error = NULL;
+
+ DBG("Loading %s", pathname);
+
+ keyfile = g_key_file_new();
+
+ if (!g_key_file_load_from_file(keyfile, pathname, 0, &error)) {
+ DBG("Unable to load %s: %s", pathname, error->message);
+ g_clear_error(&error);
+
+ g_key_file_free(keyfile);
+ keyfile = NULL;
+ }
+
+ return keyfile;
+}
+
+static int storage_save(GKeyFile *keyfile, char *pathname)
+{
+ gchar *data = NULL;
+ gsize length = 0;
+ GError *error = NULL;
+ int ret = 0;
+
+ data = g_key_file_to_data(keyfile, &length, NULL);
+
+ if (!g_file_set_contents(pathname, data, length, &error)) {
+ DBG("Failed to store information: %s", error->message);
+ g_error_free(error);
+ ret = -EIO;
+ }
+
+ g_free(data);
+
+ return ret;
+}
+
+static void storage_delete(const char *pathname)
+{
+ DBG("file path %s", pathname);
+
+ if (unlink(pathname) < 0)
+ connman_error("Failed to remove %s", pathname);
+}
+
+GKeyFile *__connman_storage_load_global(void)
+{
+ gchar *pathname;
+ GKeyFile *keyfile = NULL;
+
+ pathname = g_strdup_printf("%s/%s", STORAGEDIR, SETTINGS);
+ if (!pathname)
+ return NULL;
+
+ keyfile = storage_load(pathname);
+
+ g_free(pathname);
+
+ return keyfile;
+}
+
+int __connman_storage_save_global(GKeyFile *keyfile)
+{
+ gchar *pathname;
+ int ret;
+
+ pathname = g_strdup_printf("%s/%s", STORAGEDIR, SETTINGS);
+ if (!pathname)
+ return -ENOMEM;
+
+ ret = storage_save(keyfile, pathname);
+
+ g_free(pathname);
+
+ return ret;
+}
+
+void __connman_storage_delete_global(void)
+{
+ gchar *pathname;
+
+ pathname = g_strdup_printf("%s/%s", STORAGEDIR, SETTINGS);
+ if (!pathname)
+ return;
+
+ storage_delete(pathname);
+
+ g_free(pathname);
+}
+
+GKeyFile *__connman_storage_load_config(const char *ident)
+{
+ gchar *pathname;
+ GKeyFile *keyfile = NULL;
+
+ pathname = g_strdup_printf("%s/%s.config", STORAGEDIR, ident);
+ if (!pathname)
+ return NULL;
+
+ keyfile = storage_load(pathname);
+
+ g_free(pathname);
+
+ return keyfile;
+}
+
+GKeyFile *__connman_storage_load_provider_config(const char *ident)
+{
+ gchar *pathname;
+ GKeyFile *keyfile = NULL;
+
+ pathname = g_strdup_printf("%s/%s.config", VPN_STORAGEDIR, ident);
+ if (!pathname)
+ return NULL;
+
+ keyfile = storage_load(pathname);
+
+ g_free(pathname);
+
+ return keyfile;
+}
+
+GKeyFile *__connman_storage_open_service(const char *service_id)
+{
+ gchar *pathname;
+ GKeyFile *keyfile = NULL;
+
+ pathname = g_strdup_printf("%s/%s/%s", STORAGEDIR, service_id, SETTINGS);
+ if (!pathname)
+ return NULL;
+
+ keyfile = storage_load(pathname);
+ if (keyfile) {
+ g_free(pathname);
+ return keyfile;
+ }
+
+ g_free(pathname);
+
+ keyfile = g_key_file_new();
+
+ return keyfile;
+}
+
+gchar **connman_storage_get_services(void)
+{
+ struct dirent *d;
+ gchar *str;
+ DIR *dir;
+ GString *result;
+ gchar **services = NULL;
+ struct stat buf;
+ int ret;
+
+ dir = opendir(STORAGEDIR);
+ if (!dir)
+ return NULL;
+
+ result = g_string_new(NULL);
+
+ while ((d = readdir(dir))) {
+ if (strcmp(d->d_name, ".") == 0 ||
+ strcmp(d->d_name, "..") == 0 ||
+ strncmp(d->d_name, "provider_", 9) == 0)
+ continue;
+
+ switch (d->d_type) {
+ case DT_DIR:
+ case DT_UNKNOWN:
+ /*
+ * If the settings file is not found, then
+ * assume this directory is not a services dir.
+ */
+ str = g_strdup_printf("%s/%s/settings", STORAGEDIR,
+ d->d_name);
+ ret = stat(str, &buf);
+ g_free(str);
+ if (ret < 0)
+ continue;
+
+ g_string_append_printf(result, "%s/", d->d_name);
+ break;
+ }
+ }
+
+ closedir(dir);
+
+ str = g_string_free(result, FALSE);
+ if (str && str[0] != '\0') {
+ /*
+ * Remove the trailing separator so that services doesn't end up
+ * with an empty element.
+ */
+ str[strlen(str) - 1] = '\0';
+ services = g_strsplit(str, "/", -1);
+ }
+ g_free(str);
+
+ return services;
+}
+
+GKeyFile *connman_storage_load_service(const char *service_id)
+{
+ gchar *pathname;
+ GKeyFile *keyfile = NULL;
+
+ pathname = g_strdup_printf("%s/%s/%s", STORAGEDIR, service_id, SETTINGS);
+ if (!pathname)
+ return NULL;
+
+ keyfile = storage_load(pathname);
+ g_free(pathname);
+
+ return keyfile;
+}
+
+int __connman_storage_save_service(GKeyFile *keyfile, const char *service_id)
+{
+ int ret = 0;
+ gchar *pathname, *dirname;
+
+ dirname = g_strdup_printf("%s/%s", STORAGEDIR, service_id);
+ if (!dirname)
+ return -ENOMEM;
+
+ /* If the dir doesn't exist, create it */
+ if (!g_file_test(dirname, G_FILE_TEST_IS_DIR)) {
+ if (mkdir(dirname, MODE) < 0) {
+ if (errno != EEXIST) {
+ g_free(dirname);
+ return -errno;
+ }
+ }
+ }
+
+ pathname = g_strdup_printf("%s/%s", dirname, SETTINGS);
+
+ g_free(dirname);
+
+ ret = storage_save(keyfile, pathname);
+
+ g_free(pathname);
+
+ return ret;
+}
+
+static bool remove_file(const char *service_id, const char *file)
+{
+ gchar *pathname;
+ bool ret = false;
+
+ pathname = g_strdup_printf("%s/%s/%s", STORAGEDIR, service_id, file);
+ if (!pathname)
+ return false;
+
+ if (!g_file_test(pathname, G_FILE_TEST_EXISTS)) {
+ ret = true;
+ } else if (g_file_test(pathname, G_FILE_TEST_IS_REGULAR)) {
+ unlink(pathname);
+ ret = true;
+ }
+
+ g_free(pathname);
+ return ret;
+}
+
+static bool remove_dir(const char *service_id)
+{
+ gchar *pathname;
+ bool ret = false;
+
+ pathname = g_strdup_printf("%s/%s", STORAGEDIR, service_id);
+ if (!pathname)
+ return false;
+
+ if (!g_file_test(pathname, G_FILE_TEST_EXISTS)) {
+ ret = true;
+ } else if (g_file_test(pathname, G_FILE_TEST_IS_DIR)) {
+ rmdir(pathname);
+ ret = true;
+ }
+
+ g_free(pathname);
+ return ret;
+}
+
+bool __connman_storage_remove_service(const char *service_id)
+{
+ bool removed;
+
+ /* Remove service configuration file */
+ removed = remove_file(service_id, SETTINGS);
+ if (!removed)
+ return false;
+
+ /* Remove the statistics file also */
+ removed = remove_file(service_id, "data");
+ if (!removed)
+ return false;
+
+ removed = remove_dir(service_id);
+ if (!removed)
+ return false;
+
+ DBG("Removed service dir %s/%s", STORAGEDIR, service_id);
+
+ return true;
+}
+
+GKeyFile *__connman_storage_load_provider(const char *identifier)
+{
+ gchar *pathname;
+ GKeyFile *keyfile;
+
+ pathname = g_strdup_printf("%s/%s_%s/%s", STORAGEDIR, "provider",
+ identifier, SETTINGS);
+ if (!pathname)
+ return NULL;
+
+ keyfile = storage_load(pathname);
+ g_free(pathname);
+
+ return keyfile;
+}
+
+void __connman_storage_save_provider(GKeyFile *keyfile, const char *identifier)
+{
+ gchar *pathname, *dirname;
+
+ dirname = g_strdup_printf("%s/%s_%s", STORAGEDIR,
+ "provider", identifier);
+ if (!dirname)
+ return;
+
+ if (!g_file_test(dirname, G_FILE_TEST_IS_DIR) &&
+ mkdir(dirname, MODE) < 0) {
+ g_free(dirname);
+ return;
+ }
+
+ pathname = g_strdup_printf("%s/%s", dirname, SETTINGS);
+ g_free(dirname);
+
+ storage_save(keyfile, pathname);
+ g_free(pathname);
+}
+
+static bool remove_all(const char *id)
+{
+ bool removed;
+
+ remove_file(id, SETTINGS);
+ remove_file(id, "data");
+
+ removed = remove_dir(id);
+ if (!removed)
+ return false;
+
+ return true;
+}
+
+bool __connman_storage_remove_provider(const char *identifier)
+{
+ bool removed;
+ gchar *id;
+
+ id = g_strdup_printf("%s_%s", "provider", identifier);
+ if (!id)
+ return false;
+
+ if (remove_all(id))
+ DBG("Removed provider dir %s/%s", STORAGEDIR, id);
+
+ g_free(id);
+
+ id = g_strdup_printf("%s_%s", "vpn", identifier);
+ if (!id)
+ return false;
+
+ if ((removed = remove_all(id)))
+ DBG("Removed vpn dir %s/%s", STORAGEDIR, id);
+
+ g_free(id);
+
+ return removed;
+}
+
+gchar **__connman_storage_get_providers(void)
+{
+ GSList *list = NULL;
+ int num = 0, i = 0;
+ struct dirent *d;
+ gchar *str;
+ DIR *dir;
+ struct stat buf;
+ int ret;
+ char **providers;
+ GSList *iter;
+
+ dir = opendir(STORAGEDIR);
+ if (!dir)
+ return NULL;
+
+ while ((d = readdir(dir))) {
+ if (strcmp(d->d_name, ".") == 0 ||
+ strcmp(d->d_name, "..") == 0 ||
+ strncmp(d->d_name, "provider_", 9) != 0)
+ continue;
+
+ if (d->d_type == DT_DIR) {
+ str = g_strdup_printf("%s/%s/settings", STORAGEDIR,
+ d->d_name);
+ ret = stat(str, &buf);
+ g_free(str);
+ if (ret < 0)
+ continue;
+ list = g_slist_prepend(list, g_strdup(d->d_name));
+ num += 1;
+ }
+ }
+
+ closedir(dir);
+
+ providers = g_try_new0(char *, num + 1);
+ for (iter = list; iter; iter = g_slist_next(iter)) {
+ if (providers)
+ providers[i] = iter->data;
+ else
+ g_free(iter->data);
+ i += 1;
+ }
+ g_slist_free(list);
+
+ return providers;
+}
diff --git a/src/task.c b/src/task.c
new file mode 100644
index 0000000..8b9e1d9
--- /dev/null
+++ b/src/task.c
@@ -0,0 +1,498 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <unistd.h>
+#include <stdarg.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+#include <glib.h>
+
+#include "connman.h"
+
+struct notify_data {
+ connman_task_notify_t func;
+ void *data;
+};
+
+struct connman_task {
+ char *path;
+ pid_t pid;
+ guint child_watch;
+ GPtrArray *argv;
+ GPtrArray *envp;
+ connman_task_exit_t exit_func;
+ void *exit_data;
+ GHashTable *notify;
+};
+
+static GHashTable *task_hash = NULL;
+
+static volatile int task_counter;
+
+static DBusConnection *connection;
+
+static void free_pointer(gpointer data, gpointer user_data)
+{
+ g_free(data);
+}
+
+static void free_task(gpointer data)
+{
+ struct connman_task *task = data;
+
+ DBG("task %p", task);
+
+ g_hash_table_destroy(task->notify);
+ task->notify = NULL;
+
+ if (task->pid > 0)
+ kill(task->pid, SIGTERM);
+
+ if (task->child_watch > 0)
+ g_source_remove(task->child_watch);
+
+ g_ptr_array_foreach(task->envp, free_pointer, NULL);
+ g_ptr_array_free(task->envp, TRUE);
+
+ g_ptr_array_foreach(task->argv, free_pointer, NULL);
+ g_ptr_array_free(task->argv, TRUE);
+
+ g_free(task->path);
+ g_free(task);
+}
+
+/**
+ * connman_task_create:
+ * @program: name of executable
+ *
+ * Allocate a new task of given #program
+ *
+ * Returns: a newly-allocated #connman_task structure
+ */
+struct connman_task *connman_task_create(const char *program)
+{
+ struct connman_task *task;
+ gint counter;
+ char *str;
+
+ DBG("");
+
+ task = g_try_new0(struct connman_task, 1);
+ if (!task)
+ return NULL;
+
+ counter = __sync_fetch_and_add(&task_counter, 1);
+
+ task->path = g_strdup_printf("/task/%d", counter);
+ task->pid = -1;
+
+ task->argv = g_ptr_array_new();
+ task->envp = g_ptr_array_new();
+
+ str = g_strdup(program);
+ g_ptr_array_add(task->argv, str);
+
+ task->notify = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+
+ DBG("task %p", task);
+
+ g_hash_table_insert(task_hash, task->path, task);
+
+ return task;
+}
+
+/**
+ * connman_task_destory:
+ * @task: task structure
+ *
+ * Remove and destory #task
+ */
+void connman_task_destroy(struct connman_task *task)
+{
+ DBG("task %p", task);
+
+ g_hash_table_remove(task_hash, task->path);
+}
+
+/**
+ * connman_task_get_path:
+ * @task: task structure
+ *
+ * Get object path
+ */
+const char *connman_task_get_path(struct connman_task *task)
+{
+ return task->path;
+}
+
+/**
+ * connman_task_add_argument:
+ * @task: task structure
+ * @name: argument name
+ * @format: format string
+ * @Varargs: list of arguments
+ *
+ * Add a new command line argument
+ */
+int connman_task_add_argument(struct connman_task *task,
+ const char *name, const char *format, ...)
+{
+ va_list ap;
+ char *str;
+
+ DBG("task %p arg %s", task, name);
+
+ if (!name)
+ return -EINVAL;
+
+ str = g_strdup(name);
+ g_ptr_array_add(task->argv, str);
+
+ va_start(ap, format);
+
+ if (format) {
+ str = g_strdup_vprintf(format, ap);
+ g_ptr_array_add(task->argv, str);
+ }
+
+ va_end(ap);
+
+ return 0;
+}
+
+/**
+ * connman_task_add_variable:
+ * @task: task structure
+ * @key: variable name
+ * @format: format string
+ * @Varargs: list of arguments
+ *
+ * Add a new environment variable
+ */
+int connman_task_add_variable(struct connman_task *task,
+ const char *key, const char *format, ...)
+{
+ va_list ap;
+ char *str, *val;
+
+ DBG("task %p key %s", task, key);
+
+ if (!key)
+ return -EINVAL;
+
+ va_start(ap, format);
+
+ val = g_strdup_vprintf(format, ap);
+ str = g_strdup_printf("%s=%s", key, format ? format : "");
+ g_ptr_array_add(task->envp, str);
+ g_free(val);
+
+ va_end(ap);
+
+ return 0;
+}
+
+/**
+ * connman_task_set_notify:
+ * @task: task structure
+ * @member: notifcation method name
+ * @function: notification callback
+ * @user_data: optional notification user data
+ *
+ * Set notification handler for #member
+ */
+int connman_task_set_notify(struct connman_task *task, const char *member,
+ connman_task_notify_t function, void *user_data)
+{
+ struct notify_data *notify;
+
+ DBG("task %p", task);
+
+ notify = g_try_new0(struct notify_data, 1);
+ if (!notify)
+ return -ENOMEM;
+
+ notify->func = function;
+ notify->data = user_data;
+
+ g_hash_table_replace(task->notify, g_strdup(member), notify);
+
+ return 0;
+}
+
+static void task_died(GPid pid, gint status, gpointer user_data)
+{
+ struct connman_task *task = user_data;
+ int exit_code;
+
+ if (WIFEXITED(status)) {
+ exit_code = WEXITSTATUS(status);
+ DBG("task %p exit status %d", task, exit_code);
+ } else {
+ exit_code = 0;
+ DBG("task %p signal %d", task, WTERMSIG(status));
+ }
+
+ g_spawn_close_pid(pid);
+ task->pid = -1;
+
+ task->child_watch = 0;
+
+ if (task->exit_func)
+ task->exit_func(task, exit_code, task->exit_data);
+}
+
+static void task_setup(gpointer user_data)
+{
+ sigset_t mask;
+ struct connman_task *task = user_data;
+
+ DBG("task %p", task);
+
+ sigemptyset(&mask);
+ if (sigprocmask(SIG_SETMASK, &mask, NULL) < 0)
+ connman_error("Failed to clean signal mask");
+}
+
+/**
+ * connman_task_run:
+ * @task: task structure
+ * @function: exit callback
+ * @user_data: optional exit user data
+ * @fd: optional spawn with pipe
+ *
+ * Execute program specified by #task
+ */
+int connman_task_run(struct connman_task *task,
+ connman_task_exit_t function, void *user_data,
+ int *stdin_fd, int *stdout_fd, int *stderr_fd)
+{
+ GSpawnFlags flags = G_SPAWN_DO_NOT_REAP_CHILD;
+ bool result;
+ char **argv, **envp;
+
+ DBG("task %p", task);
+
+ if (task->pid > 0)
+ return -EALREADY;
+
+ if (!stdout_fd)
+ flags |= G_SPAWN_STDOUT_TO_DEV_NULL;
+
+ if (!stderr_fd)
+ flags |= G_SPAWN_STDERR_TO_DEV_NULL;
+
+ task->exit_func = function;
+ task->exit_data = user_data;
+
+ if (g_ptr_array_index(task->argv, task->argv->len - 1))
+ g_ptr_array_add(task->argv, NULL);
+
+ if (task->envp->len == 0 ||
+ g_ptr_array_index(task->envp, task->envp->len - 1)) {
+ if (g_hash_table_size(task->notify) > 0) {
+ const char *busname;
+ char *str;
+
+ busname = dbus_bus_get_unique_name(connection);
+ str = g_strdup_printf("CONNMAN_BUSNAME=%s", busname);
+ g_ptr_array_add(task->envp, str);
+
+ str = g_strdup_printf("CONNMAN_INTERFACE=%s",
+ CONNMAN_TASK_INTERFACE);
+ g_ptr_array_add(task->envp, str);
+
+ str = g_strdup_printf("CONNMAN_PATH=%s", task->path);
+ g_ptr_array_add(task->envp, str);
+ }
+
+ g_ptr_array_add(task->envp, NULL);
+ }
+
+ argv = (char **) task->argv->pdata;
+ envp = (char **) task->envp->pdata;
+
+ result = g_spawn_async_with_pipes(NULL, argv, envp, flags,
+ task_setup, task, &task->pid,
+ stdin_fd, stdout_fd, stderr_fd, NULL);
+ if (!result) {
+ connman_error("Failed to spawn %s", argv[0]);
+ return -EIO;
+ }
+
+ task->child_watch = g_child_watch_add(task->pid, task_died, task);
+
+ return 0;
+}
+
+static gboolean force_kill_timeout(gpointer user_data)
+{
+ pid_t pid = GPOINTER_TO_INT(user_data);
+ if (pid > 0) {
+ if (kill(pid, SIGKILL) == 0)
+ connman_warn("killing pid %d by force", pid);
+ }
+
+ return FALSE;
+}
+
+static gboolean kill_timeout(gpointer user_data)
+{
+ pid_t pid = GPOINTER_TO_INT(user_data);
+ if (pid > 0) {
+ if (kill(pid, SIGINT) == 0)
+ g_timeout_add_seconds(1, force_kill_timeout,
+ GINT_TO_POINTER(pid));
+ }
+
+ return FALSE;
+}
+
+static gboolean check_kill(gpointer user_data)
+{
+ pid_t pid = GPOINTER_TO_INT(user_data);
+ if (pid > 0) {
+ if (kill(pid, 0) == 0) {
+ connman_info("pid %d was not killed, "
+ "retrying after 2 sec", pid);
+ g_timeout_add_seconds(2, kill_timeout,
+ GINT_TO_POINTER(pid));
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * connman_task_stop:
+ * @task: task structure
+ *
+ * Stop program specified by #task
+ */
+int connman_task_stop(struct connman_task *task)
+{
+ DBG("task %p", task);
+
+ if (task->pid > 0) {
+ kill(task->pid, SIGTERM);
+
+ g_timeout_add_seconds(0, check_kill,
+ GINT_TO_POINTER(task->pid));
+ }
+
+ return 0;
+}
+
+static DBusHandlerResult task_filter(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ struct connman_task *task;
+ struct notify_data *notify;
+ const char *path, *member;
+ DBusMessage *reply = NULL;
+
+ if (dbus_message_get_type(message) != DBUS_MESSAGE_TYPE_METHOD_CALL)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (!dbus_message_has_interface(message, CONNMAN_TASK_INTERFACE))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ path = dbus_message_get_path(message);
+ if (!path)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ task = g_hash_table_lookup(task_hash, path);
+ if (!task)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ member = dbus_message_get_member(message);
+ if (!member)
+ goto send_reply;
+
+ notify = g_hash_table_lookup(task->notify, member);
+ if (!notify)
+ goto send_reply;
+
+ if (notify->func)
+ reply = notify->func(task, message, notify->data);
+
+send_reply:
+ if (!dbus_message_get_no_reply(message) &&
+ !reply) {
+
+ reply = dbus_message_new_method_return(message);
+ if (!reply)
+ return DBUS_HANDLER_RESULT_NEED_MEMORY;
+ }
+
+ if (reply) {
+ dbus_connection_send(conn, reply, NULL);
+
+ dbus_message_unref(reply);
+ }
+
+ return DBUS_HANDLER_RESULT_HANDLED;
+}
+
+static const char *task_rule = "type=method_call"
+ ",interface=" CONNMAN_TASK_INTERFACE;
+
+int __connman_task_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+
+ dbus_connection_add_filter(connection, task_filter, NULL, NULL);
+
+ task_counter = 0;
+ __sync_synchronize();
+
+ task_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, free_task);
+
+ dbus_bus_add_match(connection, task_rule, NULL);
+ dbus_connection_flush(connection);
+
+ return 0;
+}
+
+void __connman_task_cleanup(void)
+{
+ DBG("");
+
+ dbus_bus_remove_match(connection, task_rule, NULL);
+ dbus_connection_flush(connection);
+
+ g_hash_table_destroy(task_hash);
+ task_hash = NULL;
+
+ dbus_connection_remove_filter(connection, task_filter, NULL);
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/technology.c b/src/technology.c
new file mode 100644
index 0000000..56f1777
--- /dev/null
+++ b/src/technology.c
@@ -0,0 +1,1850 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+
+#include <gdbus.h>
+
+#include "connman.h"
+
+static DBusConnection *connection;
+
+static GSList *technology_list = NULL;
+
+/*
+ * List of devices with no technology associated with them either because of
+ * no compiled in support or the driver is not yet loaded.
+*/
+static GSList *techless_device_list = NULL;
+static GHashTable *rfkill_list;
+
+static bool global_offlinemode;
+
+struct connman_rfkill {
+ unsigned int index;
+ enum connman_service_type type;
+ bool softblock;
+ bool hardblock;
+};
+
+struct connman_technology {
+ int refcount;
+ enum connman_service_type type;
+ char *path;
+ GSList *device_list;
+ bool enabled;
+ char *regdom;
+ bool connected;
+
+ bool tethering;
+ bool tethering_persistent; /* Tells the save status, needed
+ * as offline mode might set
+ * tethering OFF.
+ */
+ char *tethering_ident;
+ char *tethering_passphrase;
+
+ bool enable_persistent; /* Save the tech state */
+
+ GSList *driver_list;
+
+ DBusMessage *pending_reply;
+ guint pending_timeout;
+
+ GSList *scan_pending;
+
+ bool rfkill_driven;
+ bool softblocked;
+ bool hardblocked;
+ bool dbus_registered;
+};
+
+static GSList *driver_list = NULL;
+
+static int technology_enabled(struct connman_technology *technology);
+static int technology_disabled(struct connman_technology *technology);
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_technology_driver *driver1 = a;
+ const struct connman_technology_driver *driver2 = b;
+
+ return driver2->priority - driver1->priority;
+}
+
+static void rfkill_check(gpointer key, gpointer value, gpointer user_data)
+{
+ struct connman_rfkill *rfkill = value;
+ enum connman_service_type type = GPOINTER_TO_INT(user_data);
+
+ /* Calling _technology_rfkill_add will update the tech. */
+ if (rfkill->type == type)
+ __connman_technology_add_rfkill(rfkill->index, type,
+ rfkill->softblock, rfkill->hardblock);
+}
+
+bool
+connman_technology_is_tethering_allowed(enum connman_service_type type)
+{
+ static char *allowed_default[] = { "wifi", "bluetooth", "gadget",
+ NULL };
+ const char *type_str = __connman_service_type2string(type);
+ char **allowed;
+ int i;
+
+ if (!type_str)
+ return false;
+
+ allowed = connman_setting_get_string_list("TetheringTechnologies");
+ if (!allowed)
+ allowed = allowed_default;
+
+ for (i = 0; allowed[i]; i++) {
+ if (g_strcmp0(allowed[i], type_str) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+static const char *get_name(enum connman_service_type type)
+{
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ break;
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ return "Gadget";
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ return "Wired";
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ return "WiFi";
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ return "Bluetooth";
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ return "Cellular";
+ case CONNMAN_SERVICE_TYPE_P2P:
+ return "P2P";
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ return "Thread";
+ }
+
+ return NULL;
+}
+
+static void technology_save(struct connman_technology *technology)
+{
+ GKeyFile *keyfile;
+ gchar *identifier;
+ const char *name = get_name(technology->type);
+
+ DBG("technology %p type %d name %s", technology, technology->type,
+ name);
+ if (!name)
+ return;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ keyfile = g_key_file_new();
+
+ identifier = g_strdup_printf("%s", name);
+ if (!identifier)
+ goto done;
+
+ g_key_file_set_boolean(keyfile, identifier, "Enable",
+ technology->enable_persistent);
+
+ g_key_file_set_boolean(keyfile, identifier, "Tethering",
+ technology->tethering_persistent);
+
+ if (technology->tethering_ident)
+ g_key_file_set_string(keyfile, identifier,
+ "Tethering.Identifier",
+ technology->tethering_ident);
+
+ if (technology->tethering_passphrase)
+ g_key_file_set_string(keyfile, identifier,
+ "Tethering.Passphrase",
+ technology->tethering_passphrase);
+
+done:
+ g_free(identifier);
+
+ __connman_storage_save_global(keyfile);
+
+ g_key_file_free(keyfile);
+
+ return;
+}
+
+static void tethering_changed(struct connman_technology *technology)
+{
+ dbus_bool_t tethering = technology->tethering;
+
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE, "Tethering",
+ DBUS_TYPE_BOOLEAN, &tethering);
+
+ technology_save(technology);
+}
+
+void connman_technology_tethering_notify(struct connman_technology *technology,
+ bool enabled)
+{
+ DBG("technology %p enabled %u", technology, enabled);
+
+ if (technology->tethering == enabled)
+ return;
+
+ technology->tethering = enabled;
+
+ tethering_changed(technology);
+
+ if (enabled)
+ __connman_tethering_set_enabled();
+ else
+ __connman_tethering_set_disabled();
+}
+
+static int set_tethering(struct connman_technology *technology,
+ bool enabled)
+{
+ int result = -EOPNOTSUPP;
+ int err;
+ const char *ident, *passphrase, *bridge;
+ GSList *tech_drivers;
+
+ ident = technology->tethering_ident;
+ passphrase = technology->tethering_passphrase;
+
+ __sync_synchronize();
+ if (!technology->enabled)
+ return -EACCES;
+
+ bridge = __connman_tethering_get_bridge();
+ if (!bridge)
+ return -EOPNOTSUPP;
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI &&
+ (!ident || !passphrase))
+ return -EINVAL;
+
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ struct connman_technology_driver *driver = tech_drivers->data;
+
+ if (!driver || !driver->set_tethering)
+ continue;
+
+ err = driver->set_tethering(technology, ident, passphrase,
+ bridge, enabled);
+
+ if (result == -EINPROGRESS)
+ continue;
+
+ if (err == -EINPROGRESS || err == 0) {
+ result = err;
+ continue;
+ }
+ }
+
+ return result;
+}
+
+void connman_technology_regdom_notify(struct connman_technology *technology,
+ const char *alpha2)
+{
+ DBG("");
+
+ if (!alpha2)
+ connman_error("Failed to set regulatory domain");
+ else
+ DBG("Regulatory domain set to %s", alpha2);
+
+ g_free(technology->regdom);
+ technology->regdom = g_strdup(alpha2);
+}
+
+static int set_regdom_by_device(struct connman_technology *technology,
+ const char *alpha2)
+{
+ GSList *list;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (connman_device_set_regdom(device, alpha2) != 0)
+ return -ENOTSUP;
+ }
+
+ return 0;
+}
+
+int connman_technology_set_regdom(const char *alpha2)
+{
+ GSList *list, *tech_drivers;
+
+ for (list = technology_list; list; list = list->next) {
+ struct connman_technology *technology = list->data;
+
+ if (set_regdom_by_device(technology, alpha2) != 0) {
+
+ for (tech_drivers = technology->driver_list;
+ tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+
+ struct connman_technology_driver *driver =
+ tech_drivers->data;
+
+ if (driver->set_regdom)
+ driver->set_regdom(technology, alpha2);
+ }
+ }
+ }
+
+ return 0;
+}
+
+static struct connman_technology *technology_find(enum connman_service_type type)
+{
+ GSList *list;
+
+ DBG("type %d", type);
+
+ for (list = technology_list; list; list = list->next) {
+ struct connman_technology *technology = list->data;
+
+ if (technology->type == type)
+ return technology;
+ }
+
+ return NULL;
+}
+
+bool connman_technology_get_wifi_tethering(const char **ssid,
+ const char **psk)
+{
+ struct connman_technology *technology;
+
+ if (!ssid || !psk)
+ return false;
+
+ *ssid = *psk = NULL;
+
+ technology = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (!technology)
+ return false;
+
+ if (!technology->tethering)
+ return false;
+
+ *ssid = technology->tethering_ident;
+ *psk = technology->tethering_passphrase;
+
+ return true;
+}
+
+static void free_rfkill(gpointer data)
+{
+ struct connman_rfkill *rfkill = data;
+
+ g_free(rfkill);
+}
+
+static void technology_load(struct connman_technology *technology)
+{
+ GKeyFile *keyfile;
+ gchar *identifier;
+ GError *error = NULL;
+ bool enable, need_saving = false;
+
+ DBG("technology %p", technology);
+
+ keyfile = __connman_storage_load_global();
+ /* Fallback on disabling technology if file not found. */
+ if (!keyfile) {
+ if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
+ /* We enable ethernet by default */
+ technology->enable_persistent = true;
+ else
+ technology->enable_persistent = false;
+ return;
+ }
+
+ identifier = g_strdup_printf("%s", get_name(technology->type));
+ if (!identifier)
+ goto done;
+
+ enable = g_key_file_get_boolean(keyfile, identifier, "Enable", &error);
+ if (!error)
+ technology->enable_persistent = enable;
+ else {
+ if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
+ technology->enable_persistent = true;
+ else
+ technology->enable_persistent = false;
+
+ need_saving = true;
+ g_clear_error(&error);
+ }
+
+ enable = g_key_file_get_boolean(keyfile, identifier,
+ "Tethering", &error);
+ if (!error)
+ technology->tethering_persistent = enable;
+ else {
+ need_saving = true;
+ g_clear_error(&error);
+ }
+
+ if (need_saving)
+ technology_save(technology);
+
+ technology->tethering_ident = g_key_file_get_string(keyfile,
+ identifier, "Tethering.Identifier", NULL);
+
+ technology->tethering_passphrase = g_key_file_get_string(keyfile,
+ identifier, "Tethering.Passphrase", NULL);
+done:
+ g_free(identifier);
+
+ g_key_file_free(keyfile);
+
+ return;
+}
+
+bool __connman_technology_get_offlinemode(void)
+{
+ return global_offlinemode;
+}
+
+static void connman_technology_save_offlinemode(void)
+{
+ GKeyFile *keyfile;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ keyfile = g_key_file_new();
+
+ g_key_file_set_boolean(keyfile, "global",
+ "OfflineMode", global_offlinemode);
+
+ __connman_storage_save_global(keyfile);
+
+ g_key_file_free(keyfile);
+
+ return;
+}
+
+static bool connman_technology_load_offlinemode(void)
+{
+ GKeyFile *keyfile;
+ GError *error = NULL;
+ bool offlinemode;
+
+ /* If there is a error, we enable offlinemode */
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ return false;
+
+ offlinemode = g_key_file_get_boolean(keyfile, "global",
+ "OfflineMode", &error);
+ if (error) {
+ offlinemode = false;
+ g_clear_error(&error);
+ }
+
+ g_key_file_free(keyfile);
+
+ return offlinemode;
+}
+
+static void append_properties(DBusMessageIter *iter,
+ struct connman_technology *technology)
+{
+ DBusMessageIter dict;
+ dbus_bool_t val;
+ const char *str;
+
+ connman_dbus_dict_open(iter, &dict);
+
+ str = get_name(technology->type);
+ if (str)
+ connman_dbus_dict_append_basic(&dict, "Name",
+ DBUS_TYPE_STRING, &str);
+
+ str = __connman_service_type2string(technology->type);
+ if (str)
+ connman_dbus_dict_append_basic(&dict, "Type",
+ DBUS_TYPE_STRING, &str);
+
+ __sync_synchronize();
+ val = technology->enabled;
+ connman_dbus_dict_append_basic(&dict, "Powered",
+ DBUS_TYPE_BOOLEAN,
+ &val);
+
+ val = technology->connected;
+ connman_dbus_dict_append_basic(&dict, "Connected",
+ DBUS_TYPE_BOOLEAN,
+ &val);
+
+ val = technology->tethering;
+ connman_dbus_dict_append_basic(&dict, "Tethering",
+ DBUS_TYPE_BOOLEAN,
+ &val);
+
+ if (technology->tethering_ident)
+ connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
+ DBUS_TYPE_STRING,
+ &technology->tethering_ident);
+
+ if (technology->tethering_passphrase)
+ connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
+ DBUS_TYPE_STRING,
+ &technology->tethering_passphrase);
+
+ connman_dbus_dict_close(iter, &dict);
+}
+
+static void technology_added_signal(struct connman_technology *technology)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "TechnologyAdded");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
+ &technology->path);
+ append_properties(&iter, technology);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+}
+
+static void technology_removed_signal(struct connman_technology *technology)
+{
+ g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "TechnologyRemoved",
+ DBUS_TYPE_OBJECT_PATH, &technology->path,
+ DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *get_properties(DBusConnection *conn,
+ DBusMessage *message, void *user_data)
+{
+ struct connman_technology *technology = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+
+ reply = dbus_message_new_method_return(message);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+ append_properties(&iter, technology);
+
+ return reply;
+}
+
+void __connman_technology_list_struct(DBusMessageIter *array)
+{
+ GSList *list;
+ DBusMessageIter entry;
+
+ for (list = technology_list; list; list = list->next) {
+ struct connman_technology *technology = list->data;
+
+ if (!technology->path ||
+ (technology->rfkill_driven &&
+ technology->hardblocked))
+ continue;
+
+ dbus_message_iter_open_container(array, DBUS_TYPE_STRUCT,
+ NULL, &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+ &technology->path);
+ append_properties(&entry, technology);
+ dbus_message_iter_close_container(array, &entry);
+ }
+}
+
+static gboolean technology_pending_reply(gpointer user_data)
+{
+ struct connman_technology *technology = user_data;
+ DBusMessage *reply;
+
+ /* Power request timedout, send ETIMEDOUT. */
+ if (technology->pending_reply) {
+ reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
+ if (reply)
+ g_dbus_send_message(connection, reply);
+
+ dbus_message_unref(technology->pending_reply);
+ technology->pending_reply = NULL;
+ technology->pending_timeout = 0;
+ }
+
+ return FALSE;
+}
+
+static int technology_affect_devices(struct connman_technology *technology,
+ bool enable_device)
+{
+ int err = 0, err_dev;
+ GSList *list;
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
+ if (enable_device)
+ __connman_technology_enabled(technology->type);
+ else
+ __connman_technology_disabled(technology->type);
+ return 0;
+ }
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (enable_device)
+ err_dev = __connman_device_enable(device);
+ else
+ err_dev = __connman_device_disable(device);
+
+ if (err_dev < 0 && err_dev != -EALREADY)
+ err = err_dev;
+ }
+
+ return err;
+}
+
+static void powered_changed(struct connman_technology *technology)
+{
+ dbus_bool_t enabled;
+
+ if (!technology->dbus_registered)
+ return;
+
+ if (technology->pending_reply) {
+ g_dbus_send_reply(connection,
+ technology->pending_reply, DBUS_TYPE_INVALID);
+ dbus_message_unref(technology->pending_reply);
+ technology->pending_reply = NULL;
+
+ g_source_remove(technology->pending_timeout);
+ technology->pending_timeout = 0;
+ }
+
+ __sync_synchronize();
+ enabled = technology->enabled;
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
+ DBUS_TYPE_BOOLEAN, &enabled);
+}
+
+static void enable_tethering(struct connman_technology *technology)
+{
+ int ret;
+
+ if (!connman_setting_get_bool("PersistentTetheringMode"))
+ return;
+
+ ret = set_tethering(technology, true);
+ if (ret < 0 && ret != -EALREADY)
+ DBG("Cannot enable tethering yet for %s (%d/%s)",
+ get_name(technology->type),
+ -ret, strerror(-ret));
+}
+
+static int technology_enabled(struct connman_technology *technology)
+{
+ __sync_synchronize();
+ if (technology->enabled)
+ return -EALREADY;
+
+ technology->enabled = true;
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ struct connman_technology *p2p;
+
+ p2p = technology_find(CONNMAN_SERVICE_TYPE_P2P);
+ if (p2p && !p2p->enabled && p2p->enable_persistent)
+ technology_enabled(p2p);
+ }
+
+ if (technology->tethering_persistent)
+ enable_tethering(technology);
+
+ powered_changed(technology);
+
+ return 0;
+}
+
+static int technology_enable(struct connman_technology *technology)
+{
+ int err = 0;
+ int err_dev;
+
+ DBG("technology %p enable", technology);
+
+ __sync_synchronize();
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
+ struct connman_technology *wifi;
+
+ wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (wifi && wifi->enabled)
+ return technology_enabled(technology);
+ return 0;
+ }
+
+ if (technology->enabled)
+ return -EALREADY;
+
+ if (technology->pending_reply)
+ return -EBUSY;
+
+ if (connman_setting_get_bool("PersistentTetheringMode") &&
+ technology->tethering)
+ set_tethering(technology, true);
+
+ if (technology->rfkill_driven)
+ err = __connman_rfkill_block(technology->type, false);
+
+ err_dev = technology_affect_devices(technology, true);
+
+ if (!technology->rfkill_driven)
+ err = err_dev;
+
+ return err;
+}
+
+static int technology_disabled(struct connman_technology *technology)
+{
+ __sync_synchronize();
+ if (!technology->enabled)
+ return -EALREADY;
+
+ technology->enabled = false;
+
+ powered_changed(technology);
+
+ return 0;
+}
+
+static int technology_disable(struct connman_technology *technology)
+{
+ int err;
+
+ DBG("technology %p disable", technology);
+
+ __sync_synchronize();
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
+ technology->enable_persistent = false;
+ return technology_disabled(technology);
+ } else if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ struct connman_technology *p2p;
+
+ p2p = technology_find(CONNMAN_SERVICE_TYPE_P2P);
+ if (p2p && p2p->enabled) {
+ p2p->enable_persistent = true;
+ technology_disabled(p2p);
+ }
+ }
+
+ if (!technology->enabled)
+ return -EALREADY;
+
+ if (technology->pending_reply)
+ return -EBUSY;
+
+ if (technology->tethering)
+ set_tethering(technology, false);
+
+ err = technology_affect_devices(technology, false);
+
+ if (technology->rfkill_driven)
+ err = __connman_rfkill_block(technology->type, true);
+
+ return err;
+}
+
+static DBusMessage *set_powered(struct connman_technology *technology,
+ DBusMessage *msg, bool powered)
+{
+ DBusMessage *reply = NULL;
+ int err = 0;
+
+ if (technology->rfkill_driven && technology->hardblocked) {
+ err = -EACCES;
+ goto make_reply;
+ }
+
+ if (powered)
+ err = technology_enable(technology);
+ else
+ err = technology_disable(technology);
+
+ if (err != -EBUSY) {
+ technology->enable_persistent = powered;
+ technology_save(technology);
+ }
+
+make_reply:
+ if (err == -EINPROGRESS) {
+ technology->pending_reply = dbus_message_ref(msg);
+ technology->pending_timeout = g_timeout_add_seconds(10,
+ technology_pending_reply, technology);
+ } else if (err == -EALREADY) {
+ if (powered)
+ reply = __connman_error_already_enabled(msg);
+ else
+ reply = __connman_error_already_disabled(msg);
+ } else if (err < 0)
+ reply = __connman_error_failed(msg, -err);
+ else
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *set_property(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ DBusMessageIter iter, value;
+ const char *name;
+ int type;
+
+ DBG("conn %p", conn);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ DBG("property %s", name);
+
+ if (g_str_equal(name, "Tethering")) {
+ dbus_bool_t tethering;
+ int err;
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
+
+ if (!connman_technology_is_tethering_allowed(technology->type)) {
+ DBG("%s tethering not allowed by config file",
+ __connman_service_type2string(technology->type));
+ return __connman_error_not_supported(msg);
+ }
+
+ dbus_message_iter_get_basic(&value, &tethering);
+
+ if (technology->tethering == tethering) {
+ if (!tethering)
+ return __connman_error_already_disabled(msg);
+ else
+ return __connman_error_already_enabled(msg);
+ }
+
+ err = set_tethering(technology, tethering);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ technology->tethering_persistent = tethering;
+
+ technology_save(technology);
+
+ } else if (g_str_equal(name, "TetheringIdentifier")) {
+ const char *str;
+
+ dbus_message_iter_get_basic(&value, &str);
+
+ if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return __connman_error_not_supported(msg);
+
+ if (strlen(str) < 1 || strlen(str) > 32)
+ return __connman_error_invalid_arguments(msg);
+
+ if (g_strcmp0(technology->tethering_ident, str) != 0) {
+ g_free(technology->tethering_ident);
+ technology->tethering_ident = g_strdup(str);
+ technology_save(technology);
+
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ "TetheringIdentifier",
+ DBUS_TYPE_STRING,
+ &technology->tethering_ident);
+ }
+ } else if (g_str_equal(name, "TetheringPassphrase")) {
+ const char *str;
+
+ dbus_message_iter_get_basic(&value, &str);
+
+ if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return __connman_error_not_supported(msg);
+
+ if (strlen(str) < 8 || strlen(str) > 63)
+ return __connman_error_passphrase_required(msg);
+
+ if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
+ g_free(technology->tethering_passphrase);
+ technology->tethering_passphrase = g_strdup(str);
+ technology_save(technology);
+
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ "TetheringPassphrase",
+ DBUS_TYPE_STRING,
+ &technology->tethering_passphrase);
+ }
+ } else if (g_str_equal(name, "Powered")) {
+ dbus_bool_t enable;
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &enable);
+
+ return set_powered(technology, msg, enable);
+ } else
+ return __connman_error_invalid_property(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static void reply_scan_pending(struct connman_technology *technology, int err)
+{
+ DBusMessage *reply;
+
+ DBG("technology %p err %d", technology, err);
+
+ while (technology->scan_pending) {
+ DBusMessage *msg = technology->scan_pending->data;
+
+ DBG("reply to %s", dbus_message_get_sender(msg));
+
+ if (err == 0)
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ else
+ reply = __connman_error_failed(msg, -err);
+ g_dbus_send_message(connection, reply);
+ dbus_message_unref(msg);
+
+ technology->scan_pending =
+ g_slist_delete_link(technology->scan_pending,
+ technology->scan_pending);
+ }
+}
+
+void __connman_technology_scan_started(struct connman_device *device)
+{
+ DBG("device %p", device);
+}
+
+void __connman_technology_scan_stopped(struct connman_device *device,
+ enum connman_service_type type)
+{
+ int count = 0;
+ struct connman_technology *technology;
+ GSList *list;
+
+ technology = technology_find(type);
+
+ DBG("technology %p device %p", technology, device);
+
+ if (!technology)
+ return;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *other_device = list->data;
+
+ if (device == other_device)
+ continue;
+
+ if (__connman_device_get_service_type(other_device) != type)
+ continue;
+
+ if (connman_device_get_scanning(other_device))
+ count += 1;
+ }
+
+ if (count == 0)
+ reply_scan_pending(technology, 0);
+}
+
+void __connman_technology_notify_regdom_by_device(struct connman_device *device,
+ int result, const char *alpha2)
+{
+ bool regdom_set = false;
+ struct connman_technology *technology;
+ enum connman_service_type type;
+ GSList *tech_drivers;
+
+ type = __connman_device_get_service_type(device);
+ technology = technology_find(type);
+
+ if (!technology)
+ return;
+
+ if (result < 0) {
+
+ for (tech_drivers = technology->driver_list;
+ tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ struct connman_technology_driver *driver =
+ tech_drivers->data;
+
+ if (driver->set_regdom) {
+ driver->set_regdom(technology, alpha2);
+ regdom_set = true;
+ }
+
+ }
+
+ if (!regdom_set)
+ alpha2 = NULL;
+ }
+
+ connman_technology_regdom_notify(technology, alpha2);
+}
+
+static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ int err;
+
+ DBG("technology %p request from %s", technology,
+ dbus_message_get_sender(msg));
+
+ dbus_message_ref(msg);
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, msg);
+
+ err = __connman_device_request_scan(technology->type);
+ if (err < 0)
+ reply_scan_pending(technology, err);
+
+ return NULL;
+}
+
+static const GDBusMethodTable technology_methods[] = {
+ { GDBUS_DEPRECATED_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ get_properties) },
+ { GDBUS_ASYNC_METHOD("SetProperty",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+ NULL, set_property) },
+ { GDBUS_ASYNC_METHOD("Scan", NULL, NULL, scan) },
+ { },
+};
+
+static const GDBusSignalTable technology_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { },
+};
+
+static bool technology_dbus_register(struct connman_technology *technology)
+{
+ if (technology->dbus_registered ||
+ (technology->rfkill_driven &&
+ technology->hardblocked))
+ return true;
+
+ if (!g_dbus_register_interface(connection, technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ technology_methods, technology_signals,
+ NULL, technology, NULL)) {
+ connman_error("Failed to register %s", technology->path);
+ return false;
+ }
+
+ technology_added_signal(technology);
+ technology->dbus_registered = true;
+
+ return true;
+}
+
+static void technology_dbus_unregister(struct connman_technology *technology)
+{
+ if (!technology->dbus_registered)
+ return;
+
+ technology_removed_signal(technology);
+ g_dbus_unregister_interface(connection, technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE);
+
+ technology->dbus_registered = false;
+}
+
+static void technology_put(struct connman_technology *technology)
+{
+ DBG("technology %p", technology);
+
+ if (__sync_sub_and_fetch(&technology->refcount, 1) > 0)
+ return;
+
+ reply_scan_pending(technology, -EINTR);
+
+ while (technology->driver_list) {
+ struct connman_technology_driver *driver;
+
+ driver = technology->driver_list->data;
+
+ if (driver->remove)
+ driver->remove(technology);
+
+ technology->driver_list =
+ g_slist_delete_link(technology->driver_list,
+ technology->driver_list);
+ }
+
+ technology_list = g_slist_remove(technology_list, technology);
+
+ technology_dbus_unregister(technology);
+
+ g_slist_free(technology->device_list);
+
+ /*
+ * Once set_powered is called, technology is not powered
+ * immediately. The device driver enable function returns
+ * -EINPROGRESS and a timer of 10 sec is started. If the
+ * technology is powered within 10 sec, this timer is cancelled.
+ * In case technology is not powered, from timeout handler
+ * -ETIMEDOUT is return to the application. But if technology
+ * is disabled within that 10 sec, technology pointer is freed
+ * but timer is left running. On expiry of timer, it would try
+ * to access the technology pointer which is already freed and
+ * would cause crash.
+ */
+ if (technology->pending_reply) {
+ dbus_message_unref(technology->pending_reply);
+ technology->pending_reply = NULL;
+ g_source_remove(technology->pending_timeout);
+ technology->pending_timeout = 0;
+ }
+
+ g_free(technology->path);
+ g_free(technology->regdom);
+ g_free(technology->tethering_ident);
+ g_free(technology->tethering_passphrase);
+ g_free(technology);
+}
+
+static struct connman_technology *technology_get(enum connman_service_type type)
+{
+ GSList *tech_drivers = NULL;
+ struct connman_technology_driver *driver;
+ struct connman_technology *technology;
+ const char *str;
+ GSList *list;
+
+ DBG("type %d", type);
+
+ str = __connman_service_type2string(type);
+ if (!str)
+ return NULL;
+
+ technology = technology_find(type);
+ if (technology) {
+ if (type != CONNMAN_SERVICE_TYPE_P2P)
+ __sync_fetch_and_add(&technology->refcount, 1);
+ return technology;
+ }
+
+ /* First check if we have a driver for this technology type */
+ for (list = driver_list; list; list = list->next) {
+ driver = list->data;
+
+ if (driver->type == type) {
+ DBG("technology %p driver %p", technology, driver);
+ tech_drivers = g_slist_append(tech_drivers, driver);
+ }
+ }
+
+ if (!tech_drivers) {
+ DBG("No matching drivers found for %s.",
+ __connman_service_type2string(type));
+ return NULL;
+ }
+
+ technology = g_try_new0(struct connman_technology, 1);
+ if (!technology)
+ return NULL;
+
+ technology->refcount = 1;
+ technology->type = type;
+ technology->path = g_strdup_printf("%s/technology/%s",
+ CONNMAN_PATH, str);
+
+ technology_load(technology);
+ technology_list = g_slist_prepend(technology_list, technology);
+ technology->driver_list = tech_drivers;
+
+ for (list = tech_drivers; list; list = list->next) {
+ driver = list->data;
+
+ if (driver->probe && driver->probe(technology) < 0)
+ DBG("Driver probe failed for technology %p",
+ technology);
+ }
+
+ if (!technology_dbus_register(technology)) {
+ technology_put(technology);
+ return NULL;
+ }
+
+ if (type == CONNMAN_SERVICE_TYPE_P2P) {
+ struct connman_technology *wifi;
+ bool enable;
+
+ enable = technology->enable_persistent;
+
+ wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (enable && wifi)
+ enable = wifi->enabled;
+
+ technology_affect_devices(technology, enable);
+ }
+
+ DBG("technology %p %s", technology, get_name(technology->type));
+
+ return technology;
+}
+
+int connman_technology_driver_register(struct connman_technology_driver *driver)
+{
+ GSList *list;
+ struct connman_device *device;
+ enum connman_service_type type;
+
+ for (list = driver_list; list; list = list->next) {
+ if (list->data == driver)
+ goto exist;
+ }
+
+ DBG("Registering %s driver", driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+
+ /*
+ * Check for technology less devices if this driver
+ * can service any of them.
+ */
+ for (list = techless_device_list; list; list = list->next) {
+ device = list->data;
+
+ type = __connman_device_get_service_type(device);
+ if (type != driver->type)
+ continue;
+
+ techless_device_list = g_slist_remove(techless_device_list,
+ device);
+
+ __connman_technology_add_device(device);
+ }
+
+ /* Check for orphaned rfkill switches. */
+ g_hash_table_foreach(rfkill_list, rfkill_check,
+ GINT_TO_POINTER(driver->type));
+
+exist:
+ if (driver->type == CONNMAN_SERVICE_TYPE_P2P) {
+ if (!technology_get(CONNMAN_SERVICE_TYPE_P2P))
+ return -ENOMEM;
+ }
+
+ return 0;
+}
+
+void connman_technology_driver_unregister(struct connman_technology_driver *driver)
+{
+ GSList *list, *tech_drivers;
+ struct connman_technology *technology;
+ struct connman_technology_driver *current;
+
+ DBG("Unregistering driver %p name %s", driver, driver->name);
+
+ for (list = technology_list; list; list = list->next) {
+ technology = list->data;
+
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ current = tech_drivers->data;
+ if (driver != current)
+ continue;
+
+ if (driver->remove)
+ driver->remove(technology);
+
+ technology->driver_list =
+ g_slist_remove(technology->driver_list,
+ driver);
+ break;
+ }
+ }
+
+ driver_list = g_slist_remove(driver_list, driver);
+
+ if (driver->type == CONNMAN_SERVICE_TYPE_P2P) {
+ technology = technology_find(CONNMAN_SERVICE_TYPE_P2P);
+ if (technology)
+ technology_put(technology);
+ }
+}
+
+void __connman_technology_add_interface(enum connman_service_type type,
+ int index, const char *ident)
+{
+ struct connman_technology *technology;
+ GSList *tech_drivers;
+ struct connman_technology_driver *driver;
+ char *name;
+
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ return;
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ }
+
+ name = connman_inet_ifname(index);
+ connman_info("Adding interface %s [ %s ]", name,
+ __connman_service_type2string(type));
+
+ technology = technology_find(type);
+
+ if (!technology)
+ goto out;
+
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ driver = tech_drivers->data;
+
+ if (driver->add_interface)
+ driver->add_interface(technology, index, name, ident);
+ }
+
+ /*
+ * At this point we can try to enable tethering automatically as
+ * now the interfaces are set properly.
+ */
+ if (technology->tethering_persistent)
+ enable_tethering(technology);
+
+out:
+ g_free(name);
+}
+
+void __connman_technology_remove_interface(enum connman_service_type type,
+ int index, const char *ident)
+{
+ struct connman_technology *technology;
+ GSList *tech_drivers;
+ struct connman_technology_driver *driver;
+ char *name;
+
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ return;
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ break;
+ }
+
+ name = connman_inet_ifname(index);
+ connman_info("Remove interface %s [ %s ]", name,
+ __connman_service_type2string(type));
+ g_free(name);
+
+ technology = technology_find(type);
+
+ if (!technology)
+ return;
+
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ driver = tech_drivers->data;
+
+ if (driver->remove_interface)
+ driver->remove_interface(technology, index);
+ }
+}
+
+int __connman_technology_add_device(struct connman_device *device)
+{
+ struct connman_technology *technology;
+ enum connman_service_type type;
+
+ type = __connman_device_get_service_type(device);
+
+ DBG("device %p type %s", device, get_name(type));
+
+ technology = technology_get(type);
+ if (!technology) {
+ /*
+ * Since no driver can be found for this device at the moment we
+ * add it to the techless device list.
+ */
+ techless_device_list = g_slist_prepend(techless_device_list,
+ device);
+
+ return -ENXIO;
+ }
+
+ __sync_synchronize();
+ DBG("rf kill %d enable %d persistent %d global %d", technology->rfkill_driven, technology->enabled, technology->enable_persistent, global_offlinemode);
+ if (technology->rfkill_driven) {
+ if (technology->enabled)
+ __connman_device_enable(device);
+ else
+ __connman_device_disable(device);
+
+ goto done;
+ }
+
+ if (technology->enable_persistent &&
+ !global_offlinemode) {
+ int err = __connman_device_enable(device);
+ /*
+ * connman_technology_add_device() calls __connman_device_enable()
+ * but since the device is already enabled, the calls does not
+ * propagate through to connman_technology_enabled via
+ * connman_device_set_powered.
+ */
+ if (err == -EALREADY)
+ __connman_technology_enabled(type);
+ }
+ /* if technology persistent state is offline */
+ if (!technology->enable_persistent)
+ __connman_device_disable(device);
+
+done:
+ technology->device_list = g_slist_prepend(technology->device_list,
+ device);
+
+ return 0;
+}
+
+int __connman_technology_remove_device(struct connman_device *device)
+{
+ struct connman_technology *technology;
+ enum connman_service_type type;
+
+ DBG("device %p", device);
+
+ type = __connman_device_get_service_type(device);
+
+ technology = technology_find(type);
+ if (!technology) {
+ techless_device_list = g_slist_remove(techless_device_list,
+ device);
+ return -ENXIO;
+ }
+
+ technology->device_list = g_slist_remove(technology->device_list,
+ device);
+
+ if (technology->tethering)
+ set_tethering(technology, false);
+
+ technology_put(technology);
+
+ return 0;
+}
+
+int __connman_technology_enabled(enum connman_service_type type)
+{
+ struct connman_technology *technology;
+
+ technology = technology_find(type);
+ if (!technology)
+ return -ENXIO;
+
+ DBG("technology %p type %s rfkill %d enabled %d", technology,
+ get_name(type), technology->rfkill_driven,
+ technology->enabled);
+
+ if (technology->rfkill_driven) {
+ if (technology->tethering_persistent)
+ enable_tethering(technology);
+ return 0;
+ }
+
+ return technology_enabled(technology);
+}
+
+int __connman_technology_disabled(enum connman_service_type type)
+{
+ struct connman_technology *technology;
+ GSList *list;
+
+ technology = technology_find(type);
+ if (!technology)
+ return -ENXIO;
+
+ if (technology->rfkill_driven)
+ return 0;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (connman_device_get_powered(device))
+ return 0;
+ }
+
+ return technology_disabled(technology);
+}
+
+int __connman_technology_set_offlinemode(bool offlinemode)
+{
+ GSList *list;
+ int err = -EINVAL, enabled_tech_count = 0;
+
+ if (global_offlinemode == offlinemode)
+ return 0;
+
+ DBG("offlinemode %s", offlinemode ? "On" : "Off");
+
+ /*
+ * This is a bit tricky. When you set offlinemode, there is no
+ * way to differentiate between attempting offline mode and
+ * resuming offlinemode from last saved profile. We need that
+ * information in rfkill_update, otherwise it falls back on the
+ * technology's persistent state. Hence we set the offline mode here
+ * but save it & call the notifier only if its successful.
+ */
+
+ global_offlinemode = offlinemode;
+
+ /* Traverse technology list, enable/disable each technology. */
+ for (list = technology_list; list; list = list->next) {
+ struct connman_technology *technology = list->data;
+
+ if (offlinemode)
+ err = technology_disable(technology);
+ else {
+ if (technology->hardblocked)
+ continue;
+
+ if (technology->enable_persistent) {
+ err = technology_enable(technology);
+ enabled_tech_count++;
+ }
+ }
+ }
+
+ if (err == 0 || err == -EINPROGRESS || err == -EALREADY ||
+ (err == -EINVAL && enabled_tech_count == 0)) {
+ connman_technology_save_offlinemode();
+ __connman_notifier_offlinemode(offlinemode);
+ } else
+ global_offlinemode = connman_technology_load_offlinemode();
+
+ return err;
+}
+
+void __connman_technology_set_connected(enum connman_service_type type,
+ bool connected)
+{
+ struct connman_technology *technology;
+ dbus_bool_t val;
+
+ technology = technology_find(type);
+ if (!technology)
+ return;
+
+ DBG("technology %p connected %d", technology, connected);
+
+ technology->connected = connected;
+
+ val = connected;
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE, "Connected",
+ DBUS_TYPE_BOOLEAN, &val);
+}
+
+static bool technology_apply_rfkill_change(struct connman_technology *technology,
+ bool softblock,
+ bool hardblock,
+ bool new_rfkill)
+{
+ bool hardblock_changed = false;
+ bool apply = true;
+ GList *start, *list;
+
+ DBG("technology %p --> %d/%d vs %d/%d",
+ technology, softblock, hardblock,
+ technology->softblocked, technology->hardblocked);
+
+ if (technology->hardblocked == hardblock)
+ goto softblock_change;
+
+ if (!(new_rfkill && !hardblock)) {
+ start = g_hash_table_get_values(rfkill_list);
+
+ for (list = start; list; list = list->next) {
+ struct connman_rfkill *rfkill = list->data;
+
+ if (rfkill->type != technology->type)
+ continue;
+
+ if (rfkill->hardblock != hardblock)
+ apply = false;
+ }
+
+ g_list_free(start);
+ }
+
+ if (!apply)
+ goto softblock_change;
+
+ technology->hardblocked = hardblock;
+ hardblock_changed = true;
+
+softblock_change:
+ if (!apply && technology->softblocked != softblock)
+ apply = true;
+
+ if (!apply)
+ return technology->hardblocked;
+
+ technology->softblocked = softblock;
+
+ if (technology->hardblocked ||
+ technology->softblocked) {
+ if (technology_disabled(technology) != -EALREADY)
+ technology_affect_devices(technology, false);
+ } else if (!technology->hardblocked &&
+ !technology->softblocked) {
+ if (technology_enabled(technology) != -EALREADY)
+ technology_affect_devices(technology, true);
+ }
+
+ if (hardblock_changed) {
+ if (technology->hardblocked) {
+ DBG("%s is switched off.", get_name(technology->type));
+ technology_dbus_unregister(technology);
+ } else {
+ DBG("%s is switched on.", get_name(technology->type));
+ technology_dbus_register(technology);
+
+ if (global_offlinemode)
+ __connman_rfkill_block(technology->type, true);
+ }
+ }
+
+ return technology->hardblocked;
+}
+
+int __connman_technology_add_rfkill(unsigned int index,
+ enum connman_service_type type,
+ bool softblock,
+ bool hardblock)
+{
+ struct connman_technology *technology;
+ struct connman_rfkill *rfkill;
+
+ DBG("index %u type %d soft %u hard %u", index, type,
+ softblock, hardblock);
+
+ rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
+ if (rfkill)
+ goto done;
+
+ rfkill = g_try_new0(struct connman_rfkill, 1);
+ if (!rfkill)
+ return -ENOMEM;
+
+ rfkill->index = index;
+ rfkill->type = type;
+ rfkill->softblock = softblock;
+ rfkill->hardblock = hardblock;
+
+ g_hash_table_insert(rfkill_list, GINT_TO_POINTER(index), rfkill);
+
+done:
+ technology = technology_get(type);
+ /* If there is no driver for this type, ignore it. */
+ if (!technology)
+ return -ENXIO;
+
+ technology->rfkill_driven = true;
+
+ /* If hardblocked, there is no need to handle softblocked state */
+ if (technology_apply_rfkill_change(technology,
+ softblock, hardblock, true))
+ return 0;
+
+ if (global_offlinemode)
+ return 0;
+
+ /*
+ * Depending on softblocked state we unblock/block according to
+ * offlinemode and persistente state.
+ */
+ if (technology->softblocked &&
+ technology->enable_persistent)
+ return __connman_rfkill_block(type, false);
+ else if (!technology->softblocked &&
+ !technology->enable_persistent)
+ return __connman_rfkill_block(type, true);
+
+ return 0;
+}
+
+int __connman_technology_update_rfkill(unsigned int index,
+ enum connman_service_type type,
+ bool softblock,
+ bool hardblock)
+{
+ struct connman_technology *technology;
+ struct connman_rfkill *rfkill;
+
+ DBG("index %u soft %u hard %u", index, softblock, hardblock);
+
+ rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
+ if (!rfkill)
+ return -ENXIO;
+
+ if (rfkill->softblock == softblock &&
+ rfkill->hardblock == hardblock)
+ return 0;
+
+ rfkill->softblock = softblock;
+ rfkill->hardblock = hardblock;
+
+ technology = technology_find(type);
+ /* If there is no driver for this type, ignore it. */
+ if (!technology)
+ return -ENXIO;
+
+ technology_apply_rfkill_change(technology, softblock, hardblock,
+ false);
+
+ if (technology->hardblocked)
+ DBG("%s hardblocked", get_name(technology->type));
+ else
+ DBG("%s is%s softblocked", get_name(technology->type),
+ technology->softblocked ? "" : " not");
+
+ return 0;
+}
+
+int __connman_technology_remove_rfkill(unsigned int index,
+ enum connman_service_type type)
+{
+ struct connman_technology *technology;
+ struct connman_rfkill *rfkill;
+
+ DBG("index %u", index);
+
+ rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
+ if (!rfkill)
+ return -ENXIO;
+
+ g_hash_table_remove(rfkill_list, GINT_TO_POINTER(index));
+
+ technology = technology_find(type);
+ if (!technology)
+ return -ENXIO;
+
+ technology_apply_rfkill_change(technology,
+ technology->softblocked, !technology->hardblocked, false);
+
+ technology_put(technology);
+
+ return 0;
+}
+
+int __connman_technology_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+
+ rfkill_list = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_rfkill);
+
+ global_offlinemode = connman_technology_load_offlinemode();
+
+ /* This will create settings file if it is missing */
+ connman_technology_save_offlinemode();
+
+ return 0;
+}
+
+void __connman_technology_cleanup(void)
+{
+ DBG("");
+
+ while (technology_list) {
+ struct connman_technology *technology = technology_list->data;
+ technology_list = g_slist_remove(technology_list, technology);
+ technology_put(technology);
+ }
+
+ g_hash_table_destroy(rfkill_list);
+
+ dbus_connection_unref(connection);
+}
diff --git a/src/tethering.c b/src/tethering.c
new file mode 100644
index 0000000..ceeec74
--- /dev/null
+++ b/src/tethering.c
@@ -0,0 +1,558 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ * Copyright (C) 2011 ProFUSION embedded systems
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <linux/sockios.h>
+#include <string.h>
+#include <fcntl.h>
+#include <linux/if_tun.h>
+#include <netinet/in.h>
+#include <linux/if_bridge.h>
+
+#include "connman.h"
+
+#include <gdhcp/gdhcp.h>
+
+#include <gdbus.h>
+
+#ifndef DBUS_TYPE_UNIX_FD
+#define DBUS_TYPE_UNIX_FD -1
+#endif
+
+#define BRIDGE_NAME "tether"
+
+#define DEFAULT_MTU 1500
+
+static char *private_network_primary_dns = NULL;
+static char *private_network_secondary_dns = NULL;
+
+static volatile int tethering_enabled;
+static GDHCPServer *tethering_dhcp_server = NULL;
+static struct connman_ippool *dhcp_ippool = NULL;
+static DBusConnection *connection;
+static GHashTable *pn_hash;
+
+struct connman_private_network {
+ char *owner;
+ char *path;
+ guint watch;
+ DBusMessage *msg;
+ DBusMessage *reply;
+ int fd;
+ char *interface;
+ int index;
+ guint iface_watch;
+ struct connman_ippool *pool;
+ char *primary_dns;
+ char *secondary_dns;
+};
+
+const char *__connman_tethering_get_bridge(void)
+{
+ int sk, err;
+ unsigned long args[3];
+
+ sk = socket(AF_INET, SOCK_STREAM, 0);
+ if (sk < 0)
+ return NULL;
+
+ args[0] = BRCTL_GET_VERSION;
+ args[1] = args[2] = 0;
+ err = ioctl(sk, SIOCGIFBR, &args);
+ close(sk);
+ if (err == -1) {
+ connman_error("Missing support for 802.1d ethernet bridging");
+ return NULL;
+ }
+
+ return BRIDGE_NAME;
+}
+
+static void dhcp_server_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static void dhcp_server_error(GDHCPServerError error)
+{
+ switch (error) {
+ case G_DHCP_SERVER_ERROR_NONE:
+ connman_error("OK");
+ break;
+ case G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE:
+ connman_error("Interface unavailable");
+ break;
+ case G_DHCP_SERVER_ERROR_INTERFACE_IN_USE:
+ connman_error("Interface in use");
+ break;
+ case G_DHCP_SERVER_ERROR_INTERFACE_DOWN:
+ connman_error("Interface down");
+ break;
+ case G_DHCP_SERVER_ERROR_NOMEM:
+ connman_error("No memory");
+ break;
+ case G_DHCP_SERVER_ERROR_INVALID_INDEX:
+ connman_error("Invalid index");
+ break;
+ case G_DHCP_SERVER_ERROR_INVALID_OPTION:
+ connman_error("Invalid option");
+ break;
+ case G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID:
+ connman_error("Invalid address");
+ break;
+ }
+}
+
+static GDHCPServer *dhcp_server_start(const char *bridge,
+ const char *router, const char *subnet,
+ const char *start_ip, const char *end_ip,
+ unsigned int lease_time, const char *dns)
+{
+ GDHCPServerError error;
+ GDHCPServer *dhcp_server;
+ int index;
+
+ DBG("");
+
+ index = connman_inet_ifindex(bridge);
+ if (index < 0)
+ return NULL;
+
+ dhcp_server = g_dhcp_server_new(G_DHCP_IPV4, index, &error);
+ if (!dhcp_server) {
+ dhcp_server_error(error);
+ return NULL;
+ }
+
+ g_dhcp_server_set_debug(dhcp_server, dhcp_server_debug, "DHCP server");
+
+ g_dhcp_server_set_lease_time(dhcp_server, lease_time);
+ g_dhcp_server_set_option(dhcp_server, G_DHCP_SUBNET, subnet);
+ g_dhcp_server_set_option(dhcp_server, G_DHCP_ROUTER, router);
+ g_dhcp_server_set_option(dhcp_server, G_DHCP_DNS_SERVER, dns);
+ g_dhcp_server_set_ip_range(dhcp_server, start_ip, end_ip);
+
+ g_dhcp_server_start(dhcp_server);
+
+ return dhcp_server;
+}
+
+static void dhcp_server_stop(GDHCPServer *server)
+{
+ if (!server)
+ return;
+
+ g_dhcp_server_unref(server);
+}
+
+static void tethering_restart(struct connman_ippool *pool, void *user_data)
+{
+ DBG("pool %p", pool);
+ __connman_tethering_set_disabled();
+ __connman_tethering_set_enabled();
+}
+
+void __connman_tethering_set_enabled(void)
+{
+ int index;
+ int err;
+ const char *gateway;
+ const char *broadcast;
+ const char *subnet_mask;
+ const char *start_ip;
+ const char *end_ip;
+ const char *dns;
+ unsigned char prefixlen;
+ char **ns;
+
+ DBG("enabled %d", tethering_enabled + 1);
+
+ if (__sync_fetch_and_add(&tethering_enabled, 1) != 0)
+ return;
+
+ err = __connman_bridge_create(BRIDGE_NAME);
+ if (err < 0) {
+ __sync_fetch_and_sub(&tethering_enabled, 1);
+ return;
+ }
+
+ index = connman_inet_ifindex(BRIDGE_NAME);
+ dhcp_ippool = __connman_ippool_create(index, 2, 252,
+ tethering_restart, NULL);
+ if (!dhcp_ippool) {
+ connman_error("Fail to create IP pool");
+ __connman_bridge_remove(BRIDGE_NAME);
+ __sync_fetch_and_sub(&tethering_enabled, 1);
+ return;
+ }
+
+ gateway = __connman_ippool_get_gateway(dhcp_ippool);
+ broadcast = __connman_ippool_get_broadcast(dhcp_ippool);
+ subnet_mask = __connman_ippool_get_subnet_mask(dhcp_ippool);
+ start_ip = __connman_ippool_get_start_ip(dhcp_ippool);
+ end_ip = __connman_ippool_get_end_ip(dhcp_ippool);
+
+ err = __connman_bridge_enable(BRIDGE_NAME, gateway,
+ connman_ipaddress_calc_netmask_len(subnet_mask),
+ broadcast);
+ if (err < 0 && err != -EALREADY) {
+ __connman_ippool_unref(dhcp_ippool);
+ __connman_bridge_remove(BRIDGE_NAME);
+ __sync_fetch_and_sub(&tethering_enabled, 1);
+ return;
+ }
+
+ ns = connman_setting_get_string_list("FallbackNameservers");
+ if (ns) {
+ if (ns[0]) {
+ g_free(private_network_primary_dns);
+ private_network_primary_dns = g_strdup(ns[0]);
+ }
+ if (ns[1]) {
+ g_free(private_network_secondary_dns);
+ private_network_secondary_dns = g_strdup(ns[1]);
+ }
+
+ DBG("Fallback ns primary %s secondary %s",
+ private_network_primary_dns,
+ private_network_secondary_dns);
+ }
+
+ dns = gateway;
+ if (__connman_dnsproxy_add_listener(index) < 0) {
+ connman_error("Can't add listener %s to DNS proxy",
+ BRIDGE_NAME);
+ dns = private_network_primary_dns;
+ DBG("Serving %s nameserver to clients", dns);
+ }
+
+ tethering_dhcp_server = dhcp_server_start(BRIDGE_NAME,
+ gateway, subnet_mask,
+ start_ip, end_ip,
+ 24 * 3600, dns);
+ if (!tethering_dhcp_server) {
+ __connman_bridge_disable(BRIDGE_NAME);
+ __connman_ippool_unref(dhcp_ippool);
+ __connman_bridge_remove(BRIDGE_NAME);
+ __sync_fetch_and_sub(&tethering_enabled, 1);
+ return;
+ }
+
+ prefixlen = connman_ipaddress_calc_netmask_len(subnet_mask);
+ err = __connman_nat_enable(BRIDGE_NAME, start_ip, prefixlen);
+ if (err < 0) {
+ connman_error("Cannot enable NAT %d/%s", err, strerror(-err));
+ dhcp_server_stop(tethering_dhcp_server);
+ __connman_bridge_disable(BRIDGE_NAME);
+ __connman_ippool_unref(dhcp_ippool);
+ __connman_bridge_remove(BRIDGE_NAME);
+ __sync_fetch_and_sub(&tethering_enabled, 1);
+ return;
+ }
+
+ err = __connman_ipv6pd_setup(BRIDGE_NAME);
+ if (err < 0 && err != -EINPROGRESS)
+ DBG("Cannot setup IPv6 prefix delegation %d/%s", err,
+ strerror(-err));
+
+ DBG("tethering started");
+}
+
+void __connman_tethering_set_disabled(void)
+{
+ int index;
+
+ DBG("enabled %d", tethering_enabled - 1);
+
+ if (__sync_fetch_and_sub(&tethering_enabled, 1) != 1)
+ return;
+
+ __connman_ipv6pd_cleanup();
+
+ index = connman_inet_ifindex(BRIDGE_NAME);
+ __connman_dnsproxy_remove_listener(index);
+
+ __connman_nat_disable(BRIDGE_NAME);
+
+ dhcp_server_stop(tethering_dhcp_server);
+
+ tethering_dhcp_server = NULL;
+
+ __connman_bridge_disable(BRIDGE_NAME);
+
+ __connman_ippool_unref(dhcp_ippool);
+
+ __connman_bridge_remove(BRIDGE_NAME);
+
+ g_free(private_network_primary_dns);
+ private_network_primary_dns = NULL;
+ g_free(private_network_secondary_dns);
+ private_network_secondary_dns = NULL;
+
+ DBG("tethering stopped");
+}
+
+static void setup_tun_interface(unsigned int flags, unsigned change,
+ void *data)
+{
+ struct connman_private_network *pn = data;
+ unsigned char prefixlen;
+ DBusMessageIter array, dict;
+ const char *server_ip;
+ const char *peer_ip;
+ const char *subnet_mask;
+ int err;
+
+ DBG("index %d flags %d change %d", pn->index, flags, change);
+
+ if (flags & IFF_UP)
+ return;
+
+ subnet_mask = __connman_ippool_get_subnet_mask(pn->pool);
+ server_ip = __connman_ippool_get_start_ip(pn->pool);
+ peer_ip = __connman_ippool_get_end_ip(pn->pool);
+ prefixlen = connman_ipaddress_calc_netmask_len(subnet_mask);
+
+ if ((__connman_inet_modify_address(RTM_NEWADDR,
+ NLM_F_REPLACE | NLM_F_ACK, pn->index, AF_INET,
+ server_ip, peer_ip, prefixlen, NULL)) < 0) {
+ DBG("address setting failed");
+ return;
+ }
+
+ connman_inet_ifup(pn->index);
+
+ err = __connman_nat_enable(BRIDGE_NAME, server_ip, prefixlen);
+ if (err < 0) {
+ connman_error("failed to enable NAT");
+ goto error;
+ }
+
+ dbus_message_iter_init_append(pn->reply, &array);
+
+ dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
+ &pn->path);
+
+ connman_dbus_dict_open(&array, &dict);
+
+ connman_dbus_dict_append_basic(&dict, "ServerIPv4",
+ DBUS_TYPE_STRING, &server_ip);
+ connman_dbus_dict_append_basic(&dict, "PeerIPv4",
+ DBUS_TYPE_STRING, &peer_ip);
+ if (pn->primary_dns)
+ connman_dbus_dict_append_basic(&dict, "PrimaryDNS",
+ DBUS_TYPE_STRING, &pn->primary_dns);
+
+ if (pn->secondary_dns)
+ connman_dbus_dict_append_basic(&dict, "SecondaryDNS",
+ DBUS_TYPE_STRING, &pn->secondary_dns);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ dbus_message_iter_append_basic(&array, DBUS_TYPE_UNIX_FD, &pn->fd);
+
+ g_dbus_send_message(connection, pn->reply);
+
+ return;
+
+error:
+ pn->reply = __connman_error_failed(pn->msg, -err);
+ g_dbus_send_message(connection, pn->reply);
+
+ g_hash_table_remove(pn_hash, pn->path);
+}
+
+static void remove_private_network(gpointer user_data)
+{
+ struct connman_private_network *pn = user_data;
+
+ __connman_nat_disable(BRIDGE_NAME);
+ connman_rtnl_remove_watch(pn->iface_watch);
+ __connman_ippool_unref(pn->pool);
+
+ if (pn->watch > 0) {
+ g_dbus_remove_watch(connection, pn->watch);
+ pn->watch = 0;
+ }
+
+ close(pn->fd);
+
+ g_free(pn->interface);
+ g_free(pn->owner);
+ g_free(pn->path);
+ g_free(pn->primary_dns);
+ g_free(pn->secondary_dns);
+ g_free(pn);
+}
+
+static void owner_disconnect(DBusConnection *conn, void *user_data)
+{
+ struct connman_private_network *pn = user_data;
+
+ DBG("%s died", pn->owner);
+
+ pn->watch = 0;
+
+ g_hash_table_remove(pn_hash, pn->path);
+}
+
+static void ippool_disconnect(struct connman_ippool *pool, void *user_data)
+{
+ struct connman_private_network *pn = user_data;
+
+ DBG("block used externally");
+
+ g_hash_table_remove(pn_hash, pn->path);
+}
+
+int __connman_private_network_request(DBusMessage *msg, const char *owner)
+{
+ struct connman_private_network *pn;
+ char *iface = NULL;
+ char *path = NULL;
+ int index, fd, err;
+
+ if (DBUS_TYPE_UNIX_FD < 0)
+ return -EINVAL;
+
+ fd = connman_inet_create_tunnel(&iface);
+ if (fd < 0)
+ return fd;
+
+ path = g_strdup_printf("/tethering/%s", iface);
+
+ pn = g_hash_table_lookup(pn_hash, path);
+ if (pn) {
+ g_free(path);
+ g_free(iface);
+ close(fd);
+ return -EEXIST;
+ }
+
+ index = connman_inet_ifindex(iface);
+ if (index < 0) {
+ err = -ENODEV;
+ goto error;
+ }
+ DBG("interface %s", iface);
+
+ err = connman_inet_set_mtu(index, DEFAULT_MTU);
+
+ pn = g_try_new0(struct connman_private_network, 1);
+ if (!pn) {
+ err = -ENOMEM;
+ goto error;
+ }
+
+ pn->owner = g_strdup(owner);
+ pn->path = path;
+ pn->watch = g_dbus_add_disconnect_watch(connection, pn->owner,
+ owner_disconnect, pn, NULL);
+ pn->msg = msg;
+ pn->reply = dbus_message_new_method_return(pn->msg);
+ if (!pn->reply)
+ goto error;
+
+ pn->fd = fd;
+ pn->interface = iface;
+ pn->index = index;
+ pn->pool = __connman_ippool_create(pn->index, 1, 1, ippool_disconnect, pn);
+ if (!pn->pool) {
+ errno = -ENOMEM;
+ goto error;
+ }
+
+ pn->primary_dns = g_strdup(private_network_primary_dns);
+ pn->secondary_dns = g_strdup(private_network_secondary_dns);
+
+ pn->iface_watch = connman_rtnl_add_newlink_watch(index,
+ setup_tun_interface, pn);
+
+ g_hash_table_insert(pn_hash, pn->path, pn);
+
+ return 0;
+
+error:
+ close(fd);
+ g_free(iface);
+ g_free(path);
+ g_free(pn);
+ return err;
+}
+
+int __connman_private_network_release(const char *path)
+{
+ struct connman_private_network *pn;
+
+ pn = g_hash_table_lookup(pn_hash, path);
+ if (!pn)
+ return -EACCES;
+
+ g_hash_table_remove(pn_hash, path);
+ return 0;
+}
+
+int __connman_tethering_init(void)
+{
+ DBG("");
+
+ tethering_enabled = 0;
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -EFAULT;
+
+ pn_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_private_network);
+
+ return 0;
+}
+
+void __connman_tethering_cleanup(void)
+{
+ DBG("enabled %d", tethering_enabled);
+
+ __sync_synchronize();
+ if (tethering_enabled > 0) {
+ if (tethering_dhcp_server)
+ dhcp_server_stop(tethering_dhcp_server);
+ __connman_bridge_disable(BRIDGE_NAME);
+ __connman_bridge_remove(BRIDGE_NAME);
+ __connman_nat_disable(BRIDGE_NAME);
+ }
+
+ if (!connection)
+ return;
+
+ g_hash_table_destroy(pn_hash);
+ dbus_connection_unref(connection);
+}
diff --git a/src/timeserver.c b/src/timeserver.c
new file mode 100644
index 0000000..f0d33e5
--- /dev/null
+++ b/src/timeserver.c
@@ -0,0 +1,439 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <glib.h>
+#include <stdlib.h>
+#include <gweb/gresolv.h>
+#include <netdb.h>
+
+#include "connman.h"
+
+#define TS_RECHECK_INTERVAL 7200
+
+static GSList *ts_list = NULL;
+static char *ts_current = NULL;
+static int ts_recheck_id = 0;
+
+static GResolv *resolv = NULL;
+static int resolv_id = 0;
+
+static void resolv_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+static void save_timeservers(char **servers)
+{
+ GKeyFile *keyfile;
+ int cnt;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ keyfile = g_key_file_new();
+
+ for (cnt = 0; servers && servers[cnt]; cnt++);
+
+ g_key_file_set_string_list(keyfile, "global", "Timeservers",
+ (const gchar **)servers, cnt);
+
+ __connman_storage_save_global(keyfile);
+
+ g_key_file_free(keyfile);
+
+ return;
+}
+
+static char **load_timeservers(void)
+{
+ GKeyFile *keyfile;
+ char **servers = NULL;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ return NULL;
+
+ servers = g_key_file_get_string_list(keyfile, "global",
+ "Timeservers", NULL, NULL);
+
+ g_key_file_free(keyfile);
+
+ return servers;
+}
+
+static void resolv_result(GResolvResultStatus status, char **results,
+ gpointer user_data)
+{
+ int i;
+
+ DBG("status %d", status);
+
+ if (status == G_RESOLV_RESULT_STATUS_SUCCESS) {
+ if (results) {
+ for (i = 0; results[i]; i++) {
+ DBG("result[%d]: %s", i, results[i]);
+ if (i == 0)
+ continue;
+
+ ts_list = __connman_timeserver_add_list(
+ ts_list, results[i]);
+ }
+
+ DBG("Using timeserver %s", results[0]);
+
+ __connman_ntp_start(results[0]);
+
+ return;
+ }
+ }
+
+ /* If resolving fails, move to the next server */
+ __connman_timeserver_sync_next();
+}
+
+/*
+ * Once the timeserver list (ts_list) is created, we start querying the
+ * servers one by one. If resolving fails on one of them, we move to the
+ * next one. The user can enter either an IP address or a URL for the
+ * timeserver. We only resolve the URLs. Once we have an IP for the NTP
+ * server, we start querying it for time corrections.
+ */
+void __connman_timeserver_sync_next()
+{
+ if (ts_current) {
+ g_free(ts_current);
+ ts_current = NULL;
+ }
+
+ __connman_ntp_stop();
+
+ /* Get the 1st server in the list */
+ if (!ts_list)
+ return;
+
+ ts_current = ts_list->data;
+
+ ts_list = g_slist_delete_link(ts_list, ts_list);
+
+ /* if it's an IP, directly query it. */
+ if (connman_inet_check_ipaddress(ts_current) > 0) {
+ DBG("Using timeserver %s", ts_current);
+
+ __connman_ntp_start(ts_current);
+
+ return;
+ }
+
+ DBG("Resolving timeserver %s", ts_current);
+
+ resolv_id = g_resolv_lookup_hostname(resolv, ts_current,
+ resolv_result, NULL);
+
+ return;
+}
+
+GSList *__connman_timeserver_add_list(GSList *server_list,
+ const char *timeserver)
+{
+ GSList *list = server_list;
+
+ if (!timeserver)
+ return server_list;
+
+ while (list) {
+ char *existing_server = list->data;
+ if (strcmp(timeserver, existing_server) == 0)
+ return server_list;
+ list = g_slist_next(list);
+ }
+ return g_slist_prepend(server_list, g_strdup(timeserver));
+}
+
+/*
+ * __connman_timeserver_get_all function creates the timeserver
+ * list which will be used to determine NTP server for time corrections.
+ * The service settings take priority over the global timeservers.
+ */
+GSList *__connman_timeserver_get_all(struct connman_service *service)
+{
+ GSList *list = NULL;
+ struct connman_network *network;
+ char **timeservers;
+ char **service_ts;
+ char **service_ts_config;
+ const char *service_gw;
+ char **fallback_ts;
+ int index, i;
+
+ if (__connman_clock_timeupdates() == TIME_UPDATES_MANUAL)
+ return NULL;
+
+ service_ts_config = connman_service_get_timeservers_config(service);
+
+ /* First add Service Timeservers.Configuration to the list */
+ for (i = 0; service_ts_config && service_ts_config[i];
+ i++)
+ list = __connman_timeserver_add_list(list,
+ service_ts_config[i]);
+
+ service_ts = connman_service_get_timeservers(service);
+
+ /* Then add Service Timeservers via DHCP to the list */
+ for (i = 0; service_ts && service_ts[i]; i++)
+ list = __connman_timeserver_add_list(list, service_ts[i]);
+
+ network = __connman_service_get_network(service);
+ if (network) {
+ index = connman_network_get_index(network);
+ service_gw = __connman_ipconfig_get_gateway_from_index(index,
+ CONNMAN_IPCONFIG_TYPE_ALL);
+
+ /* Then add Service Gateway to the list */
+ if (service_gw)
+ list = __connman_timeserver_add_list(list, service_gw);
+ }
+
+ /* Then add Global Timeservers to the list */
+ timeservers = load_timeservers();
+
+ for (i = 0; timeservers && timeservers[i]; i++)
+ list = __connman_timeserver_add_list(list, timeservers[i]);
+
+ g_strfreev(timeservers);
+
+ fallback_ts = connman_setting_get_string_list("FallbackTimeservers");
+
+ /* Lastly add the fallback servers */
+ for (i = 0; fallback_ts && fallback_ts[i]; i++)
+ list = __connman_timeserver_add_list(list, fallback_ts[i]);
+
+ return g_slist_reverse(list);
+}
+
+static gboolean ts_recheck(gpointer user_data)
+{
+ GSList *ts;
+
+ ts = __connman_timeserver_get_all(__connman_service_get_default());
+
+ if (!ts) {
+ DBG("timeservers disabled");
+
+ return TRUE;
+ }
+
+ if (g_strcmp0(ts_current, ts->data) != 0) {
+ DBG("current %s preferred %s", ts_current, (char *)ts->data);
+
+ g_slist_free_full(ts, g_free);
+
+ __connman_timeserver_sync(NULL);
+
+ return FALSE;
+ }
+
+ DBG("");
+
+ g_slist_free_full(ts, g_free);
+
+ return TRUE;
+}
+
+static void ts_recheck_disable(void)
+{
+ if (ts_recheck_id == 0)
+ return;
+
+ g_source_remove(ts_recheck_id);
+ ts_recheck_id = 0;
+
+ if (ts_current) {
+ g_free(ts_current);
+ ts_current = NULL;
+ }
+}
+
+static void ts_recheck_enable(void)
+{
+ if (ts_recheck_id > 0)
+ return;
+
+ ts_recheck_id = g_timeout_add_seconds(TS_RECHECK_INTERVAL, ts_recheck,
+ NULL);
+}
+
+/*
+ * This function must be called everytime the default service changes, the
+ * service timeserver(s) or gateway changes or the global timeserver(s) changes.
+ */
+int __connman_timeserver_sync(struct connman_service *default_service)
+{
+ struct connman_service *service;
+
+ if (default_service)
+ service = default_service;
+ else
+ service = __connman_service_get_default();
+
+ if (!service)
+ return -EINVAL;
+
+ if (!resolv)
+ return 0;
+ /*
+ * Before we start creating the new timeserver list we must stop
+ * any ongoing ntp query and server resolution.
+ */
+
+ __connman_ntp_stop();
+
+ ts_recheck_disable();
+
+ if (resolv_id > 0)
+ g_resolv_cancel_lookup(resolv, resolv_id);
+
+ g_slist_free_full(ts_list, g_free);
+
+ ts_list = __connman_timeserver_get_all(service);
+
+ __connman_service_timeserver_changed(service, ts_list);
+
+ if (!ts_list) {
+ DBG("No timeservers set.");
+ return 0;
+ }
+
+ ts_recheck_enable();
+
+ __connman_timeserver_sync_next();
+
+ return 0;
+}
+
+static int timeserver_start(struct connman_service *service)
+{
+ char **nameservers;
+ int i;
+
+ DBG("service %p", service);
+
+ i = __connman_service_get_index(service);
+ if (i < 0)
+ return -EINVAL;
+
+ nameservers = connman_service_get_nameservers(service);
+ if (!nameservers)
+ return -EINVAL;
+
+ /* Stop an already ongoing resolution, if there is one */
+ if (resolv && resolv_id > 0)
+ g_resolv_cancel_lookup(resolv, resolv_id);
+
+ /* get rid of the old resolver */
+ if (resolv) {
+ g_resolv_unref(resolv);
+ resolv = NULL;
+ }
+
+ resolv = g_resolv_new(i);
+ if (!resolv) {
+ g_strfreev(nameservers);
+ return -ENOMEM;
+ }
+
+ if (getenv("CONNMAN_RESOLV_DEBUG"))
+ g_resolv_set_debug(resolv, resolv_debug, "RESOLV");
+
+ for (i = 0; nameservers[i]; i++)
+ g_resolv_add_nameserver(resolv, nameservers[i], 53, 0);
+
+ g_strfreev(nameservers);
+
+ return __connman_timeserver_sync(service);
+}
+
+static void timeserver_stop(void)
+{
+ DBG(" ");
+
+ if (resolv) {
+ g_resolv_unref(resolv);
+ resolv = NULL;
+ }
+
+ g_slist_free_full(ts_list, g_free);
+
+ ts_list = NULL;
+
+ __connman_ntp_stop();
+
+ ts_recheck_disable();
+}
+
+int __connman_timeserver_system_set(char **servers)
+{
+ save_timeservers(servers);
+
+ __connman_timeserver_sync(NULL);
+
+ return 0;
+}
+
+char **__connman_timeserver_system_get()
+{
+ char **servers;
+
+ servers = load_timeservers();
+ return servers;
+}
+
+static void default_changed(struct connman_service *default_service)
+{
+ if (default_service)
+ timeserver_start(default_service);
+ else
+ timeserver_stop();
+}
+
+static struct connman_notifier timeserver_notifier = {
+ .name = "timeserver",
+ .default_changed = default_changed,
+};
+
+int __connman_timeserver_init(void)
+{
+ DBG("");
+
+ connman_notifier_register(×erver_notifier);
+
+ return 0;
+}
+
+void __connman_timeserver_cleanup(void)
+{
+ DBG("");
+
+ connman_notifier_unregister(×erver_notifier);
+}
diff --git a/src/timezone.c b/src/timezone.c
new file mode 100644
index 0000000..e346b11
--- /dev/null
+++ b/src/timezone.c
@@ -0,0 +1,454 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dirent.h>
+#include <sys/stat.h>
+#include <sys/mman.h>
+#include <sys/inotify.h>
+
+#include <glib.h>
+
+#include "connman.h"
+
+#define ETC_LOCALTIME "/etc/localtime"
+#define ETC_SYSCONFIG_CLOCK "/etc/sysconfig/clock"
+#define USR_SHARE_ZONEINFO "/usr/share/zoneinfo"
+
+static char *read_key_file(const char *pathname, const char *key)
+{
+ struct stat st;
+ char *map, *ptr, *str;
+ off_t ptrlen, keylen;
+ int fd;
+
+ fd = open(pathname, O_RDONLY | O_CLOEXEC);
+ if (fd < 0)
+ return NULL;
+
+ if (fstat(fd, &st) < 0) {
+ close(fd);
+ return NULL;
+ }
+
+ map = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+ if (!map || map == MAP_FAILED) {
+ close(fd);
+ return NULL;
+ }
+
+ ptr = map;
+ ptrlen = st.st_size;
+ keylen = strlen(key);
+
+ while (ptrlen > keylen + 1) {
+ int cmp = strncmp(ptr, key, keylen);
+
+ if (cmp == 0) {
+ if (ptr == map)
+ break;
+
+ if (*(ptr - 1) == '\n' && *(ptr + keylen) == '=')
+ break;
+ }
+
+ ptr = memchr(ptr + 1, key[0], ptrlen - 1);
+ if (!ptr)
+ break;
+
+ ptrlen = st.st_size - (ptr - map);
+ }
+
+ if (ptr) {
+ char *end, *val;
+
+ ptrlen = st.st_size - (ptr - map);
+
+ end = memchr(ptr, '\n', ptrlen);
+ if (end)
+ ptrlen = end - ptr;
+
+ val = memchr(ptr, '"', ptrlen);
+ if (val) {
+ end = memchr(val + 1, '"', end - val - 1);
+ if (end)
+ str = g_strndup(val + 1, end - val - 1);
+ else
+ str = NULL;
+ } else
+ str = g_strndup(ptr + keylen + 1, ptrlen - keylen - 1);
+ } else
+ str = NULL;
+
+ munmap(map, st.st_size);
+
+ close(fd);
+
+ return str;
+}
+
+static int compare_file(void *src_map, struct stat *src_st,
+ const char *pathname)
+{
+ struct stat dst_st;
+ void *dst_map;
+ int fd, result;
+
+ fd = open(pathname, O_RDONLY | O_CLOEXEC);
+ if (fd < 0)
+ return -1;
+
+ if (fstat(fd, &dst_st) < 0) {
+ close(fd);
+ return -1;
+ }
+
+ if (src_st->st_size != dst_st.st_size) {
+ close(fd);
+ return -1;
+ }
+
+ dst_map = mmap(0, dst_st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+ if (!dst_map || dst_map == MAP_FAILED) {
+ close(fd);
+ return -1;
+ }
+
+ result = memcmp(src_map, dst_map, src_st->st_size);
+
+ munmap(dst_map, dst_st.st_size);
+
+ close(fd);
+
+ return result;
+}
+
+static char *find_origin(void *src_map, struct stat *src_st,
+ const char *basepath, const char *subpath)
+{
+ DIR *dir;
+ struct dirent *d;
+ char *str, pathname[PATH_MAX];
+ struct stat buf;
+ int ret;
+
+ if (!subpath)
+ strncpy(pathname, basepath, sizeof(pathname) - 1);
+ else
+ snprintf(pathname, sizeof(pathname),
+ "%s/%s", basepath, subpath);
+
+ dir = opendir(pathname);
+ if (!dir)
+ return NULL;
+
+ while ((d = readdir(dir))) {
+ if (strcmp(d->d_name, ".") == 0 ||
+ strcmp(d->d_name, "..") == 0 ||
+ strcmp(d->d_name, "posix") == 0 ||
+ strcmp(d->d_name, "right") == 0)
+ continue;
+
+ switch (d->d_type) {
+ case DT_REG:
+ if (!subpath)
+ snprintf(pathname, PATH_MAX,
+ "%s/%s", basepath, d->d_name);
+ else
+ snprintf(pathname, PATH_MAX,
+ "%s/%s/%s", basepath,
+ subpath, d->d_name);
+
+ if (compare_file(src_map, src_st, pathname) == 0) {
+ str = g_strdup_printf("%s/%s",
+ subpath, d->d_name);
+ closedir(dir);
+ return str;
+ }
+ break;
+ case DT_UNKNOWN:
+ /*
+ * If there is no d_type support use fstatat()
+ * to check if d_name is directory
+ */
+ ret = fstatat(dirfd(dir), d->d_name, &buf, 0);
+ if (ret < 0)
+ continue;
+ if ((buf.st_mode & S_IFDIR) == 0)
+ continue;
+ /* fall through */
+ case DT_DIR:
+ if (!subpath)
+ strncpy(pathname, d->d_name, sizeof(pathname));
+ else
+ snprintf(pathname, sizeof(pathname),
+ "%s/%s", subpath, d->d_name);
+
+ str = find_origin(src_map, src_st, basepath, pathname);
+ if (str) {
+ closedir(dir);
+ return str;
+ }
+ break;
+ }
+ }
+
+ closedir(dir);
+
+ return NULL;
+}
+
+char *__connman_timezone_lookup(void)
+{
+ struct stat st;
+ void *map;
+ int fd;
+ char *zone;
+
+ zone = read_key_file(ETC_SYSCONFIG_CLOCK, "ZONE");
+
+ DBG("sysconfig zone %s", zone);
+
+ fd = open(ETC_LOCALTIME, O_RDONLY | O_CLOEXEC);
+ if (fd < 0) {
+ g_free(zone);
+ return NULL;
+ }
+
+ if (fstat(fd, &st) < 0)
+ goto done;
+
+ if (S_ISREG(st.st_mode)) {
+ map = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+ if (!map || map == MAP_FAILED) {
+ g_free(zone);
+ zone = NULL;
+
+ goto done;
+ }
+
+ if (zone) {
+ char pathname[PATH_MAX];
+
+ snprintf(pathname, PATH_MAX, "%s/%s",
+ USR_SHARE_ZONEINFO, zone);
+
+ if (compare_file(map, &st, pathname) != 0) {
+ g_free(zone);
+ zone = NULL;
+ }
+ }
+
+ if (!zone)
+ zone = find_origin(map, &st, USR_SHARE_ZONEINFO, NULL);
+
+ munmap(map, st.st_size);
+ } else {
+ g_free(zone);
+ zone = NULL;
+ }
+
+done:
+ close(fd);
+
+ DBG("localtime zone %s", zone);
+
+ return zone;
+}
+
+static int write_file(void *src_map, struct stat *src_st, const char *pathname)
+{
+ struct stat st;
+ int fd;
+ ssize_t written;
+
+ DBG("pathname %s", pathname);
+
+ if (lstat(pathname, &st) == 0) {
+ if (S_ISLNK(st.st_mode))
+ unlink(pathname);
+ }
+
+ fd = open(pathname, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0644);
+ if (fd < 0)
+ return -EIO;
+
+ written = write(fd, src_map, src_st->st_size);
+
+ close(fd);
+
+ if (written < 0)
+ return -EIO;
+
+ return 0;
+}
+
+int __connman_timezone_change(const char *zone)
+{
+ struct stat st;
+ char *map, pathname[PATH_MAX];
+ int fd, err;
+
+ DBG("zone %s", zone);
+
+ snprintf(pathname, PATH_MAX, "%s/%s", USR_SHARE_ZONEINFO, zone);
+
+ fd = open(pathname, O_RDONLY | O_CLOEXEC);
+ if (fd < 0)
+ return -EINVAL;
+
+ if (fstat(fd, &st) < 0) {
+ close(fd);
+ return -EIO;
+ }
+
+ map = mmap(0, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
+ if (!map || map == MAP_FAILED) {
+ close(fd);
+ return -EIO;
+ }
+
+ err = write_file(map, &st, ETC_LOCALTIME);
+
+ munmap(map, st.st_size);
+
+ close(fd);
+
+ return err;
+}
+
+static guint inotify_watch = 0;
+
+static gboolean inotify_data(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ char buffer[256];
+ void *ptr = buffer;
+ GIOStatus status;
+ gsize bytes_read;
+
+ DBG("");
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP)) {
+ inotify_watch = 0;
+ return FALSE;
+ }
+
+ status = g_io_channel_read_chars(channel, buffer, sizeof(buffer),
+ &bytes_read, NULL);
+
+ switch (status) {
+ case G_IO_STATUS_NORMAL:
+ break;
+ case G_IO_STATUS_AGAIN:
+ return TRUE;
+ default:
+ inotify_watch = 0;
+ return FALSE;
+ }
+
+ DBG("bytes read %zd", bytes_read);
+
+ while (bytes_read > 0) {
+ struct inotify_event *event = ptr;
+
+ if (bytes_read < sizeof(*event))
+ break;
+
+ ptr += sizeof(*event);
+ bytes_read -= sizeof(*event);
+
+ if (event->len == 0)
+ continue;
+
+ if (bytes_read < event->len)
+ break;
+
+ ptr += event->len;
+ bytes_read -= event->len;
+
+ if (g_strcmp0(event->name, "localtime") == 0)
+ __connman_clock_update_timezone();
+ }
+
+ return TRUE;
+}
+
+int __connman_timezone_init(void)
+{
+ GIOChannel *channel;
+ char *dirname;
+ int fd, wd;
+
+ DBG("");
+
+ fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);
+ if (fd < 0)
+ return -EIO;
+
+ channel = g_io_channel_unix_new(fd);
+ if (!channel) {
+ close(fd);
+ return -EIO;
+ }
+
+ g_io_channel_set_close_on_unref(channel, TRUE);
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ inotify_watch = g_io_add_watch(channel,
+ G_IO_IN | G_IO_HUP | G_IO_NVAL | G_IO_ERR,
+ inotify_data, NULL);
+
+ g_io_channel_unref(channel);
+
+ dirname = g_path_get_dirname(ETC_LOCALTIME);
+
+ wd = inotify_add_watch(fd, dirname, IN_DONT_FOLLOW |
+ IN_CLOSE_WRITE | IN_MOVED_TO);
+
+ g_free(dirname);
+
+ if (wd < 0)
+ return -EIO;
+
+ return 0;
+}
+
+void __connman_timezone_cleanup(void)
+{
+ DBG("");
+
+ if (inotify_watch > 0) {
+ g_source_remove(inotify_watch);
+ inotify_watch = 0;
+ }
+}
diff --git a/src/util.c b/src/util.c
new file mode 100644
index 0000000..da32cc5
--- /dev/null
+++ b/src/util.c
@@ -0,0 +1,88 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2014 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <inttypes.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <errno.h>
+#include <stdlib.h>
+
+#include "connman.h"
+
+#define URANDOM "/dev/urandom"
+
+int f = -1;
+
+int __connman_util_get_random(uint64_t *val)
+{
+ int r = 0;
+
+ if (!val)
+ return -EINVAL;
+
+ if (read(f, val, sizeof(uint64_t)) < 0) {
+ r = -errno;
+ connman_warn_once("Could not read from "URANDOM);
+ *val = random();
+ }
+
+ return r;
+}
+
+int __connman_util_init(void)
+{
+ int r = 0;
+
+ if (f > 0)
+ return 0;
+
+ f = open(URANDOM, O_RDONLY);
+ if (f < 0) {
+ r = -errno;
+ connman_warn("Could not open "URANDOM);
+ srandom(time(NULL));
+ } else {
+ uint64_t val;
+
+ r = __connman_util_get_random(&val);
+ if (r < 0)
+ srandom(time(NULL));
+ else
+ srandom(val);
+ }
+
+ return r;
+}
+
+void __connman_util_cleanup(void)
+{
+ if (f > 0)
+ close(f);
+
+ f = -1;
+}
diff --git a/src/utsname.c b/src/utsname.c
new file mode 100644
index 0000000..1dd5e0f
--- /dev/null
+++ b/src/utsname.c
@@ -0,0 +1,139 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+
+#include "connman.h"
+
+static GSList *driver_list = NULL;
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct connman_utsname_driver *driver1 = a;
+ const struct connman_utsname_driver *driver2 = b;
+
+ return driver2->priority - driver1->priority;
+}
+
+/**
+ * connman_utsname_driver_register:
+ * @driver: utsname driver definition
+ *
+ * Register a new utsname driver
+ *
+ * Returns: %0 on success
+ */
+int connman_utsname_driver_register(struct connman_utsname_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+
+ return 0;
+}
+
+/**
+ * connman_utsname_driver_unregister:
+ * @driver: utsname driver definition
+ *
+ * Remove a previously registered utsname driver
+ */
+void connman_utsname_driver_unregister(struct connman_utsname_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_remove(driver_list, driver);
+}
+
+/**
+ * connman_utsname_get_hostname:
+ *
+ * Returns current hostname
+ */
+const char *connman_utsname_get_hostname(void)
+{
+ GSList *list;
+
+ DBG("");
+
+ for (list = driver_list; list; list = list->next) {
+ struct connman_utsname_driver *driver = list->data;
+ const char *hostname;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (!driver->get_hostname)
+ continue;
+
+ hostname = driver->get_hostname();
+ if (hostname)
+ return hostname;
+ }
+
+ return NULL;
+}
+
+int __connman_utsname_set_hostname(const char *hostname)
+{
+ GSList *list;
+
+ DBG("hostname %s", hostname);
+
+ for (list = driver_list; list; list = list->next) {
+ struct connman_utsname_driver *driver = list->data;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (!driver->set_hostname)
+ continue;
+
+ if (driver->set_hostname(hostname) == 0)
+ break;
+ }
+
+ return 0;
+}
+
+int __connman_utsname_set_domainname(const char *domainname)
+{
+ GSList *list;
+
+ DBG("domainname %s", domainname);
+
+ for (list = driver_list; list; list = list->next) {
+ struct connman_utsname_driver *driver = list->data;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (!driver->set_domainname)
+ continue;
+
+ if (driver->set_domainname(domainname) == 0)
+ break;
+ }
+
+ return 0;
+}
diff --git a/src/wispr.c b/src/wispr.c
new file mode 100644
index 0000000..10f869b
--- /dev/null
+++ b/src/wispr.c
@@ -0,0 +1,1008 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+
+#include <gweb/gweb.h>
+
+#include "connman.h"
+
+#define STATUS_URL_IPV4 "http://ipv4.connman.net/online/status.html"
+#define STATUS_URL_IPV6 "http://ipv6.connman.net/online/status.html"
+
+struct connman_wispr_message {
+ bool has_error;
+ const char *current_element;
+ int message_type;
+ int response_code;
+ char *login_url;
+ char *abort_login_url;
+ char *logoff_url;
+ char *access_procedure;
+ char *access_location;
+ char *location_name;
+};
+
+enum connman_wispr_result {
+ CONNMAN_WISPR_RESULT_UNKNOWN = 0,
+ CONNMAN_WISPR_RESULT_LOGIN = 1,
+ CONNMAN_WISPR_RESULT_ONLINE = 2,
+ CONNMAN_WISPR_RESULT_FAILED = 3,
+};
+
+struct wispr_route {
+ char *address;
+ int if_index;
+};
+
+struct connman_wispr_portal_context {
+ struct connman_service *service;
+ enum connman_ipconfig_type type;
+ struct connman_wispr_portal *wispr_portal;
+
+ /* Portal/WISPr common */
+ GWeb *web;
+ unsigned int token;
+ guint request_id;
+
+ const char *status_url;
+
+ char *redirect_url;
+
+ /* WISPr specific */
+ GWebParser *wispr_parser;
+ struct connman_wispr_message wispr_msg;
+
+ char *wispr_username;
+ char *wispr_password;
+ char *wispr_formdata;
+
+ enum connman_wispr_result wispr_result;
+
+ GSList *route_list;
+
+ guint timeout;
+};
+
+struct connman_wispr_portal {
+ struct connman_wispr_portal_context *ipv4_context;
+ struct connman_wispr_portal_context *ipv6_context;
+};
+
+static bool wispr_portal_web_result(GWebResult *result, gpointer user_data);
+
+static GHashTable *wispr_portal_list = NULL;
+
+static void connman_wispr_message_init(struct connman_wispr_message *msg)
+{
+ DBG("");
+
+ msg->has_error = false;
+ msg->current_element = NULL;
+
+ msg->message_type = -1;
+ msg->response_code = -1;
+
+ g_free(msg->login_url);
+ msg->login_url = NULL;
+
+ g_free(msg->abort_login_url);
+ msg->abort_login_url = NULL;
+
+ g_free(msg->logoff_url);
+ msg->logoff_url = NULL;
+
+ g_free(msg->access_procedure);
+ msg->access_procedure = NULL;
+
+ g_free(msg->access_location);
+ msg->access_location = NULL;
+
+ g_free(msg->location_name);
+ msg->location_name = NULL;
+}
+
+static void free_wispr_routes(struct connman_wispr_portal_context *wp_context)
+{
+ while (wp_context->route_list) {
+ struct wispr_route *route = wp_context->route_list->data;
+
+ DBG("free route to %s if %d type %d", route->address,
+ route->if_index, wp_context->type);
+
+ switch (wp_context->type) {
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ connman_inet_del_host_route(route->if_index,
+ route->address);
+ break;
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ connman_inet_del_ipv6_host_route(route->if_index,
+ route->address);
+ break;
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ break;
+ }
+
+ g_free(route->address);
+ g_free(route);
+
+ wp_context->route_list =
+ g_slist_delete_link(wp_context->route_list,
+ wp_context->route_list);
+ }
+}
+
+static void free_connman_wispr_portal_context(
+ struct connman_wispr_portal_context *wp_context)
+{
+ DBG("context %p", wp_context);
+
+ if (!wp_context)
+ return;
+
+ if (wp_context->wispr_portal) {
+ if (wp_context->wispr_portal->ipv4_context == wp_context)
+ wp_context->wispr_portal->ipv4_context = NULL;
+
+ if (wp_context->wispr_portal->ipv6_context == wp_context)
+ wp_context->wispr_portal->ipv6_context = NULL;
+ }
+
+ if (wp_context->token > 0)
+ connman_proxy_lookup_cancel(wp_context->token);
+
+ if (wp_context->request_id > 0)
+ g_web_cancel_request(wp_context->web, wp_context->request_id);
+
+ if (wp_context->timeout > 0)
+ g_source_remove(wp_context->timeout);
+
+ if (wp_context->web)
+ g_web_unref(wp_context->web);
+
+ g_free(wp_context->redirect_url);
+
+ if (wp_context->wispr_parser)
+ g_web_parser_unref(wp_context->wispr_parser);
+
+ connman_wispr_message_init(&wp_context->wispr_msg);
+
+ g_free(wp_context->wispr_username);
+ g_free(wp_context->wispr_password);
+ g_free(wp_context->wispr_formdata);
+
+ free_wispr_routes(wp_context);
+
+ g_free(wp_context);
+}
+
+static struct connman_wispr_portal_context *create_wispr_portal_context(void)
+{
+ return g_try_new0(struct connman_wispr_portal_context, 1);
+}
+
+static void free_connman_wispr_portal(gpointer data)
+{
+ struct connman_wispr_portal *wispr_portal = data;
+
+ DBG("");
+
+ if (!wispr_portal)
+ return;
+
+ free_connman_wispr_portal_context(wispr_portal->ipv4_context);
+ free_connman_wispr_portal_context(wispr_portal->ipv6_context);
+
+ g_free(wispr_portal);
+}
+
+static const char *message_type_to_string(int message_type)
+{
+ switch (message_type) {
+ case 100:
+ return "Initial redirect message";
+ case 110:
+ return "Proxy notification";
+ case 120:
+ return "Authentication notification";
+ case 130:
+ return "Logoff notification";
+ case 140:
+ return "Response to Authentication Poll";
+ case 150:
+ return "Response to Abort Login";
+ }
+
+ return NULL;
+}
+
+static const char *response_code_to_string(int response_code)
+{
+ switch (response_code) {
+ case 0:
+ return "No error";
+ case 50:
+ return "Login succeeded";
+ case 100:
+ return "Login failed";
+ case 102:
+ return "RADIUS server error/timeout";
+ case 105:
+ return "RADIUS server not enabled";
+ case 150:
+ return "Logoff succeeded";
+ case 151:
+ return "Login aborted";
+ case 200:
+ return "Proxy detection/repeat operation";
+ case 201:
+ return "Authentication pending";
+ case 255:
+ return "Access gateway internal error";
+ }
+
+ return NULL;
+}
+
+static struct {
+ const char *str;
+ enum {
+ WISPR_ELEMENT_NONE = 0,
+ WISPR_ELEMENT_ACCESS_PROCEDURE = 1,
+ WISPR_ELEMENT_ACCESS_LOCATION = 2,
+ WISPR_ELEMENT_LOCATION_NAME = 3,
+ WISPR_ELEMENT_LOGIN_URL = 4,
+ WISPR_ELEMENT_ABORT_LOGIN_URL = 5,
+ WISPR_ELEMENT_MESSAGE_TYPE = 6,
+ WISPR_ELEMENT_RESPONSE_CODE = 7,
+ WISPR_ELEMENT_NEXT_URL = 8,
+ WISPR_ELEMENT_DELAY = 9,
+ WISPR_ELEMENT_REPLY_MESSAGE = 10,
+ WISPR_ELEMENT_LOGIN_RESULTS_URL = 11,
+ WISPR_ELEMENT_LOGOFF_URL = 12,
+ } element;
+} wispr_element_map[] = {
+ { "AccessProcedure", WISPR_ELEMENT_ACCESS_PROCEDURE },
+ { "AccessLocation", WISPR_ELEMENT_ACCESS_LOCATION },
+ { "LocationName", WISPR_ELEMENT_LOCATION_NAME },
+ { "LoginURL", WISPR_ELEMENT_LOGIN_URL },
+ { "AbortLoginURL", WISPR_ELEMENT_ABORT_LOGIN_URL },
+ { "MessageType", WISPR_ELEMENT_MESSAGE_TYPE },
+ { "ResponseCode", WISPR_ELEMENT_RESPONSE_CODE },
+ { "NextURL", WISPR_ELEMENT_NEXT_URL },
+ { "Delay", WISPR_ELEMENT_DELAY },
+ { "ReplyMessage", WISPR_ELEMENT_REPLY_MESSAGE },
+ { "LoginResultsURL", WISPR_ELEMENT_LOGIN_RESULTS_URL },
+ { "LogoffURL", WISPR_ELEMENT_LOGOFF_URL },
+ { NULL, WISPR_ELEMENT_NONE },
+};
+
+static void xml_wispr_start_element_handler(GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data, GError **error)
+{
+ struct connman_wispr_message *msg = user_data;
+
+ msg->current_element = element_name;
+}
+
+static void xml_wispr_end_element_handler(GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data, GError **error)
+{
+ struct connman_wispr_message *msg = user_data;
+
+ msg->current_element = NULL;
+}
+
+static void xml_wispr_text_handler(GMarkupParseContext *context,
+ const gchar *text, gsize text_len,
+ gpointer user_data, GError **error)
+{
+ struct connman_wispr_message *msg = user_data;
+ int i;
+
+ if (!msg->current_element)
+ return;
+
+ for (i = 0; wispr_element_map[i].str; i++) {
+ if (!g_str_equal(wispr_element_map[i].str, msg->current_element))
+ continue;
+
+ switch (wispr_element_map[i].element) {
+ case WISPR_ELEMENT_NONE:
+ case WISPR_ELEMENT_ACCESS_PROCEDURE:
+ g_free(msg->access_procedure);
+ msg->access_procedure = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_ACCESS_LOCATION:
+ g_free(msg->access_location);
+ msg->access_location = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_LOCATION_NAME:
+ g_free(msg->location_name);
+ msg->location_name = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_LOGIN_URL:
+ g_free(msg->login_url);
+ msg->login_url = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_ABORT_LOGIN_URL:
+ g_free(msg->abort_login_url);
+ msg->abort_login_url = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_MESSAGE_TYPE:
+ msg->message_type = atoi(text);
+ break;
+ case WISPR_ELEMENT_RESPONSE_CODE:
+ msg->response_code = atoi(text);
+ break;
+ case WISPR_ELEMENT_NEXT_URL:
+ case WISPR_ELEMENT_DELAY:
+ case WISPR_ELEMENT_REPLY_MESSAGE:
+ case WISPR_ELEMENT_LOGIN_RESULTS_URL:
+ break;
+ case WISPR_ELEMENT_LOGOFF_URL:
+ g_free(msg->logoff_url);
+ msg->logoff_url = g_strdup(text);
+ break;
+ }
+ }
+}
+
+static void xml_wispr_error_handler(GMarkupParseContext *context,
+ GError *error, gpointer user_data)
+{
+ struct connman_wispr_message *msg = user_data;
+
+ msg->has_error = true;
+}
+
+static const GMarkupParser xml_wispr_parser_handlers = {
+ xml_wispr_start_element_handler,
+ xml_wispr_end_element_handler,
+ xml_wispr_text_handler,
+ NULL,
+ xml_wispr_error_handler,
+};
+
+static void xml_wispr_parser_callback(const char *str, gpointer user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+ GMarkupParseContext *parser_context = NULL;
+ bool result;
+
+ DBG("");
+
+ parser_context = g_markup_parse_context_new(&xml_wispr_parser_handlers,
+ G_MARKUP_TREAT_CDATA_AS_TEXT,
+ &(wp_context->wispr_msg), NULL);
+
+ result = g_markup_parse_context_parse(parser_context,
+ str, strlen(str), NULL);
+ if (result)
+ g_markup_parse_context_end_parse(parser_context, NULL);
+
+ g_markup_parse_context_free(parser_context);
+}
+
+static void web_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static void wispr_portal_error(struct connman_wispr_portal_context *wp_context)
+{
+ DBG("Failed to proceed wispr/portal web request");
+
+ wp_context->wispr_result = CONNMAN_WISPR_RESULT_FAILED;
+}
+
+static void portal_manage_status(GWebResult *result,
+ struct connman_wispr_portal_context *wp_context)
+{
+ struct connman_service *service = wp_context->service;
+ enum connman_ipconfig_type type = wp_context->type;
+ const char *str = NULL;
+
+ DBG("");
+
+ /* We currently don't do anything with this info */
+ if (g_web_result_get_header(result, "X-ConnMan-Client-IP",
+ &str))
+ connman_info("Client-IP: %s", str);
+
+ if (g_web_result_get_header(result, "X-ConnMan-Client-Country",
+ &str))
+ connman_info("Client-Country: %s", str);
+
+ if (g_web_result_get_header(result, "X-ConnMan-Client-Region",
+ &str))
+ connman_info("Client-Region: %s", str);
+
+ if (g_web_result_get_header(result, "X-ConnMan-Client-Timezone",
+ &str))
+ connman_info("Client-Timezone: %s", str);
+
+ free_connman_wispr_portal_context(wp_context);
+
+ __connman_service_ipconfig_indicate_state(service,
+ CONNMAN_SERVICE_STATE_ONLINE, type);
+}
+
+static bool wispr_route_request(const char *address, int ai_family,
+ int if_index, gpointer user_data)
+{
+ int result = -1;
+ struct connman_wispr_portal_context *wp_context = user_data;
+ const char *gateway;
+ struct wispr_route *route;
+
+ gateway = __connman_ipconfig_get_gateway_from_index(if_index,
+ wp_context->type);
+
+ DBG("address %s if %d gw %s", address, if_index, gateway);
+
+ if (!gateway)
+ return false;
+
+ route = g_try_new0(struct wispr_route, 1);
+ if (route == 0) {
+ DBG("could not create struct");
+ return false;
+ }
+
+ switch (wp_context->type) {
+ case CONNMAN_IPCONFIG_TYPE_IPV4:
+ result = connman_inet_add_host_route(if_index, address,
+ gateway);
+ break;
+ case CONNMAN_IPCONFIG_TYPE_IPV6:
+ result = connman_inet_add_ipv6_host_route(if_index, address,
+ gateway);
+ break;
+ case CONNMAN_IPCONFIG_TYPE_UNKNOWN:
+ case CONNMAN_IPCONFIG_TYPE_ALL:
+ break;
+ }
+
+ if (result < 0) {
+ g_free(route);
+ return false;
+ }
+
+ route->address = g_strdup(address);
+ route->if_index = if_index;
+ wp_context->route_list = g_slist_prepend(wp_context->route_list, route);
+
+ return true;
+}
+
+static void wispr_portal_request_portal(
+ struct connman_wispr_portal_context *wp_context)
+{
+ DBG("");
+
+ wp_context->request_id = g_web_request_get(wp_context->web,
+ wp_context->status_url,
+ wispr_portal_web_result,
+ wispr_route_request,
+ wp_context);
+
+ if (wp_context->request_id == 0)
+ wispr_portal_error(wp_context);
+}
+
+static bool wispr_input(const guint8 **data, gsize *length,
+ gpointer user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+ GString *buf;
+ gsize count;
+
+ DBG("");
+
+ buf = g_string_sized_new(100);
+
+ g_string_append(buf, "button=Login&UserName=");
+ g_string_append_uri_escaped(buf, wp_context->wispr_username,
+ NULL, FALSE);
+ g_string_append(buf, "&Password=");
+ g_string_append_uri_escaped(buf, wp_context->wispr_password,
+ NULL, FALSE);
+ g_string_append(buf, "&FNAME=0&OriginatingServer=");
+ g_string_append_uri_escaped(buf, wp_context->status_url, NULL, FALSE);
+
+ count = buf->len;
+
+ g_free(wp_context->wispr_formdata);
+ wp_context->wispr_formdata = g_string_free(buf, FALSE);
+
+ *data = (guint8 *) wp_context->wispr_formdata;
+ *length = count;
+
+ return false;
+}
+
+static void wispr_portal_browser_reply_cb(struct connman_service *service,
+ bool authentication_done,
+ const char *error, void *user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+
+ DBG("");
+
+ if (!service || !wp_context)
+ return;
+
+ if (!authentication_done) {
+ wispr_portal_error(wp_context);
+ free_wispr_routes(wp_context);
+ return;
+ }
+
+ /* Restarting the test */
+ __connman_wispr_start(service, wp_context->type);
+}
+
+static void wispr_portal_request_wispr_login(struct connman_service *service,
+ bool success,
+ const char *ssid, int ssid_len,
+ const char *username, const char *password,
+ bool wps, const char *wpspin,
+ const char *error, void *user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+
+ DBG("");
+
+ if (error) {
+ if (g_strcmp0(error,
+ "net.connman.Agent.Error.LaunchBrowser") == 0) {
+ if (__connman_agent_request_browser(service,
+ wispr_portal_browser_reply_cb,
+ wp_context->redirect_url,
+ wp_context) == -EINPROGRESS)
+ return;
+ }
+
+ free_connman_wispr_portal_context(wp_context);
+ return;
+ }
+
+ g_free(wp_context->wispr_username);
+ wp_context->wispr_username = g_strdup(username);
+
+ g_free(wp_context->wispr_password);
+ wp_context->wispr_password = g_strdup(password);
+
+ wp_context->request_id = g_web_request_post(wp_context->web,
+ wp_context->wispr_msg.login_url,
+ "application/x-www-form-urlencoded",
+ wispr_input, wispr_portal_web_result,
+ wp_context);
+
+ connman_wispr_message_init(&wp_context->wispr_msg);
+}
+
+static bool wispr_manage_message(GWebResult *result,
+ struct connman_wispr_portal_context *wp_context)
+{
+ DBG("Message type: %s (%d)",
+ message_type_to_string(wp_context->wispr_msg.message_type),
+ wp_context->wispr_msg.message_type);
+ DBG("Response code: %s (%d)",
+ response_code_to_string(wp_context->wispr_msg.response_code),
+ wp_context->wispr_msg.response_code);
+
+ if (wp_context->wispr_msg.access_procedure)
+ DBG("Access procedure: %s",
+ wp_context->wispr_msg.access_procedure);
+ if (wp_context->wispr_msg.access_location)
+ DBG("Access location: %s",
+ wp_context->wispr_msg.access_location);
+ if (wp_context->wispr_msg.location_name)
+ DBG("Location name: %s",
+ wp_context->wispr_msg.location_name);
+ if (wp_context->wispr_msg.login_url)
+ DBG("Login URL: %s", wp_context->wispr_msg.login_url);
+ if (wp_context->wispr_msg.abort_login_url)
+ DBG("Abort login URL: %s",
+ wp_context->wispr_msg.abort_login_url);
+ if (wp_context->wispr_msg.logoff_url)
+ DBG("Logoff URL: %s", wp_context->wispr_msg.logoff_url);
+
+ switch (wp_context->wispr_msg.message_type) {
+ case 100:
+ DBG("Login required");
+
+ wp_context->wispr_result = CONNMAN_WISPR_RESULT_LOGIN;
+
+ if (__connman_agent_request_login_input(wp_context->service,
+ wispr_portal_request_wispr_login,
+ wp_context) != -EINPROGRESS)
+ wispr_portal_error(wp_context);
+ else
+ return true;
+
+ break;
+ case 120: /* Falling down */
+ case 140:
+ if (wp_context->wispr_msg.response_code == 50) {
+ wp_context->wispr_result = CONNMAN_WISPR_RESULT_ONLINE;
+
+ g_free(wp_context->wispr_username);
+ wp_context->wispr_username = NULL;
+
+ g_free(wp_context->wispr_password);
+ wp_context->wispr_password = NULL;
+
+ g_free(wp_context->wispr_formdata);
+ wp_context->wispr_formdata = NULL;
+
+ wispr_portal_request_portal(wp_context);
+
+ return true;
+ } else
+ wispr_portal_error(wp_context);
+
+ break;
+ default:
+ break;
+ }
+
+ return false;
+}
+
+static bool wispr_portal_web_result(GWebResult *result, gpointer user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+ const char *redirect = NULL;
+ const guint8 *chunk = NULL;
+ const char *str = NULL;
+ guint16 status;
+ gsize length;
+
+ DBG("");
+
+ if (wp_context->wispr_result != CONNMAN_WISPR_RESULT_ONLINE) {
+ g_web_result_get_chunk(result, &chunk, &length);
+
+ if (length > 0) {
+ g_web_parser_feed_data(wp_context->wispr_parser,
+ chunk, length);
+ return true;
+ }
+
+ g_web_parser_end_data(wp_context->wispr_parser);
+
+ if (wp_context->wispr_msg.message_type >= 0) {
+ if (wispr_manage_message(result, wp_context))
+ goto done;
+ }
+ }
+
+ status = g_web_result_get_status(result);
+
+ DBG("status: %03u", status);
+
+ switch (status) {
+ case 000:
+ __connman_agent_request_browser(wp_context->service,
+ wispr_portal_browser_reply_cb,
+ wp_context->status_url, wp_context);
+ break;
+ case 200:
+ if (wp_context->wispr_msg.message_type >= 0)
+ break;
+
+ if (g_web_result_get_header(result, "X-ConnMan-Status",
+ &str)) {
+ portal_manage_status(result, wp_context);
+ return false;
+ } else
+ __connman_agent_request_browser(wp_context->service,
+ wispr_portal_browser_reply_cb,
+ wp_context->redirect_url, wp_context);
+
+ break;
+ case 302:
+ if (!g_web_supports_tls() ||
+ !g_web_result_get_header(result, "Location",
+ &redirect)) {
+
+ __connman_agent_request_browser(wp_context->service,
+ wispr_portal_browser_reply_cb,
+ wp_context->status_url, wp_context);
+ break;
+ }
+
+ DBG("Redirect URL: %s", redirect);
+
+ wp_context->redirect_url = g_strdup(redirect);
+
+ wp_context->request_id = g_web_request_get(wp_context->web,
+ redirect, wispr_portal_web_result,
+ wispr_route_request, wp_context);
+
+ goto done;
+ case 400:
+ case 404:
+ if (__connman_service_online_check_failed(wp_context->service,
+ wp_context->type) == 0) {
+ wispr_portal_error(wp_context);
+ free_connman_wispr_portal_context(wp_context);
+ return false;
+ }
+
+ break;
+ case 505:
+ __connman_agent_request_browser(wp_context->service,
+ wispr_portal_browser_reply_cb,
+ wp_context->status_url, wp_context);
+ break;
+ default:
+ break;
+ }
+
+ free_wispr_routes(wp_context);
+ wp_context->request_id = 0;
+done:
+ wp_context->wispr_msg.message_type = -1;
+ return false;
+}
+
+static void proxy_callback(const char *proxy, void *user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+
+ DBG("proxy %s", proxy);
+
+ if (!wp_context)
+ return;
+
+ wp_context->token = 0;
+
+ if (proxy && g_strcmp0(proxy, "DIRECT") != 0) {
+ if (g_str_has_prefix(proxy, "PROXY")) {
+ proxy += 5;
+ for (; *proxy == ' ' && *proxy != '\0'; proxy++);
+ }
+ g_web_set_proxy(wp_context->web, proxy);
+ }
+
+ g_web_set_accept(wp_context->web, NULL);
+ g_web_set_user_agent(wp_context->web, "ConnMan/%s wispr", VERSION);
+ g_web_set_close_connection(wp_context->web, TRUE);
+
+ connman_wispr_message_init(&wp_context->wispr_msg);
+
+ wp_context->wispr_parser = g_web_parser_new(
+ "<WISPAccessGatewayParam",
+ "WISPAccessGatewayParam>",
+ xml_wispr_parser_callback, wp_context);
+
+ wispr_portal_request_portal(wp_context);
+}
+
+static gboolean no_proxy_callback(gpointer user_data)
+{
+ struct connman_wispr_portal_context *wp_context = user_data;
+
+ wp_context->timeout = 0;
+
+ proxy_callback("DIRECT", wp_context);
+
+ return FALSE;
+}
+
+static int wispr_portal_detect(struct connman_wispr_portal_context *wp_context)
+{
+ enum connman_service_proxy_method proxy_method;
+ enum connman_service_type service_type;
+ char *interface = NULL;
+ char **nameservers = NULL;
+ int if_index;
+ int err = 0;
+ int i;
+
+ DBG("wispr/portal context %p", wp_context);
+ DBG("service %p", wp_context->service);
+
+ service_type = connman_service_get_type(wp_context->service);
+
+ switch (service_type) {
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ break;
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ case CONNMAN_SERVICE_TYPE_P2P:
+ case CONNMAN_SERVICE_TYPE_LOWPAN:
+ return -EOPNOTSUPP;
+ }
+
+ interface = connman_service_get_interface(wp_context->service);
+ if (!interface)
+ return -EINVAL;
+
+ DBG("interface %s", interface);
+
+ if_index = connman_inet_ifindex(interface);
+ if (if_index < 0) {
+ DBG("Could not get ifindex");
+ err = -EINVAL;
+ goto done;
+ }
+
+ nameservers = connman_service_get_nameservers(wp_context->service);
+ if (!nameservers) {
+ DBG("Could not get nameservers");
+ err = -EINVAL;
+ goto done;
+ }
+
+ wp_context->web = g_web_new(if_index);
+ if (!wp_context->web) {
+ DBG("Could not set up GWeb");
+ err = -ENOMEM;
+ goto done;
+ }
+
+ if (getenv("CONNMAN_WEB_DEBUG"))
+ g_web_set_debug(wp_context->web, web_debug, "WEB");
+
+ if (wp_context->type == CONNMAN_IPCONFIG_TYPE_IPV4) {
+ g_web_set_address_family(wp_context->web, AF_INET);
+ wp_context->status_url = STATUS_URL_IPV4;
+ } else {
+ g_web_set_address_family(wp_context->web, AF_INET6);
+ wp_context->status_url = STATUS_URL_IPV6;
+ }
+
+ for (i = 0; nameservers[i]; i++)
+ g_web_add_nameserver(wp_context->web, nameservers[i]);
+
+ proxy_method = connman_service_get_proxy_method(wp_context->service);
+
+ if (proxy_method != CONNMAN_SERVICE_PROXY_METHOD_DIRECT) {
+ wp_context->token = connman_proxy_lookup(interface,
+ wp_context->status_url,
+ wp_context->service,
+ proxy_callback, wp_context);
+
+ if (wp_context->token == 0) {
+ err = -EINVAL;
+ free_connman_wispr_portal_context(wp_context);
+ }
+ } else if (wp_context->timeout == 0) {
+ wp_context->timeout =
+ g_timeout_add_seconds(0, no_proxy_callback, wp_context);
+ }
+
+done:
+ g_strfreev(nameservers);
+
+ g_free(interface);
+ return err;
+}
+
+int __connman_wispr_start(struct connman_service *service,
+ enum connman_ipconfig_type type)
+{
+ struct connman_wispr_portal_context *wp_context = NULL;
+ struct connman_wispr_portal *wispr_portal = NULL;
+ int index;
+
+ DBG("service %p", service);
+
+ if (!wispr_portal_list)
+ return -EINVAL;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -EINVAL;
+
+ wispr_portal = g_hash_table_lookup(wispr_portal_list,
+ GINT_TO_POINTER(index));
+ if (!wispr_portal) {
+ wispr_portal = g_try_new0(struct connman_wispr_portal, 1);
+ if (!wispr_portal)
+ return -ENOMEM;
+
+ g_hash_table_replace(wispr_portal_list,
+ GINT_TO_POINTER(index), wispr_portal);
+ }
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ wp_context = wispr_portal->ipv4_context;
+ else if (type == CONNMAN_IPCONFIG_TYPE_IPV6)
+ wp_context = wispr_portal->ipv6_context;
+ else
+ return -EINVAL;
+
+ /* If there is already an existing context, we wipe it */
+ if (wp_context)
+ free_connman_wispr_portal_context(wp_context);
+
+ wp_context = create_wispr_portal_context();
+ if (!wp_context)
+ return -ENOMEM;
+
+ wp_context->service = service;
+ wp_context->type = type;
+ wp_context->wispr_portal = wispr_portal;
+
+ if (type == CONNMAN_IPCONFIG_TYPE_IPV4)
+ wispr_portal->ipv4_context = wp_context;
+ else
+ wispr_portal->ipv6_context = wp_context;
+
+ return wispr_portal_detect(wp_context);
+}
+
+void __connman_wispr_stop(struct connman_service *service)
+{
+ int index;
+
+ DBG("service %p", service);
+
+ if (!wispr_portal_list)
+ return;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return;
+
+ g_hash_table_remove(wispr_portal_list, GINT_TO_POINTER(index));
+}
+
+int __connman_wispr_init(void)
+{
+ DBG("");
+
+ wispr_portal_list = g_hash_table_new_full(g_direct_hash,
+ g_direct_equal, NULL,
+ free_connman_wispr_portal);
+
+ return 0;
+}
+
+void __connman_wispr_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(wispr_portal_list);
+ wispr_portal_list = NULL;
+}
diff --git a/src/wpad.c b/src/wpad.c
new file mode 100644
index 0000000..d40959b
--- /dev/null
+++ b/src/wpad.c
@@ -0,0 +1,217 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gweb/gresolv.h>
+
+#include "connman.h"
+
+struct connman_wpad {
+ struct connman_service *service;
+ GResolv *resolv;
+ char *hostname;
+ char **addrlist;
+};
+
+static GHashTable *wpad_list = NULL;
+
+static void resolv_debug(const char *str, void *data)
+{
+ connman_info("%s: %s\n", (const char *) data, str);
+}
+
+static void free_wpad(gpointer data)
+{
+ struct connman_wpad *wpad = data;
+
+ g_resolv_unref(wpad->resolv);
+
+ g_strfreev(wpad->addrlist);
+ g_free(wpad->hostname);
+ g_free(wpad);
+}
+
+static void download_pac(struct connman_wpad *wpad, const char *target)
+{
+}
+
+static void wpad_result(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+ struct connman_wpad *wpad = user_data;
+ const char *ptr;
+ char *hostname;
+
+ DBG("status %d", status);
+
+ if (status == G_RESOLV_RESULT_STATUS_SUCCESS) {
+ char *url;
+
+ if (!results || g_strv_length(results) == 0)
+ goto failed;
+
+ url = g_strdup_printf("http://%s/wpad.dat", wpad->hostname);
+
+ __connman_service_set_proxy_autoconfig(wpad->service, url);
+
+ wpad->addrlist = g_strdupv(results);
+ if (wpad->addrlist)
+ download_pac(wpad, "wpad.dat");
+
+ g_free(url);
+
+ __connman_wispr_start(wpad->service,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+
+ return;
+ }
+
+ hostname = wpad->hostname;
+
+ if (strlen(hostname) < 6)
+ goto failed;
+
+ ptr = strchr(hostname + 5, '.');
+ if (!ptr || strlen(ptr) < 2)
+ goto failed;
+
+ if (!strchr(ptr + 1, '.'))
+ goto failed;
+
+ wpad->hostname = g_strdup_printf("wpad.%s", ptr + 1);
+ g_free(hostname);
+
+ DBG("hostname %s", wpad->hostname);
+
+ g_resolv_lookup_hostname(wpad->resolv, wpad->hostname,
+ wpad_result, wpad);
+
+ return;
+
+failed:
+ connman_service_set_proxy_method(wpad->service,
+ CONNMAN_SERVICE_PROXY_METHOD_DIRECT);
+
+ __connman_wispr_start(wpad->service,
+ CONNMAN_IPCONFIG_TYPE_IPV4);
+}
+
+int __connman_wpad_start(struct connman_service *service)
+{
+ struct connman_wpad *wpad;
+ const char *domainname;
+ char **nameservers;
+ int index;
+ int i;
+
+ DBG("service %p", service);
+
+ if (!wpad_list)
+ return -EINVAL;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return -EINVAL;
+
+ domainname = connman_service_get_domainname(service);
+ if (!domainname)
+ return -EINVAL;
+
+ nameservers = connman_service_get_nameservers(service);
+ if (!nameservers)
+ return -EINVAL;
+
+ wpad = g_try_new0(struct connman_wpad, 1);
+ if (!wpad) {
+ g_strfreev(nameservers);
+ return -ENOMEM;
+ }
+
+ wpad->service = service;
+ wpad->resolv = g_resolv_new(index);
+ if (!wpad->resolv) {
+ g_strfreev(nameservers);
+ g_free(wpad);
+ return -ENOMEM;
+ }
+
+ if (getenv("CONNMAN_RESOLV_DEBUG"))
+ g_resolv_set_debug(wpad->resolv, resolv_debug, "RESOLV");
+
+ for (i = 0; nameservers[i]; i++)
+ g_resolv_add_nameserver(wpad->resolv, nameservers[i], 53, 0);
+
+ g_strfreev(nameservers);
+
+ wpad->hostname = g_strdup_printf("wpad.%s", domainname);
+
+ DBG("hostname %s", wpad->hostname);
+
+ g_resolv_lookup_hostname(wpad->resolv, wpad->hostname,
+ wpad_result, wpad);
+
+ connman_service_ref(service);
+ g_hash_table_replace(wpad_list, GINT_TO_POINTER(index), wpad);
+
+ return 0;
+}
+
+void __connman_wpad_stop(struct connman_service *service)
+{
+ int index;
+
+ DBG("service %p", service);
+
+ if (!wpad_list)
+ return;
+
+ index = __connman_service_get_index(service);
+ if (index < 0)
+ return;
+
+ if (g_hash_table_remove(wpad_list, GINT_TO_POINTER(index)))
+ connman_service_unref(service);
+}
+
+int __connman_wpad_init(void)
+{
+ DBG("");
+
+ wpad_list = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_wpad);
+
+ return 0;
+}
+
+void __connman_wpad_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(wpad_list);
+ wpad_list = NULL;
+}
diff --git a/test/backtrace b/test/backtrace
new file mode 100755
index 0000000..c906f36
--- /dev/null
+++ b/test/backtrace
@@ -0,0 +1,57 @@
+#!/usr/bin/python
+
+import os
+import re
+import sys
+import subprocess
+
+if (len(sys.argv) < 3):
+ print "Usage: %s [binary] [log]" % (sys.argv[0])
+ sys.exit(1)
+
+binary = sys.argv[1]
+count = 0
+frames = []
+addrs = []
+
+log_file = open(sys.argv[2], 'r')
+
+# Extract addresses
+for line in log_file:
+ matchobj = re.compile(r'\[(0x[0-9a-f]+)\]$').search(line)
+ if matchobj:
+ addrs.append(matchobj.group(1))
+
+log_file.close()
+
+# Feed into addr2line
+command = ['addr2line', '--demangle', '--functions', '--basename',
+ '-e', binary]
+command.extend(addrs)
+
+p = subprocess.Popen(command, shell=False, bufsize=0,
+ stdin=subprocess.PIPE, stdout=subprocess.PIPE, close_fds=True)
+(child_stdin, child_stdout) = (p.stdin, p.stdout)
+
+child_stdin.close()
+
+# Backtrace display
+for line in child_stdout:
+
+ if line.startswith("??"):
+ continue
+
+ line = line.strip()
+
+ frames.append(line)
+
+child_stdout.close()
+
+frame_count = len(frames);
+
+count = 0
+print "-------- backtrace --------"
+while count < frame_count:
+ print "[%d]: %s() [%s]" % (count/2, frames[count], frames[count + 1])
+ count = count + 2
+print "---------------------------"
diff --git a/test/connect-provider b/test/connect-provider
new file mode 100755
index 0000000..15128c8
--- /dev/null
+++ b/test/connect-provider
@@ -0,0 +1,73 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 4):
+ print "Usage: %s <type> ... " % (sys.argv[0])
+ print " type: openconnect"
+ print " <name> <host> <domain> <cookie> [servercert]"
+ print " type: openvpn"
+ print " <name> <host> <domain> [<cafile> <certfile> <keyfile>]"
+ print " type: pptp"
+ print " <name> <host> <domain> <user> <password>"
+ print " type: l2tp"
+ print " <name> <host> <domain> <user> <password>"
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+print "Attempting to connect service %s" % (sys.argv[3])
+
+if sys.argv[1] == "openconnect":
+ if (len(sys.argv) > 6):
+ path = manager.ConnectProvider(({ "Type": "openconnect",
+ "Name": sys.argv[2],
+ "Host": sys.argv[3],
+ "VPN.Domain": sys.argv[4],
+ "OpenConnect.Cookie": sys.argv[5],
+ "OpenConnect.ServerCert": sys.argv[6]}))
+ else:
+ path = manager.ConnectProvider(({ "Type": "openconnect",
+ "Name": sys.argv[2],
+ "Host": sys.argv[3],
+ "VPN.Domain": sys.argv[4],
+ "OpenConnect.Cookie": sys.argv[5]}))
+elif sys.argv[1] == "openvpn":
+ if (len(sys.argv) < 6):
+ path = manager.ConnectProvider(({ "Type": "openvpn",
+ "Name": sys.argv[2],
+ "Host": sys.argv[3],
+ "VPN.Domain": sys.argv[4] }))
+ else:
+ path = manager.ConnectProvider(({ "Type": "openvpn",
+ "Name": sys.argv[2],
+ "Host": sys.argv[3],
+ "VPN.Domain": sys.argv[4],
+ "OpenVPN.CACert": sys.argv[5],
+ "OpenVPN.Cert": sys.argv[6],
+ "OpenVPN.Key": sys.argv[7]}))
+
+elif sys.argv[1] == "pptp":
+ path = manager.ConnectProvider(({ "Type": "pptp",
+ "Name": sys.argv[2],
+ "Host": sys.argv[3],
+ "VPN.Domain": sys.argv[4],
+ "PPTP.User": sys.argv[5],
+ "PPTP.Password": sys.argv[6]}))
+elif sys.argv[1] == "l2tp":
+ path = manager.ConnectProvider(({ "Type": "l2tp",
+ "Name": sys.argv[2],
+ "Host": sys.argv[3],
+ "VPN.Domain": sys.argv[4],
+ "L2TP.User": sys.argv[5],
+ "L2TP.Password": sys.argv[6]}))
+
+else:
+ print "Unknown VPN type"
+ sys.exit(1)
+
+print "VPN service path is %s" %(path)
diff --git a/test/disable-tethering b/test/disable-tethering
new file mode 100755
index 0000000..a3d5908
--- /dev/null
+++ b/test/disable-tethering
@@ -0,0 +1,40 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) != 2):
+ print "Usage: %s type" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('net.connman', "/"),
+ 'net.connman.Manager')
+
+def technology_disable_tethering(path, tech_type):
+ tech = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Technology")
+
+ properties = tech.GetProperties()
+
+ for key in properties.keys():
+ if key in ["Type"]:
+ if properties[key] == tech_type:
+ print "Disabling %s tethering" % tech_type
+ tech.SetProperty("Tethering", dbus.Boolean(0))
+
+ return tech_type
+ else:
+ return None
+
+technologies = manager.GetTechnologies()
+tech = None
+
+for path,_ in technologies:
+ tech = technology_disable_tethering(path, sys.argv[1])
+ if tech != None:
+ break;
+
+if tech == None:
+ print "Failed to disable %s tethering" % (sys.argv[1])
diff --git a/test/enable-tethering b/test/enable-tethering
new file mode 100755
index 0000000..cbcd4e7
--- /dev/null
+++ b/test/enable-tethering
@@ -0,0 +1,54 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) >= 3 and len(sys.argv) != 4 and sys.argv[1] == "wifi"):
+ print "Usage: %s wifi [SSID] [passphrase]" % (sys.argv[0])
+ sys.exit(1)
+elif (len(sys.argv) < 2):
+ print "Usage: %s type" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('net.connman', "/"),
+ 'net.connman.Manager')
+
+def technology_enable_tethering(path, tech_type, ssid, psk):
+ tech = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Technology")
+
+ properties = tech.GetProperties()
+
+ for key in properties.keys():
+ if key in ["Type"]:
+ if properties[key] == tech_type:
+ if len(ssid) > 0:
+ tech.SetProperty("TetheringIdentifier",
+ ssid)
+ if len(psk) > 0:
+ tech.SetProperty("TetheringPassphrase",
+ psk)
+ print "Enabling %s tethering" % tech_type
+ tech.SetProperty("Tethering", dbus.Boolean(1))
+
+ return tech_type
+ else:
+ return None
+
+technologies = manager.GetTechnologies()
+tech = None
+
+for path,_ in technologies:
+ if (len(sys.argv) == 4):
+ tech = technology_enable_tethering(path,
+ sys.argv[1], sys.argv[2], sys.argv[3])
+ else:
+ tech = technology_enable_tethering(path, sys.argv[1], "", "")
+
+ if tech != None:
+ break;
+
+if tech == None:
+ print "Failed to enable %s tethering" % (sys.argv[1])
diff --git a/test/get-global-timeservers b/test/get-global-timeservers
new file mode 100755
index 0000000..adcf175
--- /dev/null
+++ b/test/get-global-timeservers
@@ -0,0 +1,12 @@
+#!/usr/bin/python
+
+import dbus
+
+bus = dbus.SystemBus()
+
+clock = dbus.Interface(bus.get_object('net.connman', '/'),
+ 'net.connman.Clock')
+
+properties = clock.GetProperties()
+
+print "Timeserver is %s" % (properties["Timeservers"])
diff --git a/test/get-proxy-autoconfig b/test/get-proxy-autoconfig
new file mode 100755
index 0000000..6709a9e
--- /dev/null
+++ b/test/get-proxy-autoconfig
@@ -0,0 +1,37 @@
+#!/usr/bin/python
+
+import dbus
+import urllib
+
+def get_pac(url):
+ conn = urllib.urlopen(url, proxies={})
+ data = conn.read()
+ print data
+ conn.close()
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('net.connman', '/'),
+ 'net.connman.Manager')
+
+services = manager.GetServices()
+
+for entry in services:
+ path = entry[0]
+ properties = entry[1]
+
+ proxy = properties["Proxy"]
+
+ if "Method" in proxy:
+ print "[ %s ]" % (path)
+
+ method = proxy["Method"]
+ print "Method = %s" % (method)
+
+ if method in ["auto"]:
+ url = proxy["URL"]
+ print "URL = %s" % (url)
+ print
+ get_pac(url)
+ else:
+ print
diff --git a/test/get-services b/test/get-services
new file mode 100755
index 0000000..0956480
--- /dev/null
+++ b/test/get-services
@@ -0,0 +1,58 @@
+#!/usr/bin/python
+
+import dbus
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ val += " " + str(i)
+ val += " ]"
+ return val
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('net.connman', '/'),
+ 'net.connman.Manager')
+
+services = manager.GetServices()
+
+for entry in services:
+ path = entry[0]
+ properties = entry[1]
+
+ print "[ %s ]" % (path)
+
+ for key in properties.keys():
+ if key in ["IPv4", "IPv4.Configuration",
+ "IPv6", "IPv6.Configuration",
+ "Proxy", "Proxy.Configuration",
+ "Ethernet", "Provider"]:
+ val = extract_values(properties[key])
+ elif key in ["Nameservers", "Nameservers.Configuration",
+ "Domains", "Domains.Configuration",
+ "Security"]:
+ val = extract_list(properties[key])
+ elif key in ["Favorite", "Immutable", "AutoConnect",
+ "PassphraseRequired"]:
+ if properties[key] == dbus.Boolean(1):
+ val = "true"
+ else:
+ val = "false"
+ elif key in ["Strength"]:
+ val = int(properties[key])
+ else:
+ val = str(properties[key])
+ print " %s = %s" % (key, val)
+
+ print
diff --git a/test/get-state b/test/get-state
new file mode 100755
index 0000000..75d5a16
--- /dev/null
+++ b/test/get-state
@@ -0,0 +1,12 @@
+#!/usr/bin/python
+
+import dbus
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('net.connman', "/"),
+ 'net.connman.Manager')
+
+properties = manager.GetProperties()
+
+print "System is %s" % (properties["State"])
diff --git a/test/list-services b/test/list-services
new file mode 100755
index 0000000..6be4945
--- /dev/null
+++ b/test/list-services
@@ -0,0 +1,60 @@
+#!/usr/bin/python
+
+import dbus
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["PrefixLength"]:
+ val += "%s" % (int(values[key]))
+ else:
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ val += " " + str(i)
+ val += " ]"
+ return val
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+for path, properties in manager.GetServices():
+ service = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Service")
+ identifier = path[path.rfind("/") + 1:]
+ print "[ %s ]" % (identifier)
+
+ for key in properties.keys():
+ if key in ["IPv4", "IPv4.Configuration",
+ "IPv6", "IPv6.Configuration",
+ "Proxy", "Proxy.Configuration",
+ "Ethernet", "Provider"]:
+ val = extract_values(properties[key])
+ elif key in ["Nameservers", "Nameservers.Configuration",
+ "Domains", "Domains.Configuration",
+ "Timeservers", "Timeservers.Configuration",
+ "Security"]:
+ val = extract_list(properties[key])
+ elif key in ["Favorite", "Immutable", "AutoConnect",
+ "LoginRequired", "PassphraseRequired"]:
+ if properties[key] == dbus.Boolean(1):
+ val = "true"
+ else:
+ val = "false"
+ elif key in ["Strength"]:
+ val = int(properties[key])
+ else:
+ val = properties[key]
+ print " %s = %s" % (key, val)
+
+ print
diff --git a/test/monitor-connman b/test/monitor-connman
new file mode 100755
index 0000000..1b3b84c
--- /dev/null
+++ b/test/monitor-connman
@@ -0,0 +1,87 @@
+#!/usr/bin/python
+
+import gobject
+
+import dbus
+import dbus.mainloop.glib
+
+from dbus.lowlevel import MethodCallMessage, HANDLER_RESULT_NOT_YET_HANDLED
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ if type(i).__name__ == 'Dictionary':
+ val = extract_values(i)
+ else:
+ val += " " + str(i)
+ val += " ]"
+ return val
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["PrefixLength"]:
+ val += "%s" % (int(values[key]))
+ elif key in ["IPv4", "IPv6", "Ethernet" ]:
+ val += extract_values(values[key])
+ elif key in [ "AllowedBearers" ]:
+ val += extract_list(values[key])
+ else:
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract(name, value):
+ val = None
+
+ if name in ["Strength", "Priority"]:
+ val = int(value)
+ elif name in ["IPv4", "IPv6", "Ethernet", "Proxy" ]:
+ val = extract_values(value)
+ elif name in ["Services", "Technologies",
+ "Nameservers", "Domains", "Timeservers"]:
+ val = extract_list(value)
+ else:
+ val = str(value)
+
+ return val
+
+def property_changed(name, value, path, interface):
+ iface = interface[interface.rfind(".") + 1:]
+ val = extract(name, value)
+
+ print "{%s} [%s] %s = %s" % (iface, path, name, val)
+
+def message_filter(connection, message):
+ if not isinstance(message, MethodCallMessage):
+ return HANDLER_RESULT_NOT_YET_HANDLED
+
+ interface = message.get_interface()
+ path = message.get_path()
+ name = message.get_member()
+ args = message.get_args_list()
+
+ property_changed(name, args, path, interface)
+
+if __name__ == '__main__':
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ bus = dbus.SystemBus()
+
+ bus.add_signal_receiver(property_changed,
+ bus_name="net.connman",
+ signal_name = "PropertyChanged",
+ path_keyword="path",
+ interface_keyword="interface")
+
+ bus.add_match_string("member=Change,interface=net.connman.Session")
+ bus.add_match_string("member=Update,interface=net.connman.Notification")
+ bus.add_message_filter(message_filter)
+
+ mainloop = gobject.MainLoop()
+
+ mainloop.run()
diff --git a/test/monitor-services b/test/monitor-services
new file mode 100755
index 0000000..9476bf8
--- /dev/null
+++ b/test/monitor-services
@@ -0,0 +1,106 @@
+#!/usr/bin/python
+
+import gobject
+
+import dbus
+import dbus.mainloop.glib
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ val += " " + str(i)
+ val += " ]"
+ return val
+
+def property_changed(name, value, path):
+ service = path[path.rfind("/") + 1:]
+ if name in ["Services"]:
+ val = "["
+ for i in value:
+ val = val + " " + i[i.rfind("/") + 1:]
+ val = val + " ]"
+ elif name in ["IPv4", "IPv4.Configuration",
+ "IPv6", "IPv6.Configuration",
+ "Proxy", "Proxy.Configuration", "Ethernet", "Provider"]:
+ val = extract_values(value)
+ elif name in ["Nameservers", "Nameservers.Configuration",
+ "Domains", "Domains.Configuration",
+ "Timeservers", "Timeservers.Configuration", "Security"]:
+ val = extract_list(value)
+ elif name in ["Strength", "Priority"]:
+ val = int(value)
+ else:
+ val = str(value)
+ print "[%s] %s = %s" % (service, name, val)
+
+def services_changed(services, removed):
+ for i in services:
+ service = i[0][i[0].rfind("/") + 1:]
+ print "[%s] changed" % (service)
+ for n in i[1].keys():
+ property_changed(n, i[1][n], i[0])
+ for i in removed:
+ service = i[i.rfind("/") + 1:]
+ print "[%s] removed" % (service)
+
+def technology_added(path, properties):
+ technology = path[path.rfind("/") + 1:]
+ print "[%s] added" % (technology)
+ for n in properties.keys():
+ property_changed(n, properties[n], technology)
+
+def technology_removed(path):
+ technology = path[path.rfind("/") + 1:]
+ print "[%s] removed" % (technology)
+
+if __name__ == '__main__':
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ bus = dbus.SystemBus()
+
+ bus.add_signal_receiver(property_changed,
+ bus_name="net.connman",
+ dbus_interface="net.connman.Manager",
+ signal_name="PropertyChanged",
+ path_keyword="path")
+
+ bus.add_signal_receiver(services_changed,
+ bus_name="net.connman",
+ dbus_interface="net.connman.Manager",
+ signal_name="ServicesChanged")
+
+ bus.add_signal_receiver(property_changed,
+ bus_name="net.connman",
+ dbus_interface="net.connman.Service",
+ signal_name="PropertyChanged",
+ path_keyword="path")
+
+ bus.add_signal_receiver(technology_added,
+ bus_name="net.connman",
+ dbus_interface="net.connman.Manager",
+ signal_name="TechnologyAdded")
+
+ bus.add_signal_receiver(technology_removed,
+ bus_name="net.connman",
+ dbus_interface="net.connman.Manager",
+ signal_name="TechnologyRemoved")
+
+ bus.add_signal_receiver(property_changed,
+ bus_name="net.connman",
+ dbus_interface="net.connman.Technology",
+ signal_name="PropertyChanged",
+ path_keyword="path")
+
+ mainloop = gobject.MainLoop()
+ mainloop.run()
diff --git a/test/monitor-vpn b/test/monitor-vpn
new file mode 100755
index 0000000..2b63687
--- /dev/null
+++ b/test/monitor-vpn
@@ -0,0 +1,81 @@
+#!/usr/bin/python
+
+import gobject
+
+import dbus
+import dbus.mainloop.glib
+
+from dbus.lowlevel import MethodCallMessage, HANDLER_RESULT_NOT_YET_HANDLED
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ if type(i).__name__ == 'Dictionary':
+ val += extract_values(i)
+ elif type(i).__name__ == 'Struct':
+ val += extract_list(i)
+ else:
+ val += " " + str(i)
+ val += "]"
+ return val
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["ProtocolFamily"]:
+ val += "%s" % (int(values[key]))
+ elif key in ["IPv4", "IPv6"]:
+ val += extract_values(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract(name, value):
+ val = None
+
+ if name in ["Index"]:
+ val = int(value)
+ elif name in ["IPv4", "IPv6" ]:
+ val = extract_values(value)
+ elif name in ["UserRoutes", "ServerRoutes", "Nameservers"]:
+ val = extract_list(value)
+ else:
+ val = str(value)
+
+ return val
+
+def property_changed(name, value, path, interface):
+ iface = interface[interface.rfind(".") + 1:]
+ val = extract(name, value)
+
+ print "{%s} [%s] %s = %s" % (iface, path, name, val)
+
+def message_filter(connection, message):
+ if not isinstance(message, MethodCallMessage):
+ return HANDLER_RESULT_NOT_YET_HANDLED
+
+ interface = message.get_interface()
+ path = message.get_path()
+ name = message.get_member()
+ args = message.get_args_list()
+
+ property_changed(name, args, path, interface)
+
+if __name__ == '__main__':
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ bus = dbus.SystemBus()
+
+ bus.add_signal_receiver(property_changed,
+ bus_name="net.connman.vpn",
+ signal_name = "PropertyChanged",
+ path_keyword="path",
+ interface_keyword="interface")
+
+ bus.add_message_filter(message_filter)
+
+ mainloop = gobject.MainLoop()
+
+ mainloop.run()
diff --git a/test/p2p-on-supplicant b/test/p2p-on-supplicant
new file mode 100755
index 0000000..8cc76e8
--- /dev/null
+++ b/test/p2p-on-supplicant
@@ -0,0 +1,649 @@
+#!/usr/bin/python
+
+from os import O_NONBLOCK
+from sys import stdin, stdout, exit, version_info, argv
+from fcntl import fcntl, F_GETFL, F_SETFL
+import glib
+import dbus
+import dbus.mainloop.glib
+import gobject
+import argparse
+
+WPA_NAME='fi.w1.wpa_supplicant1'
+WPA_INTF='fi.w1.wpa_supplicant1'
+WPA_PATH='/fi/w1/wpa_supplicant1'
+WPA_IF_INTF = WPA_INTF + '.Interface'
+WPA_P2P_INTF = WPA_IF_INTF + '.P2PDevice'
+WPA_GROUP_INTF = WPA_INTF + '.Group'
+WPA_PEER_INTF = WPA_INTF + '.Peer'
+DBUS_PROPERTIES_INTF = 'org.freedesktop.DBus.Properties'
+
+P2P_GROUP_CAPAB_GROUP_OWNER = 1 << 0
+
+class ArgFields:
+ for field in ('help', 'metavar'):
+ exec('{}="{}"'.format(field, field))
+
+class InputLine:
+ def __init__(self, handler):
+ self.line = ''
+ self.handler = handler
+
+ flags = fcntl(stdin.fileno(), F_GETFL)
+ flags |= O_NONBLOCK
+ fcntl(stdin.fileno(), F_SETFL, flags)
+ glib.io_add_watch(stdin, glib.IO_IN, self.input_cb)
+
+ self.prompt()
+
+ def prompt(self):
+ self.line = ''
+ print '> ',
+ stdout.flush()
+
+ def input_cb(self, fd, event):
+ if event != glib.IO_IN:
+ return
+
+ self.line += fd.read();
+ for line in self.line.split('\n'):
+ line = line.strip()
+ if len(line) == 0:
+ break
+
+ self.handler(line.strip())
+
+ self.prompt()
+
+ return True
+
+def error_print(ex):
+ print 'Command Error: %s' % ex
+
+def checkarg(nb_args = 0, min_args = False):
+ def under(function):
+ def wrapper(*args, **kwargs):
+ resuls = True
+
+ if min_args:
+ result = len(args[1]) < nb_args
+ else:
+ result = len(args[1]) != nb_args
+
+ if result:
+ raise Exception('Command %s takes %s arguments' %
+ (function.__name__, nb_args))
+ return function(*args, **kwargs)
+ return wrapper
+ return under
+
+def print_dict(d):
+ for k in d:
+ try:
+ if type(d[k]) is dbus.Byte:
+ print 'Key %s --> 0x%x' % (k, d[k])
+ else:
+ print 'Key %s --> %s' % (k, d[k])
+ except:
+ print "Error: Key %s content cannot be printed" % k
+ pass
+
+def print_tuple(t):
+ for e in t:
+ if type(e) is dbus.Dictionary:
+ print_dict(e)
+ else:
+ print 'Element: %s' % e
+
+class Wpa_s:
+ def __init__(self, bus, iface_name, command):
+ self.wpa = dbus.Interface(bus.get_object(WPA_NAME, WPA_PATH), WPA_INTF)
+ bus.add_signal_receiver(self.__wpa_property_changed, path=WPA_PATH,
+ member_keyword='signal')
+ bus.add_signal_receiver(self.__InterfaceAdded, path=WPA_PATH,
+ signal_name='InterfaceAdded')
+ bus.add_signal_receiver(self.__InterfaceRemoved, path=WPA_PATH,
+ signal_name='InterfaceRemoved')
+ self.__reset()
+
+ self.bus = bus
+
+ self.debug = False
+
+ self.line_in = InputLine(self.__command)
+
+ if iface_name:
+ try:
+ self.create_if([iface_name])
+ except:
+ print "Error creating interface: %s" % iface_name
+
+ if len(command.strip(' ')):
+ self.__command(command)
+
+ def help(self, args):
+ list = self.command_list.keys()
+ list.sort()
+ for key in list:
+ help = ''
+ if (self.command_list[key].has_key(ArgFields.help)):
+ help = self.command_list[key][ArgFields.help]
+
+ print "%s\t%s" % (key.rjust(25), help.ljust(50))
+
+ def __command(self, cmd_line):
+ cmd = cmd_line.split(' ')
+
+ try:
+ func = getattr(self, cmd[0])
+ except Exception, e:
+ print 'Error: command unknown - %s' % e
+ return
+
+ try:
+ func(cmd[1:])
+ except Exception, e:
+ error_print(e)
+
+ def __wpa_property_changed(*args, **kwargs):
+ print 'WPA - Signal: %s' % kwargs.get('signal')
+
+ def __if_property_changed(*args, **kwargs):
+ signal = kwargs.get('signal')
+ print 'IF - Signal: %s' % signal
+
+ if signal == 'BSSAdded':
+ return
+
+ if args[0].debug:
+ print_tuple(args[1:])
+
+ def __p2p_property_changed(*args, **kwargs):
+ print 'IF P2P - Signal: %s' % kwargs.get('signal')
+ if args[0].debug:
+ print_tuple(args[1:])
+
+ def __peer_if_p2p_property_changed(*args, **kwargs):
+ print 'Peer - ',
+ args[0].__p2p_property_changed(*args, **kwargs)
+
+ def __DeviceFound(self, object_path):
+ self.peers[object_path] = None
+
+ peer = self.bus.get_object(WPA_INTF, object_path)
+ peer_if = dbus.Interface(peer, DBUS_PROPERTIES_INTF)
+
+ self.bus.add_signal_receiver(self.__peer_if_p2p_property_changed,
+ dbus_interface=WPA_PEER_INTF,
+ path=object_path, member_keyword='signal')
+
+ self.peers[object_path] = peer_if.GetAll(WPA_PEER_INTF)
+
+ if self.debug:
+ print_dict(self.peers[object_path])
+
+ def __DeviceLost(self, object_path):
+ if object_path in self.peers:
+ del self.peers[object_path]
+
+ def __PeerJoined(self, object_path):
+ print 'Peer %s joined' % object_path
+
+ def __PeerDisconnected(self, object_path):
+ print 'Peer %s disconnected' % object_path
+
+ def __group_if_property_changed(*args, **kwargs):
+ print 'Group - ',
+ args[0].__if_property_changed(*args, **kwargs)
+
+ def __group_if_p2p_property_changed(*args, **kwargs):
+ print 'Group - ',
+ args[0].__p2p_property_changed(*args, **kwargs)
+
+ def __GroupFinished(self, properties):
+ print 'Group running on %s is being removed' % ifname
+ self.group_obj = self.group_if = self.group_iface_path = None
+
+ if self.debug:
+ print_dict(properties)
+
+ def __InvitationResult(self, response):
+ print 'Invitation result status: %d ' % response['status']
+
+ if response.has_key('bssid'):
+ print 'bssid: %s' % response['bssid']
+
+ if self.debug:
+ print_dict(response)
+
+ def __GroupStarted(self, properties):
+ self.group_obj = properties['group_object']
+ self.bus.add_signal_receiver(self.__PeerJoined,
+ dbus_interface=WPA_GROUP_INTF,
+ path=self.group_obj,
+ signal_name='PeerJoined')
+ self.bus.add_signal_receiver(self.__PeerDisconnected,
+ dbus_interface=WPA_GROUP_INTF,
+ path=self.group_obj,
+ signal_name='PeerDisconnected')
+
+ self.group_iface_path = properties['interface_object']
+ self.group_if = dbus.Interface(self.bus.get_object(WPA_INTF,
+ self.group_iface_path),
+ WPA_P2P_INTF)
+ self.bus.add_signal_receiver(self.__group_if_property_changed,
+ dbus_interface=WPA_IF_INTF,
+ path=self.group_iface_path,
+ member_keyword='signal')
+ self.bus.add_signal_receiver(self.__group_if_p2p_property_changed,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.group_iface_path,
+ member_keyword='signal')
+ self.bus.add_signal_receiver(self.__GroupFinished,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.group_iface_path,
+ signal_name='GroupFinished')
+ self.bus.add_signal_receiver(self.__InvitationResult,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.iface_path,
+ signal_name='InvitationResult')
+
+ if self.debug:
+ group = dbus.Interface(self.bus.get_object(WPA_INTF,
+ self.group_obj),
+ DBUS_PROPERTIES_INTF)
+ print_dict(group.GetAll(WPA_GROUP_INTF))
+
+ def __ServiceDiscoveryResponse(self, response):
+ peer = response['peer_object']
+ if peer in self.peers:
+ print 'Peer %s has this TLVs:' % (self.peers[peer]['DeviceName'])
+ print response['tlvs']
+
+ def __InterfaceAdded(self, path, properties):
+ print 'Interface %s Added (%s)' % (properties['Ifname'], path)
+ if self.debug:
+ print_dict(properties)
+ p2p = dbus.Interface(self.bus.get_object(WPA_INTF,
+ path), DBUS_PROPERTIES_INTF)
+ print_dict(p2p.GetAll(WPA_P2P_INTF))
+
+ def __InterfaceRemoved(self, path):
+ print 'Interface Removed (%s)' % (path)
+
+ def __listen_if_signals(self):
+ self.bus.add_signal_receiver(self.__if_property_changed,
+ dbus_interface=WPA_IF_INTF,
+ path=self.iface_path,
+ member_keyword='signal')
+ self.bus.add_signal_receiver(self.__p2p_property_changed,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.iface_path,
+ member_keyword='signal')
+ self.bus.add_signal_receiver(self.__GroupStarted,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.iface_path,
+ signal_name='GroupStarted')
+ self.bus.add_signal_receiver(self.__DeviceFound,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.iface_path,
+ signal_name='DeviceFound')
+ self.bus.add_signal_receiver(self.__DeviceLost,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.iface_path,
+ signal_name='DeviceLost')
+ self.bus.add_signal_receiver(self.__ServiceDiscoveryResponse,
+ dbus_interface=WPA_P2P_INTF,
+ path=self.iface_path,
+ signal_name='ServiceDiscoveryResponse')
+
+ def __reset(self):
+ self.iface_path = self.iface_name = self.iface = None
+ self.p2p = self.group_if = self.group_obj = None
+ self.peers = {}
+
+ def __set_if(self, iface_name):
+ self.iface = dbus.Interface(self.bus.get_object(WPA_INTF,
+ self.iface_path), WPA_IF_INTF)
+ self.p2p = dbus.Interface(self.bus.get_object(WPA_INTF,
+ self.iface_path), WPA_P2P_INTF)
+
+ p2p_if = dbus.Interface(self.p2p, DBUS_PROPERTIES_INTF)
+ p2p_if.Set(WPA_P2P_INTF, 'P2PDeviceConfig',
+ dbus.Dictionary({ 'DeviceName' : 'ConnManP2P' },
+ signature='sv'))
+ print 'Interface %s: %s' % (iface_name, self.iface_path)
+ self.iface_name = iface_name
+ self.__listen_if_signals()
+
+ @checkarg()
+ def enable_debug(self, args):
+ self.debug = True
+
+ @checkarg()
+ def disable_debug(self, args):
+ self.debug = False
+
+ @checkarg(nb_args=1)
+ def create_if(self, args):
+ self.__reset()
+ self.iface_path = self.wpa.CreateInterface(({ 'Ifname' : args[0]} ))
+ self.__set_if(args[0])
+
+ @checkarg(nb_args=1)
+ def get_if(self, args):
+ self.__reset()
+ self.iface_path = self.wpa.GetInterface(args[0])
+ self.__set_if(args[0])
+
+ @checkarg()
+ def del_if(self, args = None):
+ if not self.iface_path:
+ return
+
+ self.wpa.RemoveInterface(self.iface_path)
+ print 'Interface %s removed' % self.iface_name
+ self.__reset()
+
+ @checkarg()
+ def scan(self, args = None):
+ if not self.iface:
+ return
+
+ self.iface.Scan(({ 'Type': 'passive' }))
+ print 'Scan started'
+
+ @checkarg()
+ def quit(self, args = None):
+ self.del_if(args)
+ exit(0)
+
+ @checkarg(nb_args=1)
+ def set_command_list(self, command_list):
+ self.command_list = command_list[0]
+
+ @checkarg()
+ def p2p_find(self, args = None):
+ if not self.p2p:
+ return
+
+ self.p2p.Find(({}))
+
+ @checkarg()
+ def p2p_stop_find(self, args = None):
+ if not self.p2p:
+ return
+
+ self.p2p.StopFind()
+
+ @checkarg()
+ def p2p_peers(self, args = None):
+ if not self.iface:
+ return
+
+ for p in self.peers:
+ print 'Peer Name=%s' % (self.peers[p]['DeviceName'])
+
+ def __find_peer(self, peer_name, ret_object_path = False):
+ if len(self.peers) == 0:
+ return None
+
+ peer = None
+ for p in self.peers:
+ if self.peers[p]['DeviceName'] == peer_name:
+ peer = self.peers[p]
+ break
+
+ if not peer:
+ print 'No peer found under the name: %s' % peer_name
+ p = None
+
+ if ret_object_path:
+ return p
+ else:
+ return peer
+
+ @checkarg(nb_args = 1)
+ def p2p_peer(self, args):
+ peer_path = self.__find_peer(args[0], True)
+ if peer_path:
+ peer = self.bus.get_object(WPA_INTF, peer_path)
+ peer_if = dbus.Interface(peer, DBUS_PROPERTIES_INTF)
+ self.peers[peer_path] = peer_if.GetAll(WPA_PEER_INTF)
+
+ print_dict(self.peers[peer_path])
+
+ @checkarg(nb_args = 1)
+ def p2p_connect(self, args):
+ if not self.p2p:
+ return
+
+ peer = self.__find_peer(args[0])
+ if not peer:
+ return
+
+ peer_path = self.__find_peer(args[0], True)
+
+ if (peer['groupcapability'] & P2P_GROUP_CAPAB_GROUP_OWNER ==
+ P2P_GROUP_CAPAB_GROUP_OWNER):
+ print 'Joining an existing P2P group'
+ pin = self.p2p.Connect(({ 'peer' : peer_path,
+ 'wps_method' : 'pbc',
+ 'join' : True,
+ 'go_intent' : 0 }))
+ else:
+ print 'Associating with another P2P device'
+ pin = self.p2p.Connect(({ 'peer' : peer_path,
+ 'wps_method' : 'pbc',
+ 'join' : False,
+ 'go_intent' : 7 }))
+ if not pin:
+ print 'WPS PIN in use: %s' % pin
+
+ @checkarg(nb_args = 1)
+ def p2p_disconnect(self, args):
+ if not self.p2p:
+ return
+
+ peer = self.__find_peer(args[0])
+ if not peer:
+ return
+
+ if not self.group_if:
+ print 'Peer %s is not connected' % (peer['DeviceName'])
+ return
+
+ self.group_if.Disconnect()
+
+ @checkarg()
+ def p2p_group_add(self, args):
+ if not self.p2p:
+ return
+
+ self.p2p.GroupAdd(({ 'persistent' : dbus.Boolean(1) }))
+
+ @checkarg()
+ def p2p_group_remove(self, args):
+ if not self.group_if:
+ return
+
+ self.group_if.Disconnect()
+
+ @checkarg()
+ def p2p_group(self, args):
+ if not self.group_obj:
+ return
+
+ group = dbus.Interface(self.bus.get_object(WPA_INTF,
+ self.group_obj), DBUS_PROPERTIES_INTF)
+ print_dict(group.GetAll(WPA_GROUP_INTF))
+
+ @checkarg()
+ def p2p_flush(self, args):
+ if not self.p2p:
+ return
+
+ self.p2p.Flush()
+
+ @checkarg()
+ def p2p_serv_disc_req(self, args = None):
+ if not self.p2p:
+ return
+
+ """ We request all kind of services """
+ sd_req = dbus.Array(signature='y', variant_level=1)
+ for a in [2,0,0,1]:
+ sd_req.append(dbus.Byte(a))
+
+ ref = self.p2p.ServiceDiscoveryRequest(({ 'tlv' : sd_req }))
+ print 'Service discovery reference: %s' % ref
+
+ @checkarg(nb_args = 1)
+ def p2p_serv_disc_cancel_req(self, args):
+ if not self.p2p:
+ return
+
+ self.p2p.ServiceDiscoveryCancelRequest(int(args[0]))
+
+ @checkarg(nb_args = 3)
+ def p2p_service_add(self, args):
+ if not self.p2p:
+ return
+
+ service = { 'service_type' : args[0] }
+ if args[0] == 'upnp':
+ service['version'] = args[1]
+ service['service'] = args[2]
+ elif args[0] == 'bonjour':
+ service['query'] = args[1]
+ service['response'] = args[2]
+ else:
+ print 'Unknown service: %s' % args[0]
+ return
+
+ self.p2p.AddService((service))
+
+ @checkarg(nb_args = 2, min_args = True)
+ def p2p_service_del(self, args):
+ if not self.p2p:
+ return
+
+ service = { 'service_type' : args[0] }
+ if args[0] == 'upnp':
+ service['version'] = args[1]
+ service['service'] = args[2]
+ elif args[0] == 'bonjour':
+ service['query'] = args[1]
+ else:
+ print 'Unknown service: %s' % args[0]
+ return
+
+ self.p2p.DeleteService((service))
+
+ @checkarg()
+ def p2p_service_flush(self, args = None):
+ if not self.p2p:
+ return
+
+ self.p2p.FlushService()
+
+ @checkarg(nb_args = 1)
+ def p2p_invite(self, args):
+ if not self.p2p or not self.group_if:
+ return
+
+ peer_path = self.__find_peer(args[0], True)
+
+ if not peer_path:
+ return
+
+ self.group_if.Invite({ 'peer' : peer_path})
+
+def build_args(parser):
+ parser.add_argument('-d', default=False, action='store_true',
+ dest='debug', help='enable debug')
+ parser.add_argument('-i', metavar='<interface>', dest='ifname',
+ help='interface name')
+
+ command = {}
+ command['quit'] = {}
+ command['enable_debug'] = {}
+ command['disable_debug'] = {}
+ command['create_if'] = {ArgFields.help:'<iface_name> - create interface'}
+ command['get_if'] = {ArgFields.help:'<iface_name> - get interface'}
+ command['del_if'] = {ArgFields.help:'removes current interface'}
+ command['scan'] = {}
+ command['p2p_find'] = {}
+ command['p2p_stop_find'] = {}
+ command['p2p_flush'] = {}
+ command['p2p_group_add'] = {ArgFields.help:'adds an autonomous group'}
+ command['p2p_group_remove'] = {}
+ command['p2p_group'] = {}
+ command['p2p_peers'] = {}
+ command['p2p_peer'] = {ArgFields.help:'<p2p device name> - get info for a '
+ 'peer'}
+ command['p2p_connect'] = {ArgFields.help:'<p2p device name>'}
+ command['p2p_disconnect'] = {ArgFields.help:'<p2p device name>'}
+ command['p2p_serv_disc_req'] = {}
+ command['p2p_serv_disc_cancel_req'] = {ArgFields.help:'<identifier>'}
+ command['p2p_service_add'] = {ArgFields.help:'<service type> '
+ '<version/query> <service/response>'}
+ command['p2p_service_del'] = {ArgFields.help:'<service type> '
+ '<version/query> [<service>]'}
+ command['p2p_service_flush'] = {}
+ command['p2p_invite'] = {ArgFields.help:'<p2p device name>'}
+
+ command_list = command.keys()
+ command_list.sort()
+ subparsers = parser.add_subparsers(help='commands', dest='command')
+ subparsers.add_parser('')
+ for key in command_list:
+ help=None
+ metavar=None
+ if command[key].has_key(ArgFields.help):
+ help = command[key][ArgFields.help]
+ if command[key].has_key(ArgFields.metavar):
+ metavar = command[key][ArgFields.metavar]
+ command_parser = subparsers.add_parser(key, help=help)
+ command_parser.add_argument(key, nargs='*', metavar=metavar, help=help)
+
+ return command
+
+def main():
+ if version_info.major != 2:
+ print 'You need to run this under Python 2.x'
+ exit(1)
+
+ parser = argparse.ArgumentParser(description='Connman P2P Test')
+
+ command_list = build_args(parser)
+
+ argv[1:] += ['']
+
+ args = parser.parse_args(argv[1:])
+
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ opts = []
+ if args.command:
+ opts = getattr(args, args.command)
+
+ params = ''
+ if opts and len(opts[0]):
+ params = ' ' + ''.join(opts)
+
+ bus = dbus.SystemBus()
+
+ mainloop = gobject.MainLoop()
+
+ wpa_s = Wpa_s(bus, args.ifname, args.command + params)
+
+ if (args.debug):
+ wpa_s.enable_debug([])
+
+ wpa_s.set_command_list([command_list])
+
+ mainloop.run()
+
+if __name__ == '__main__':
+ main()
diff --git a/test/remove-provider b/test/remove-provider
new file mode 100755
index 0000000..39f8de7
--- /dev/null
+++ b/test/remove-provider
@@ -0,0 +1,19 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 2):
+ print "Usage: %s <VPN service path> " % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+path = "" + sys.argv[1]
+
+print "remove path is %s" %(path)
+
+manager.RemoveProvider(sys.argv[1])
diff --git a/test/service-move-before b/test/service-move-before
new file mode 100755
index 0000000..d912c88
--- /dev/null
+++ b/test/service-move-before
@@ -0,0 +1,27 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+def print_usage():
+ print "Usage: %s <service> <target service>" % (sys.argv[0])
+
+
+if (len(sys.argv) < 2):
+ print_usage()
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+path2 = "/net/connman/service/" + sys.argv[2]
+service2 = dbus.Interface(bus.get_object('net.connman', path2),
+ 'net.connman.Service')
+
+print "Moving %s before %s" % (sys.argv[1], sys.argv[2])
+
+service.MoveBefore(service2)
+
+print
diff --git a/test/set-clock b/test/set-clock
new file mode 100755
index 0000000..a9db3e3
--- /dev/null
+++ b/test/set-clock
@@ -0,0 +1,32 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+def print_usage():
+ print "Usage: %s TimeUpdates|TimezoneUpdates manual|auto" % (sys.argv[0])
+ sys.exit(1)
+
+
+def make_variant(string):
+ return dbus.String(string, variant_level=1)
+
+
+if (len(sys.argv) != 3):
+ print_usage()
+
+if (sys.argv[1] != "TimeUpdates" and sys.argv[1] != "TimezoneUpdates"):
+ print_usage()
+
+if (sys.argv[2] != "manual" and sys.argv[2] != "auto"):
+ print_usage()
+
+bus = dbus.SystemBus()
+
+clock = dbus.Interface(bus.get_object('net.connman', '/'),
+ 'net.connman.Clock')
+
+print "Setting %s to %s" % (sys.argv[1], sys.argv[2])
+
+clock.SetProperty(sys.argv[1], make_variant(sys.argv[2]),
+ signature=dbus.Signature('sv'))
diff --git a/test/set-domains b/test/set-domains
new file mode 100755
index 0000000..87e563e
--- /dev/null
+++ b/test/set-domains
@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 2):
+ print "Usage: %s <service> [domain*]" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+properties = service.GetProperties()
+
+print "Setting domains to %s" % (sys.argv[2:])
+
+service.SetProperty("Domains.Configuration",
+ dbus.Array(sys.argv[2:], signature=dbus.Signature('s')))
diff --git a/test/set-global-timeservers b/test/set-global-timeservers
new file mode 100755
index 0000000..d7551a1
--- /dev/null
+++ b/test/set-global-timeservers
@@ -0,0 +1,18 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 1):
+ print "Usage: %s [timeserver*]" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+clock = dbus.Interface(bus.get_object('net.connman', '/'),
+ 'net.connman.Clock')
+
+print "Setting timeserver to %s" % (sys.argv[1:])
+
+clock.SetProperty("Timeservers", dbus.Array(sys.argv[1:],
+ signature=dbus.Signature('s')))
diff --git a/test/set-ipv4-method b/test/set-ipv4-method
new file mode 100755
index 0000000..235113f
--- /dev/null
+++ b/test/set-ipv4-method
@@ -0,0 +1,37 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+def make_variant(string):
+ return dbus.String(string, variant_level=1)
+
+def print_usage():
+ print "Usage: %s <service> [off|dhcp|manual <address> [netmask] [gateway]]" % (sys.argv[0])
+
+
+if (len(sys.argv) < 3):
+ print_usage()
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+properties = service.GetProperties()
+
+print "Setting method %s for %s" % (sys.argv[2], sys.argv[1])
+
+ipv4_configuration = { "Method": make_variant(sys.argv[2]) }
+if (len(sys.argv) > 3):
+ ipv4_configuration["Address"] = make_variant(sys.argv[3])
+if (len(sys.argv) > 4):
+ ipv4_configuration["Netmask"] = make_variant(sys.argv[4])
+if (len(sys.argv) > 5):
+ ipv4_configuration["Gateway"] = make_variant(sys.argv[5])
+
+service.SetProperty("IPv4.Configuration", ipv4_configuration)
+print "New IPv4.Configuration: ", ipv4_configuration
+
+print
diff --git a/test/set-ipv6-method b/test/set-ipv6-method
new file mode 100755
index 0000000..eb1f1b5
--- /dev/null
+++ b/test/set-ipv6-method
@@ -0,0 +1,43 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+def make_variant(string):
+ return dbus.String(string, variant_level=1)
+
+def make_byte_variant(string):
+ return dbus.Byte(int(string), variant_level=1)
+
+def print_usage():
+ print "Usage: %s <service> off|manual|auto [<address> [prefixlen] [gateway]] [<privacy>]" % (sys.argv[0])
+
+if (len(sys.argv) < 3):
+ print_usage()
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+properties = service.GetProperties()
+
+print "Setting method %s for %s" % (sys.argv[2], sys.argv[1])
+
+ipv6_configuration = { "Method": make_variant(sys.argv[2])}
+if sys.argv[2] == "auto":
+ if (len(sys.argv) > 3):
+ ipv6_configuration["Privacy"] = make_variant(sys.argv[3])
+else:
+ if (len(sys.argv) > 3):
+ ipv6_configuration["Address"] = make_variant(sys.argv[3])
+ if (len(sys.argv) > 4):
+ ipv6_configuration["PrefixLength"] = make_byte_variant(sys.argv[4])
+ if (len(sys.argv) > 5):
+ ipv6_configuration["Gateway"] = make_variant(sys.argv[5])
+
+service.SetProperty("IPv6.Configuration", ipv6_configuration)
+print "New IPv6.Configuration: ", ipv6_configuration
+
+print
diff --git a/test/set-nameservers b/test/set-nameservers
new file mode 100755
index 0000000..ece69b8
--- /dev/null
+++ b/test/set-nameservers
@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 2):
+ print "Usage: %s <service> [nameserver*]" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+properties = service.GetProperties()
+
+print "Setting nameserver to %s" % (sys.argv[2:])
+
+service.SetProperty("Nameservers.Configuration",
+ dbus.Array(sys.argv[2:], signature=dbus.Signature('s')))
diff --git a/test/set-proxy b/test/set-proxy
new file mode 100755
index 0000000..b9da7b0
--- /dev/null
+++ b/test/set-proxy
@@ -0,0 +1,44 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 2):
+ print "Usage:"
+ print "%s <service> direct" % (sys.argv[0])
+ print "%s <service> manual [servers=uri1,uri2,...] [excludes=host1,host2,...]" % (sys.argv[0])
+ print "%s <service> auto url=[pac-url]" % (sys.argv[0])
+ print "Example: %s service0 manual servers=proxy.example.com:8080" % sys.argv[0]
+ print " This would set the proxy uri and the method to manual"
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+values = { "Method" : sys.argv[2] }
+
+properties = service.GetProperties()
+
+for arg in sys.argv[3:]:
+ if arg.startswith("url="):
+ url = arg.replace("url=", "", 1)
+ values["URL"] = url
+ if arg.startswith("servers="):
+ try:
+ servers_uris = arg.replace("servers=","",1).split(",")
+ except:
+ servers_uris = []
+ values["Servers"] = servers_uris
+ if arg.startswith("excludes="):
+ try:
+ excludes_uris = arg.replace("excludes=","",1).split(",")
+ except:
+ excludes_uris = []
+ values["Excludes"] = excludes_uris
+
+try:
+ service.SetProperty("Proxy.Configuration", dbus.Dictionary(values, signature='sv'))
+except dbus.exceptions.DBusException, e_msg:
+ print e_msg
diff --git a/test/set-timeservers b/test/set-timeservers
new file mode 100755
index 0000000..19cc938
--- /dev/null
+++ b/test/set-timeservers
@@ -0,0 +1,20 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 2):
+ print "Usage: %s <service> [timeserver*]" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+path = "/net/connman/service/" + sys.argv[1]
+service = dbus.Interface(bus.get_object('net.connman', path),
+ 'net.connman.Service')
+
+properties = service.GetProperties()
+
+print "Setting timeserver to %s" % (sys.argv[2:])
+
+service.SetProperty("Timeservers.Configuration",
+ dbus.Array(sys.argv[2:], signature=dbus.Signature('s')))
diff --git a/test/set-timezone b/test/set-timezone
new file mode 100755
index 0000000..dfc1c98
--- /dev/null
+++ b/test/set-timezone
@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) != 2):
+ print "Usage: %s <timezone>" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+clock = dbus.Interface(bus.get_object('net.connman', '/'),
+ 'net.connman.Clock')
+
+print "Setting timezone to %s" % (sys.argv[1])
+
+try:
+ clock.SetProperty("Timezone", dbus.String(sys.argv[1], variant_level=1),
+ signature=dbus.Signature('sv'))
+except dbus.exceptions.DBusException, e_msg:
+ print e_msg
diff --git a/test/show-introspection b/test/show-introspection
new file mode 100755
index 0000000..4b6450f
--- /dev/null
+++ b/test/show-introspection
@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+import dbus
+
+bus = dbus.SystemBus()
+
+object = dbus.Interface(bus.get_object("net.connman", '/'),
+ "org.freedesktop.DBus.Introspectable")
+
+print object.Introspect()
+
+manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+technologies = manager.GetTechnologies()
+
+for path, properties in technologies:
+ object = dbus.Interface(bus.get_object("net.connman", path),
+ "org.freedesktop.DBus.Introspectable")
+
+ print object.Introspect()
diff --git a/test/simple-agent b/test/simple-agent
new file mode 100755
index 0000000..01c82ba
--- /dev/null
+++ b/test/simple-agent
@@ -0,0 +1,357 @@
+#!/usr/bin/python
+
+import gobject
+
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+import sys
+
+class Canceled(dbus.DBusException):
+ _dbus_error_name = "net.connman.Error.Canceled"
+
+class LaunchBrowser(dbus.DBusException):
+ _dbus_error_name = "net.connman.Agent.Error.LaunchBrowser"
+
+class Agent(dbus.service.Object):
+ name = None
+ ssid = None
+ identity = None
+ passphrase = None
+ wpspin = None
+ username = None
+ password = None
+
+ @dbus.service.method("net.connman.Agent",
+ in_signature='', out_signature='')
+ def Release(self):
+ print("Release")
+ mainloop.quit()
+
+ def input_passphrase(self):
+ response = {}
+
+ if not self.identity and not self.passphrase and not self.wpspin:
+ print "Service credentials requested, type cancel to cancel"
+ args = raw_input('Answer: ')
+
+ for arg in args.split():
+ if arg.startswith("cancel"):
+ response["Error"] = arg
+ if arg.startswith("Identity="):
+ identity = arg.replace("Identity=", "", 1)
+ response["Identity"] = identity
+ if arg.startswith("Passphrase="):
+ passphrase = arg.replace("Passphrase=", "", 1)
+ response["Passphrase"] = passphrase
+ if arg.startswith("WPS="):
+ wpspin = arg.replace("WPS=", "", 1)
+ response["WPS"] = wpspin
+ break
+ else:
+ if self.identity:
+ response["Identity"] = self.identity
+ if self.passphrase:
+ response["Passphrase"] = self.passphrase
+ if self.wpspin:
+ response["WPS"] = self.wpspin
+
+ return response
+
+ def input_username(self):
+ response = {}
+
+ if not self.username and not self.password:
+ print "User login requested, type cancel to cancel"
+ print "or browser to login through the browser by yourself."
+ args = raw_input('Answer: ')
+
+ for arg in args.split():
+ if arg.startswith("cancel") or arg.startswith("browser"):
+ response["Error"] = arg
+ if arg.startswith("Username="):
+ username = arg.replace("Username=", "", 1)
+ response["Username"] = username
+ if arg.startswith("Password="):
+ password = arg.replace("Password=", "", 1)
+ response["Password"] = password
+ else:
+ if self.username:
+ response["Username"] = self.username
+ if self.password:
+ response["Password"] = self.password
+
+ return response
+
+ def input_hidden(self):
+ response = {}
+
+ if not self.name and not self.ssid:
+ args = raw_input('Answer ')
+
+ for arg in args.split():
+ if arg.startswith("Name="):
+ name = arg.replace("Name=", "", 1)
+ response["Name"] = name
+ break
+ if arg.startswith("SSID="):
+ ssid = arg.replace("SSID", "", 1)
+ response["SSID"] = ssid
+ break
+ else:
+ if self.name:
+ response["Name"] = self.name
+ if self.ssid:
+ response["SSID"] = self.ssid
+
+ return response
+
+ @dbus.service.method("net.connman.Agent",
+ in_signature='oa{sv}',
+ out_signature='a{sv}')
+ def RequestInput(self, path, fields):
+ print "RequestInput (%s,%s)" % (path, fields)
+
+ response = {}
+
+ if fields.has_key("Name"):
+ response.update(self.input_hidden())
+ if fields.has_key("Passphrase"):
+ response.update(self.input_passphrase())
+ if fields.has_key("Username"):
+ response.update(self.input_username())
+
+ if response.has_key("Error"):
+ if response["Error"] == "cancel":
+ raise Canceled("canceled")
+ return
+ if response["Error"] == "browser":
+ raise LaunchBrowser("launch browser")
+ return
+
+ print "returning (%s)" % (response)
+
+ return response
+
+ @dbus.service.method("net.connman.Agent",
+ in_signature='os',
+ out_signature='')
+ def RequestBrowser(self, path, url):
+ print "RequestBrowser (%s,%s)" % (path, url)
+
+ print "Please login through the given url in a browser"
+ print "Then press enter to accept or some text to cancel"
+
+ args = raw_input('> ')
+
+ if len(args) > 0:
+ raise Canceled("canceled")
+
+ return
+
+ @dbus.service.method("net.connman.Agent",
+ in_signature='os',
+ out_signature='')
+ def ReportError(self, path, error):
+ print "ReportError %s, %s" % (path, error)
+ retry = raw_input("Retry service (yes/no): ")
+ if (retry == "yes"):
+ class Retry(dbus.DBusException):
+ _dbus_error_name = "net.connman.Agent.Error.Retry"
+
+ raise Retry("retry service")
+ else:
+ return
+
+
+ @dbus.service.method("net.connman.Agent",
+ in_signature='', out_signature='')
+ def Cancel(self):
+ print "Cancel"
+
+class VpnAgent(dbus.service.Object):
+ name = None
+ host = None
+ cookie = None
+ username = None
+ password = None
+
+ @dbus.service.method("net.connman.vpn.Agent",
+ in_signature='', out_signature='')
+ def Release(self):
+ print("Release VPN agent")
+
+ def input_cookie(self):
+ response = {}
+
+ if not self.cookie:
+ print "VPN credentials requested, type cancel to cancel"
+ args = raw_input('Answer: ')
+
+ for arg in args.split():
+ if arg.startswith("cancel"):
+ response["Error"] = arg
+ if arg.startswith("Cookie="):
+ cookie = arg.replace("Cookie=", "", 1)
+ response["OpenConnect.Cookie"] = cookie
+ else:
+ if self.cookie:
+ response["OpenConnect.Cookie"] = self.cookie
+
+ return response
+
+ def input_username(self):
+ response = {}
+
+ if not self.username and not self.password:
+ print "User login requested, type cancel to cancel"
+ args = raw_input('Answer: ')
+
+ for arg in args.split():
+ if arg.startswith("cancel"):
+ response["Error"] = arg
+ if arg.startswith("Username="):
+ username = arg.replace("Username=", "", 1)
+ response["Username"] = username
+ if arg.startswith("Password="):
+ password = arg.replace("Password=", "", 1)
+ response["Password"] = password
+ else:
+ if self.username:
+ response["Username"] = self.username
+ if self.password:
+ response["Password"] = self.password
+
+ return response
+
+ @dbus.service.method("net.connman.vpn.Agent",
+ in_signature='oa{sv}',
+ out_signature='a{sv}')
+ def RequestInput(self, path, fields):
+ print "RequestInput (%s,%s)" % (path, fields)
+
+ response = {}
+
+ if fields.has_key("OpenConnect.Cookie"):
+ response.update(self.input_cookie())
+ if fields.has_key("Username") or fields.has_key("Password"):
+ response.update(self.input_username())
+
+ if response.has_key("Error"):
+ if response["Error"] == "cancel":
+ raise Canceled("canceled")
+ return
+
+ print "returning (%s)" % (response)
+
+ return response
+
+ @dbus.service.method("net.connman.vpn.Agent",
+ in_signature='os',
+ out_signature='')
+ def ReportError(self, path, error):
+ print "ReportError %s, %s" % (path, error)
+ retry = raw_input("Retry service (yes/no): ")
+ if (retry == "yes"):
+ class Retry(dbus.DBusException):
+ _dbus_error_name = "net.connman.vpn.Agent.Error.Retry"
+
+ raise Retry("retry service")
+ else:
+ return
+
+
+ @dbus.service.method("net.connman.vpn.Agent",
+ in_signature='', out_signature='')
+ def Cancel(self):
+ print "Cancel"
+
+def vpnNameOwnerChanged(proxy):
+ if proxy:
+ print("vpnd is connected to system bus")
+ try:
+ path = "/test/vpn_agent"
+ vpn_manager = dbus.Interface(bus.get_object('net.connman.vpn',
+ "/"),
+ 'net.connman.vpn.Manager')
+ vpn_manager.RegisterAgent(path)
+ except:
+ print "vpn agent is not registered"
+ else:
+ print("vpnd is disconnected from system bus")
+ vpn_manager = None
+
+def print_usage():
+ print "Usage:"
+ print "For hidden service:"
+ print "%s Name=<hidden service name> [SSID=<hidden ssid>]" % (sys.argv[0])
+ print "For EAP/WPA input:"
+ print "%s Identity=<identity> Passphrase=<passphrase> WPS=<wpspin>" % (sys.argv[0])
+ print "For WISPr login, L2TP or PPTP input:"
+ print "%s Username=<username> Password=<password>" % (sys.argv[0])
+ print "For OpenConnect input:"
+ print "%s Cookie=<string>" % (sys.argv[0])
+ print "Help: %s help" % (sys.argv[0])
+ sys.exit(1)
+
+if __name__ == '__main__':
+ if len(sys.argv) == 2 and sys.argv[1] == "help":
+ print_usage()
+
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ bus = dbus.SystemBus()
+ manager = dbus.Interface(bus.get_object('net.connman', "/"),
+ 'net.connman.Manager')
+
+ path = "/test/agent"
+ object = Agent(bus, path)
+
+ try:
+ vpn_manager = dbus.Interface(bus.get_object('net.connman.vpn', "/"),
+ 'net.connman.vpn.Manager')
+ vpn_path = "/test/vpn_agent"
+ vpn_object = VpnAgent(bus, vpn_path)
+ except:
+ vpn_manager = None
+ print "net.connman.vpn is not present"
+
+ if len(sys.argv) >= 2:
+ for arg in sys.argv[1:]:
+ if arg.startswith("Name="):
+ object.name = arg.replace("Name=", "", 1)
+ elif arg.startswith("SSID="):
+ object.ssid = arg.replace("SSID=", "", 1)
+ elif arg.startswith("Identity="):
+ object.identity = arg.replace("Identity=", "", 1)
+ elif arg.startswith("Passphrase="):
+ object.passphrase = arg.replace("Passphrase=", "", 1)
+ elif arg.startswith("WPS="):
+ object.wpspin = arg.replace("WPS=", "", 1)
+ elif arg.startswith("Username="):
+ object.username = arg.replace("Username=", "", 1)
+ vpn_object.username = arg.replace("Username=", "", 1)
+ elif arg.startswith("Password="):
+ object.password = arg.replace("Password=", "", 1)
+ vpn_object.password = arg.replace("Password=", "", 1)
+ elif arg.startswith("Cookie="):
+ vpn_object.cookie = arg.replace("Cookie=", "", 1)
+ else:
+ print_usage()
+
+ try:
+ manager.RegisterAgent(path)
+ except:
+ print "Cannot register connman agent."
+
+ if vpn_manager != None:
+ try:
+ vpn_manager.RegisterAgent(vpn_path)
+ bus.watch_name_owner('net.connman.vpn', vpnNameOwnerChanged)
+ except:
+ "Cannot register vpn agent"
+
+ mainloop = gobject.MainLoop()
+ mainloop.run()
+
+ #manager.UnregisterAgent(path)
diff --git a/test/test-clock b/test/test-clock
new file mode 100755
index 0000000..e9b76fc
--- /dev/null
+++ b/test/test-clock
@@ -0,0 +1,19 @@
+#!/usr/bin/python
+
+import dbus
+
+bus = dbus.SystemBus()
+
+clock = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Clock")
+
+properties = clock.GetProperties()
+
+for key in properties.keys():
+ if key in ["Timeservers"]:
+ list = ""
+ for val in properties[key]:
+ list = list + val + " "
+ print "%s = [ %s]" % (key, list)
+ else:
+ print "%s = %s" % (key, properties[key])
diff --git a/test/test-compat b/test/test-compat
new file mode 100755
index 0000000..cd1ca7a
--- /dev/null
+++ b/test/test-compat
@@ -0,0 +1,15 @@
+#!/usr/bin/python
+
+import dbus
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('org.freedesktop.NetworkManager',
+ '/org/freedesktop/NetworkManager'),
+ 'org.freedesktop.NetworkManager')
+
+states = [ "unknown", "asleep", "connecting", "connected", "disconnected" ]
+
+state = manager.state()
+
+print "System is %s" % (states[state])
diff --git a/test/test-connman b/test/test-connman
new file mode 100755
index 0000000..d047c86
--- /dev/null
+++ b/test/test-connman
@@ -0,0 +1,193 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+if len(sys.argv) < 2:
+ print "Usage: %s <command>" % (sys.argv[0])
+ print ""
+ print " state"
+ print " services"
+ print " autoconnect <service> [autoconnect]"
+ print " connect <service>"
+ print " disconnect <service>"
+ print " remove <service>"
+ print ""
+ print " scan <type>"
+ print " enable <type>"
+ print " disable <type>"
+ print " offlinemode [on|off]"
+ sys.exit(1)
+
+def print_services(services):
+ for path, properties in services:
+ identifier = path[path.rfind("/") + 1:]
+ state = " "
+ autoconnect = " "
+
+ if properties["Favorite"] == dbus.Boolean(1):
+ favorite = "*"
+
+ if properties["AutoConnect"] == dbus.Boolean(1):
+ autoconnect = " A"
+ else:
+ autoconnect = " "
+
+ if properties["State"] == "ready":
+ state = "R"
+ elif properties["State"] == "online":
+ state = "O"
+ else:
+ favorite = " "
+
+ if "Name" in properties.keys():
+ name = properties["Name"]
+ else:
+ name = "{" + properties["Type"] + "}"
+
+ print "%s%s%s %-26s { %s }" % (favorite, autoconnect, state,
+ name, identifier)
+
+if sys.argv[1] == "state":
+ properties = manager.GetProperties()
+
+ print "System is %s" % (properties["State"])
+
+elif sys.argv[1] in ["services", "list", "show"]:
+ print_services(manager.GetServices())
+
+elif sys.argv[1] in ["autoconnect", "autoconn"]:
+ if (len(sys.argv) < 3):
+ print "Need at least service parameter"
+ sys.exit(1)
+
+ path = "/net/connman/service/" + sys.argv[2]
+
+ service = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Service")
+
+ if (len(sys.argv) > 3):
+ flag = sys.argv[3].strip().lower()
+ autoconnect = dbus.Boolean(flag not in ['false', 'f', 'n', '0'])
+
+ service.SetProperty("AutoConnect", autoconnect);
+
+ print "Auto connect %s for %s" % (autoconnect, sys.argv[2])
+ else:
+ properties = service.GetProperties()
+
+ if "Name" in properties.keys():
+ name = properties["Name"]
+ else:
+ name = "{" + properties["Type"] + "}"
+
+ if "AutoConnect" in properties.keys():
+ autoconnect = properties["AutoConnect"]
+ else:
+ autoconnect = dbus.Boolean(0)
+
+ print "Auto connect %s for %s" % (autoconnect, name)
+
+elif sys.argv[1] in ["connect", "conn"]:
+ if (len(sys.argv) < 3):
+ print "Need at least service parameter"
+ sys.exit(1)
+
+ path = "/net/connman/service/" + sys.argv[2]
+
+ service = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Service")
+
+ try:
+ service.Connect(timeout=60000)
+ except dbus.DBusException, error:
+ print "%s: %s" % (error._dbus_error_name, error.message)
+
+elif sys.argv[1] in ["disconnect", "disc"]:
+ if (len(sys.argv) < 3):
+ print "Need at least service parameter"
+ sys.exit(1)
+
+ path = "/net/connman/service/" + sys.argv[2]
+
+ service = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Service")
+
+ try:
+ service.Disconnect()
+ except dbus.DBusException, error:
+ print "%s: %s" % (error._dbus_error_name, error.message)
+
+elif sys.argv[1] in ["remove"]:
+ if (len(sys.argv) < 3):
+ print "Need at least service parameter"
+ sys.exit(1)
+
+ path = "/net/connman/service/" + sys.argv[2]
+
+ service = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Service")
+
+ properties = service.GetProperties()
+
+ if properties["Favorite"] == dbus.Boolean(0):
+ print "Only favorite services can be removed"
+ sys.exit(1)
+
+ try:
+ service.Remove()
+ except dbus.DBusException, error:
+ print "%s: %s" % (error._dbus_error_name, error.message)
+
+elif sys.argv[1] == "scan":
+ if len(sys.argv) == 3:
+ path = "/net/connman/technology/" + sys.argv[2]
+ technology = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Technology")
+ technology.Scan()
+ else:
+ print "'%s' takes two arguments" % sys.argv[1]
+
+elif sys.argv[1] == "enable":
+ if len(sys.argv) == 3:
+ path = "/net/connman/technology/" + sys.argv[2]
+ technology = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Technology")
+ technology.SetProperty("Powered", True)
+ else:
+ print "'%s' takes two arguments" % sys.argv[1]
+
+elif sys.argv[1] == "disable":
+ if len(sys.argv) == 3:
+ path = "/net/connman/technology/" + sys.argv[2]
+ technology = dbus.Interface(bus.get_object("net.connman", path),
+ "net.connman.Technology")
+ technology.SetProperty("Powered", False)
+ else:
+ print "'%s' takes two arguments" % sys.argv[1]
+
+
+elif sys.argv[1] in ["offlinemode", "flightmode"]:
+ if len(sys.argv) == 3:
+ if sys.argv[2] == "on" or sys.argv[2] == "1" or sys.argv[2] == "yes":
+ active = dbus.Boolean(1)
+ elif sys.argv[2] == "off" or sys.argv[2] == "0" or sys.argv[2] == "no":
+ active = dbus.Boolean(0)
+ else:
+ print "Use either 'on', '1', 'yes', 'off', '0' or 'no'"
+ exit()
+
+ manager.SetProperty("OfflineMode", active)
+ elif len(sys.argv) == 2:
+ properties = manager.GetProperties()
+ print "Offline mode is %s" % (properties["OfflineMode"])
+ else:
+ print "'%s' takes max. two arguments" % sys.argv[1]
+
+else:
+ print "Unknown command"
diff --git a/test/test-counter b/test/test-counter
new file mode 100755
index 0000000..ce83580
--- /dev/null
+++ b/test/test-counter
@@ -0,0 +1,79 @@
+#!/usr/bin/python
+
+import sys
+import gobject
+
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+
+def make_bytes_readable(bytes):
+ SUFFIXES = [ 'KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB' ]
+ size = 1024
+
+ if bytes < size:
+ return ''
+
+ for suffix in SUFFIXES:
+ if bytes > size * 1024:
+ size = size * 1024
+ continue
+
+ return '%.1f %s' % (bytes / float(size), suffix)
+
+ return ''
+
+def print_stats(stats):
+ keys = stats.keys()
+ keys.sort()
+
+ for key in keys:
+ val = int(stats[key])
+ str = " %s = %s" % (key, val)
+
+ if key in ["RX.Bytes", "TX.Bytes"]:
+ hstr = make_bytes_readable(val)
+ if hstr:
+ str = "%s (%s)" % (str, hstr)
+
+ print str
+
+class Counter(dbus.service.Object):
+ @dbus.service.method("net.connman.Counter",
+ in_signature='', out_signature='')
+ def Release(self):
+ print("Release")
+ mainloop.quit()
+
+ @dbus.service.method("net.connman.Counter",
+ in_signature='oa{sv}a{sv}', out_signature='')
+ def Usage(self, path, home, roaming):
+ print "%s" % (path)
+
+ if len(home) > 0:
+ print " Home"
+ print_stats(home)
+ if len(roaming) > 0:
+ print " Roaming"
+ print_stats(roaming)
+
+if __name__ == '__main__':
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ bus = dbus.SystemBus()
+ manager = dbus.Interface(bus.get_object('net.connman', "/"),
+ 'net.connman.Manager')
+
+ period = 2
+ if len(sys.argv) > 1:
+ period = sys.argv[1]
+
+ path = "/test/counter%s" % period
+ object = Counter(bus, path)
+
+ manager.RegisterCounter(path, dbus.UInt32(10), dbus.UInt32(period))
+
+ mainloop = gobject.MainLoop()
+ mainloop.run()
+
+ #manager.UnregisterCounter(path)
diff --git a/test/test-manager b/test/test-manager
new file mode 100755
index 0000000..2b4493c
--- /dev/null
+++ b/test/test-manager
@@ -0,0 +1,93 @@
+#!/usr/bin/python
+
+import dbus
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["PrefixLength"]:
+ val += "%s" % (int(values[key]))
+ else:
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ val += " " + str(i)
+ val += " ]"
+ return val
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+
+properties = manager.GetProperties()
+
+for key in properties.keys():
+ if key in ["OfflineMode", "SessionMode"]:
+ print "%s" % (key)
+ if properties[key] == dbus.Boolean(1):
+ print " true"
+ else:
+ print " false"
+ else:
+ print "%s" % (key)
+ print " %s" % (properties[key])
+
+print ("Services")
+services = manager.GetServices()
+
+for (path, properties) in services:
+ print " %s" % (path)
+ for key in properties.keys():
+ if key in ["Available", "Remember", "Default",
+ "Favorite", "Immutable", "AutoConnect",
+ "LoginRequired",
+ "PassphraseRequired"]:
+ if properties[key] == dbus.Boolean(1):
+ val = "true"
+ else:
+ val = "false"
+
+ elif key in ["IPv4", "IPv4.Configuration",
+ "IPv6", "IPv6.Configuration",
+ "Proxy", "Proxy.Configuration",
+ "Ethernet", "Provider"]:
+ val = extract_values(properties[key])
+
+ elif key in ["Nameservers", "Nameservers.Configuration",
+ "Domains", "Domains.Configuration",
+ "Security"]:
+ val = extract_list(properties[key])
+
+ elif key in ["Strength", "Priority"]:
+ val = int(properties[key])
+
+ else:
+ val = str(properties[key])
+
+ print " %s = %s" % (key, val)
+
+print ("Technologies")
+technologies = manager.GetTechnologies()
+
+for (path, properties) in technologies:
+ print " %s" % (path)
+ for key in properties.keys():
+
+ if key in ["Connected", "Powered", "Tethering"]:
+ if properties[key] == dbus.Boolean(1):
+ val = "true"
+ else:
+ val = "false"
+ else:
+ val = properties[key]
+
+ print " %s = %s" % (key, val)
diff --git a/test/test-new-supplicant b/test/test-new-supplicant
new file mode 100755
index 0000000..be230dc
--- /dev/null
+++ b/test/test-new-supplicant
@@ -0,0 +1,14 @@
+#!/usr/bin/python
+
+import dbus
+
+WPA_NAME='fi.w1.wpa_supplicant1'
+WPA_INTF='fi.w1.wpa_supplicant1'
+WPA_PATH='/fi/w1/wpa_supplicant1'
+
+bus = dbus.SystemBus()
+
+dummy = dbus.Interface(bus.get_object(WPA_NAME, WPA_PATH),
+ 'org.freedesktop.DBus.Introspectable')
+
+print dummy.Introspect()
diff --git a/test/test-session b/test/test-session
new file mode 100755
index 0000000..2d82fb6
--- /dev/null
+++ b/test/test-session
@@ -0,0 +1,341 @@
+#!/usr/bin/python
+
+import sys
+import gobject
+import string
+
+import dbus
+import dbus.service
+import dbus.mainloop.glib
+
+import glib
+
+import traceback
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ val += " " + str(i)
+ val += " ]"
+ return val
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["PrefixLength"]:
+ val += "%s" % (int(values[key]))
+ else:
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+class Notification(dbus.service.Object):
+ def __init__(self, bus, app, notify_path):
+ dbus.service.Object.__init__(self)
+ self.app = app
+
+ @dbus.service.method("net.connman.Notification",
+ in_signature='', out_signature='')
+ def Release(self):
+ print "Release %s" % (self._object_path)
+ session_name = self._object_path.split('/')[-1]
+ self.app.release(session_name)
+
+ @dbus.service.method("net.connman.Notification",
+ in_signature='a{sv}', out_signature='')
+ def Update(self, settings):
+ print "Update called at %s" % (self._object_path)
+
+ try:
+ for key in settings.keys():
+ if key in ["IPv4", "IPv6"]:
+ val = extract_values(settings[key])
+ elif key in ["AllowedBearers"]:
+ val = extract_list(settings[key])
+ else:
+ val = settings[key]
+ print " %s = %s" % (key, val)
+ except:
+ print "Exception:"
+ traceback.print_exc()
+
+class SessionApplication(dbus.service.Object):
+ def __init__(self, bus, object_path, mainloop):
+ dbus.service.Object.__init__(self, bus, object_path)
+
+ self.manager = None
+ self.mainloop = mainloop
+ self.sessions = {}
+
+ try:
+ bus = dbus.SystemBus()
+ bus.watch_name_owner('net.connman', self.connman_name_owner_changed)
+ except dbus.DBusException:
+ traceback.print_exc()
+
+ def connman_name_owner_changed(self, proxy):
+ try:
+ if proxy:
+ print "connman appeared on D-Bus ", str(proxy)
+
+ bus = dbus.SystemBus()
+ self.manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+ else:
+ print "connman disappeared on D-Bus"
+ self.manager = None
+ for s in self.sessions.keys():
+ self.sessions[s]['notify'].remove_from_connection()
+ self.sessions[s]['notify'] = None
+
+ self.sessions = {}
+
+ except dbus.DBusException:
+ traceback.print_exc()
+
+ def release(self, session_name):
+ s = self.find_session(session_name)
+ if not s:
+ return
+ if s['session']:
+ s['session'].Destroy()
+ s['session'] = None
+ if s['notify']:
+ s['notify'].remove_from_connection()
+ s['notify'] = None
+ del self.sessions[session_name]
+
+ def type_convert(self, key, value):
+ if key in [ "AllowedBearers" ]:
+ return value
+ elif key in [ "RoamingPolicy", "ConnectionType" ]:
+ if len(value) > 0:
+ return value[0]
+ elif key in [ "Priority", "AvoidHandover",
+ "StayConnected", "EmergencyCall" ]:
+ flag = str(value[0]).strip().lower()
+ val = flag not in ['false', 'f', 'n', '0']
+ return dbus.Boolean(val)
+ elif key in [ "PeriodicConnect", "IdleTimeout" ]:
+ val = value[0]
+ return dbus.UInt32(val)
+
+ return value
+
+ def find_session(self, session_name):
+ if not session_name in self.sessions.keys():
+ return None
+ return self.sessions[session_name]
+
+ @dbus.service.method("com.example.TestSession",
+ in_signature='', out_signature='')
+ def CreateSession(self, session_name):
+ print "Create session"
+
+ s = self.find_session(session_name)
+ if s and s['session'] :
+ print "Session %s already created-> drop reqest" % (session_name)
+ return
+
+ try:
+ bus = dbus.SystemBus()
+
+ if s == None:
+ s = {}
+ s['notify_path'] = self._object_path + "/" + session_name
+ s['notify'] = Notification(bus, self, s['notify_path'])
+ s['notify'].add_to_connection(bus, s['notify_path'])
+ if not 'settings' in s.keys():
+ s['settings'] = {};
+ s['session_path'] = self.manager.CreateSession(s['settings'], s['notify_path'])
+ print "notify path %s" % (s['notify_path'])
+ print "session path %s" % (s['session_path'])
+ s['session'] = dbus.Interface(bus.get_object("net.connman", s['session_path']),
+ "net.connman.Session")
+ self.sessions[session_name] = s
+
+ except dbus.DBusException, e:
+ if e.get_dbus_name() in ['net.connman.Error.Failed']:
+ print e.get_dbus_message()
+ return
+ traceback.print_exc()
+
+ @dbus.service.method("com.example.TestSession",
+ in_signature='', out_signature='')
+ def DestroySession(self, session_name):
+ print "Destroy session"
+
+ s = self.find_session(session_name)
+ if s == None or s['session'] == None:
+ print "The session is not running -> drop request"
+ return
+
+ try:
+ self.release(session_name)
+ except dbus.DBusException:
+ traceback.print_exc()
+
+ @dbus.service.method("com.example.TestSession",
+ in_signature='', out_signature='')
+ def Connect(self, session_name):
+ print "Connect session"
+
+ s = self.find_session(session_name)
+ if s == None or s['session'] == None:
+ print "The session is not running -> drop request"
+ return
+
+ try:
+ s['session'].Connect()
+ except dbus.DBusException, e:
+ if e.get_dbus_name() in ['net.connman.Error.Failed']:
+ print e.get_dbus_message()
+ return
+ traceback.print_exc()
+
+ @dbus.service.method("com.example.TestSession",
+ in_signature='', out_signature='')
+ def Disconnect(self, session_name):
+ print "Disconnect session"
+
+ s = self.find_session(session_name)
+ if s == None or s['session'] == None:
+ print "The session is not running -> drop request"
+ return
+
+ try:
+ s['session'].Disconnect()
+ except dbus.DBusException, e:
+ if e.get_dbus_name() in ['net.connman.Error.Failed']:
+ print e.get_dbus_message()
+ return
+ traceback.print_exc()
+
+ @dbus.service.method("com.example.TestSession",
+ in_signature='', out_signature='')
+ def Change(self, session_name, key, value):
+ print "Update session settings"
+
+ s = self.find_session(session_name)
+ if s == None or s['session'] == None:
+ print "The session is not running -> drop request"
+ return
+
+ try:
+ val = self.type_convert(key, value)
+ s['session'].Change(key, val)
+ except dbus.DBusException, e:
+ if e.get_dbus_name() in ['net.connman.Error.Failed']:
+ print e.get_dbus_message()
+ return
+ traceback.print_exc()
+
+ @dbus.service.method("com.example.TestSession",
+ in_signature='', out_signature='')
+ def Configure(self, session_name, key, value):
+ print "Configure session settings"
+ s = self.find_session(session_name)
+ if s == None:
+ s = {}
+ s['notify_path'] = None
+ s['notify'] = None
+ if not 'settings' in s.keys():
+ s['settings'] = {};
+ s['session_path'] = None
+ s['session'] = None
+ self.sessions[session_name] = s
+ if s and s['session']:
+ print "The session is running, use change -> drop request"
+ return
+ val = self.type_convert(key, value)
+ s['settings'][key] = val
+
+def main():
+ if len(sys.argv) < 2:
+ print "Usage: %s <command>" % (sys.argv[0])
+ print ""
+ print " enable"
+ print " disable"
+ print " create <app_path> <session_name>"
+ print " destroy <app_path> <session_name>"
+ print " connect <app_path> <session_name>"
+ print " disconnect <app_path> <session_name>"
+ print " change <app_path> <session_name> <key> <value>"
+ print " configure <app_path> <session_name> <key> <value>"
+ print ""
+ print " run <app_path>"
+ sys.exit(1)
+
+ dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
+
+ if sys.argv[1] == "enable":
+ bus = dbus.SystemBus()
+ manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+ manager.SetProperty("SessionMode", True)
+ return
+
+ elif sys.argv[1] == "disable":
+ bus = dbus.SystemBus()
+ manager = dbus.Interface(bus.get_object("net.connman", "/"),
+ "net.connman.Manager")
+ manager.SetProperty("SessionMode", False)
+ return
+
+ if (len(sys.argv) < 3):
+ print "Need test application path"
+ sys.exit(1)
+
+ app_path = sys.argv[2]
+ bus = dbus.SessionBus()
+
+ app_name = "com.example.SessionApplication.%s" % (string.strip(app_path, "/"))
+
+ if sys.argv[1] == "run":
+ name = dbus.service.BusName(app_name, bus)
+ mainloop = gobject.MainLoop()
+
+ app = SessionApplication(bus, app_path, mainloop)
+
+ mainloop.run()
+ return
+
+ app = dbus.Interface(bus.get_object(app_name, app_path),
+ "com.example.TestSession")
+
+ if sys.argv[1] == "create":
+ app.CreateSession(sys.argv[3])
+
+ elif sys.argv[1] == "destroy":
+ app.DestroySession(sys.argv[3])
+
+ elif sys.argv[1] == "connect":
+ app.Connect(sys.argv[3])
+
+ elif sys.argv[1] == "disconnect":
+ app.Disconnect(sys.argv[3])
+
+ elif sys.argv[1] == "change":
+ if len(sys.argv) < 5:
+ print "Arguments missing"
+ sys.exit(1)
+
+ app.Change(sys.argv[3], sys.argv[4], sys.argv[5:])
+
+ elif sys.argv[1] == "configure":
+ if len(sys.argv) < 5:
+ print "Arguments missing"
+ sys.exit(1)
+
+ app.Configure(sys.argv[3], sys.argv[4], sys.argv[5:])
+
+ else:
+ print "Unknown command '%s'" % sys.argv[1]
+ sys.exit(1)
+
+if __name__ == '__main__':
+ main()
diff --git a/test/vpn-connect b/test/vpn-connect
new file mode 100755
index 0000000..0f8636d
--- /dev/null
+++ b/test/vpn-connect
@@ -0,0 +1,24 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 2):
+ print "Usage: %s <VPN connection id>" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman.vpn", "/"),
+ "net.connman.vpn.Manager")
+
+connections = manager.GetConnections()
+
+path = "/net/connman/vpn/connection/" + sys.argv[1]
+
+print "Attempting to connect VPN %s" % (path)
+
+connection = dbus.Interface(bus.get_object("net.connman.vpn", path),
+ "net.connman.vpn.Connection")
+
+connection.Connect()
diff --git a/test/vpn-disconnect b/test/vpn-disconnect
new file mode 100755
index 0000000..d7a49ba
--- /dev/null
+++ b/test/vpn-disconnect
@@ -0,0 +1,24 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+if (len(sys.argv) < 1):
+ print "Usage: %s <VPN connection id>" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman.vpn", "/"),
+ "net.connman.vpn.Manager")
+
+connections = manager.GetConnections()
+
+path = "/net/connman/vpn/connection/" + sys.argv[1]
+
+print "Attempting to disconnect VPN %s" % (path)
+
+connection = dbus.Interface(bus.get_object("net.connman.vpn", path),
+ "net.connman.vpn.Connection")
+
+connection.Disconnect()
diff --git a/test/vpn-get b/test/vpn-get
new file mode 100755
index 0000000..f1f760c
--- /dev/null
+++ b/test/vpn-get
@@ -0,0 +1,48 @@
+#!/usr/bin/python
+
+import dbus
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ if type(i).__name__ == 'Dictionary':
+ val += extract_values(i)
+ elif type(i).__name__ == 'Struct':
+ val += extract_list(i)
+ else:
+ val += " " + str(i)
+ val += "]"
+ return val
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object('net.connman.vpn', '/'),
+ 'net.connman.vpn.Manager')
+
+for entry in manager.GetConnections():
+ path = entry[0]
+ properties = entry[1]
+
+ print "[ %s ]" % (path)
+
+ for key in properties.keys():
+ if key in ["IPv4", "IPv6" ]:
+ val = extract_values(properties[key])
+ elif key in ["Nameservers","ServerRoutes","UserRoutes"]:
+ val = extract_list(properties[key])
+ else:
+ val = str(properties[key])
+ print " %s = %s" % (key, val)
+
+ print
diff --git a/test/vpn-property b/test/vpn-property
new file mode 100755
index 0000000..d05f4c7
--- /dev/null
+++ b/test/vpn-property
@@ -0,0 +1,72 @@
+#!/usr/bin/python
+
+import sys
+import dbus
+
+def make_variant(string):
+ return dbus.String(string, variant_level=1)
+
+def extract_values(values):
+ val = "{"
+ for key in values.keys():
+ val += " " + key + "="
+ if key in ["Servers", "Excludes"]:
+ val += extract_list(values[key])
+ else:
+ val += str(values[key])
+ val += " }"
+ return val
+
+def extract_list(list):
+ val = "["
+ for i in list:
+ if type(i).__name__ == 'Dictionary':
+ val += extract_values(i)
+ elif type(i).__name__ == 'Struct':
+ val += extract_list(i)
+ else:
+ val += " " + str(i)
+ val += "]"
+ return val
+
+argc = len(sys.argv)
+
+if (argc < 2):
+ print "Usage: %s <VPN connection id> [<property name>] [<property values>]" % (sys.argv[0])
+ sys.exit(1)
+
+bus = dbus.SystemBus()
+
+manager = dbus.Interface(bus.get_object("net.connman.vpn", "/"),
+ "net.connman.vpn.Manager")
+
+connections = manager.GetConnections()
+
+path = "/net/connman/vpn/connection/" + sys.argv[1]
+
+print "Attempting to connect VPN %s" % (path)
+
+connection = dbus.Interface(bus.get_object("net.connman.vpn", path),
+ "net.connman.vpn.Connection")
+
+if (argc < 3):
+ properties = connection.GetProperties()
+ for key in properties.keys():
+ if key in ["IPv4", "IPv6" ]:
+ val = extract_values(properties[key])
+ elif key in ["Nameservers","ServerRoutes","UserRoutes"]:
+ val = extract_list(properties[key])
+ else:
+ val = str(properties[key])
+ print " %s = %s" % (key, val)
+
+elif (argc < 4):
+ try:
+ connection.ClearProperty(sys.argv[2])
+ except dbus.DBusException, error:
+ print "%s: %s" % (error._dbus_error_name, error.message)
+else:
+ try:
+ connection.SetProperty(sys.argv[2], sys.argv[3])
+ except dbus.DBusException, error:
+ print "%s: %s" % (error._dbus_error_name, error.message)
diff --git a/tools/addr-test.c b/tools/addr-test.c
new file mode 100644
index 0000000..273ab02
--- /dev/null
+++ b/tools/addr-test.c
@@ -0,0 +1,66 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <arpa/inet.h>
+
+static unsigned char netmask2prefixlen(const char *netmask)
+{
+ unsigned char bits = 0;
+ in_addr_t mask = inet_network(netmask);
+ in_addr_t host = ~mask;
+
+ /* a valid netmask must be 2^n - 1 */
+ if ((host & (host + 1)) != 0)
+ return -1;
+
+ for (; mask; mask <<= 1)
+ ++bits;
+
+ return bits;
+}
+
+int main(int argc, char *argv[])
+{
+ const char *masks[] = { "255.255.255.255", "255.255.255.0",
+ "255.255.0.0", "255.0.0.0" };
+ struct in_addr addr;
+ int i, len;
+
+ for (i = 0; i < 4; i++) {
+ printf("subnet %-16s prefixlen %u\n", masks[i],
+ netmask2prefixlen(masks[i]));
+ }
+
+ printf("\n");
+
+ for (i = 0; i < 4; i++) {
+ len = (i + 1) * 8;
+ addr.s_addr = htonl(~(0xfffffffflu >> len));
+ printf("prefixlen %-2u netmask %s\n", len, inet_ntoa(addr));
+ }
+
+ return 0;
+}
diff --git a/tools/dbus-test.c b/tools/dbus-test.c
new file mode 100644
index 0000000..ece5d19
--- /dev/null
+++ b/tools/dbus-test.c
@@ -0,0 +1,85 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <gdbus.h>
+
+#define DBG(fmt, arg...) do { \
+ printf("%s() " fmt "\n", __FUNCTION__ , ## arg); \
+} while (0)
+
+static GMainLoop *main_loop = NULL;
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static void disconnect_callback(DBusConnection *conn, void *user_data)
+{
+ printf("D-Bus disconnect\n");
+
+ g_main_loop_quit(main_loop);
+}
+
+int main(int argc, char *argv[])
+{
+ DBusConnection *conn;
+ DBusError err;
+ struct sigaction sa;
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ dbus_error_init(&err);
+
+ conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
+ if (!conn) {
+ if (dbus_error_is_set(&err)) {
+ fprintf(stderr, "%s\n", err.message);
+ dbus_error_free(&err);
+ } else
+ fprintf(stderr, "Can't register with system bus\n");
+ exit(1);
+ }
+
+ g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ dbus_connection_unref(conn);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
diff --git a/tools/dhcp-server-test.c b/tools/dhcp-server-test.c
new file mode 100644
index 0000000..b7d2e54
--- /dev/null
+++ b/tools/dhcp-server-test.c
@@ -0,0 +1,123 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gdhcp/gdhcp.h>
+
+static GMainLoop *main_loop;
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static void handle_error(GDHCPServerError error)
+{
+ switch (error) {
+ case G_DHCP_SERVER_ERROR_NONE:
+ printf("dhcp server ok\n");
+ break;
+ case G_DHCP_SERVER_ERROR_INTERFACE_UNAVAILABLE:
+ printf("Interface unavailable\n");
+ break;
+ case G_DHCP_SERVER_ERROR_INTERFACE_IN_USE:
+ printf("Interface in use\n");
+ break;
+ case G_DHCP_SERVER_ERROR_INTERFACE_DOWN:
+ printf("Interface down\n");
+ break;
+ case G_DHCP_SERVER_ERROR_NOMEM:
+ printf("No memory\n");
+ break;
+ case G_DHCP_SERVER_ERROR_INVALID_INDEX:
+ printf("Invalid index\n");
+ break;
+ case G_DHCP_SERVER_ERROR_INVALID_OPTION:
+ printf("Invalid option\n");
+ break;
+ case G_DHCP_SERVER_ERROR_IP_ADDRESS_INVALID:
+ printf("Invalid address\n");
+ break;
+ }
+}
+
+static void dhcp_debug(const char *str, void *data)
+{
+ printf("%s: %s\n", (const char *) data, str);
+}
+
+
+int main(int argc, char *argv[])
+{
+ struct sigaction sa;
+ GDHCPServerError error;
+ GDHCPServer *dhcp_server;
+ int index;
+
+ if (argc < 2) {
+ printf("Usage: dhcp-server-test <interface index>\n");
+ exit(0);
+ }
+
+ index = atoi(argv[1]);
+
+ printf("Create DHCP server for interface %d\n", index);
+
+ dhcp_server = g_dhcp_server_new(G_DHCP_IPV4, index, &error);
+ if (!dhcp_server) {
+ handle_error(error);
+ exit(0);
+ }
+
+ g_dhcp_server_set_debug(dhcp_server, dhcp_debug, "DHCP");
+
+ g_dhcp_server_set_lease_time(dhcp_server, 3600);
+ g_dhcp_server_set_option(dhcp_server, G_DHCP_SUBNET, "255.255.0.0");
+ g_dhcp_server_set_option(dhcp_server, G_DHCP_ROUTER, "192.168.0.2");
+ g_dhcp_server_set_option(dhcp_server, G_DHCP_DNS_SERVER, "192.168.0.3");
+ g_dhcp_server_set_ip_range(dhcp_server, "192.168.0.101",
+ "192.168.0.102");
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ printf("Start DHCP Server operation\n");
+
+ g_dhcp_server_start(dhcp_server);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_dhcp_server_unref(dhcp_server);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
diff --git a/tools/dhcp-test.c b/tools/dhcp-test.c
new file mode 100644
index 0000000..c34e10a
--- /dev/null
+++ b/tools/dhcp-test.c
@@ -0,0 +1,189 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <net/route.h>
+#include <net/ethernet.h>
+#include <linux/if_arp.h>
+
+#include <gdhcp/gdhcp.h>
+
+static GTimer *timer;
+
+static GMainLoop *main_loop;
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static void print_elapsed(void)
+{
+ gdouble elapsed;
+
+ elapsed = g_timer_elapsed(timer, NULL);
+
+ printf("elapsed: %f seconds\n", elapsed);
+}
+
+static void handle_error(GDHCPClientError error)
+{
+ switch (error) {
+ case G_DHCP_CLIENT_ERROR_NONE:
+ printf("dhcp client ok\n");
+ break;
+ case G_DHCP_CLIENT_ERROR_INTERFACE_UNAVAILABLE:
+ printf("Interface unavailable\n");
+ break;
+ case G_DHCP_CLIENT_ERROR_INTERFACE_IN_USE:
+ printf("Interface in use\n");
+ break;
+ case G_DHCP_CLIENT_ERROR_INTERFACE_DOWN:
+ printf("Interface down\n");
+ break;
+ case G_DHCP_CLIENT_ERROR_NOMEM:
+ printf("No memory\n");
+ break;
+ case G_DHCP_CLIENT_ERROR_INVALID_INDEX:
+ printf("Invalid index\n");
+ break;
+ case G_DHCP_CLIENT_ERROR_INVALID_OPTION:
+ printf("Invalid option\n");
+ break;
+ }
+}
+
+static void no_lease_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ print_elapsed();
+
+ printf("No lease available\n");
+
+ g_main_loop_quit(main_loop);
+}
+
+static void lease_available_cb(GDHCPClient *dhcp_client, gpointer user_data)
+{
+ GList *list, *option_value = NULL;
+ char *address;
+
+ print_elapsed();
+
+ printf("Lease available\n");
+
+ address = g_dhcp_client_get_address(dhcp_client);
+ printf("address %s\n", address);
+ if (!address)
+ return;
+
+ option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_SUBNET);
+ for (list = option_value; list; list = list->next)
+ printf("sub-mask %s\n", (char *) list->data);
+
+ option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_DNS_SERVER);
+ for (list = option_value; list; list = list->next)
+ printf("domain-name-servers %s\n", (char *) list->data);
+
+ option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_DOMAIN_NAME);
+ for (list = option_value; list; list = list->next)
+ printf("domain-name %s\n", (char *) list->data);
+
+ option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_ROUTER);
+ for (list = option_value; list; list = list->next)
+ printf("routers %s\n", (char *) list->data);
+
+ option_value = g_dhcp_client_get_option(dhcp_client, G_DHCP_HOST_NAME);
+ for (list = option_value; list; list = list->next)
+ printf("hostname %s\n", (char *) list->data);
+}
+
+int main(int argc, char *argv[])
+{
+ struct sigaction sa;
+ GDHCPClientError error;
+ GDHCPClient *dhcp_client;
+ int index;
+
+ if (argc < 2) {
+ printf("Usage: dhcp-test <interface index>\n");
+ exit(0);
+ }
+
+ index = atoi(argv[1]);
+
+ printf("Create DHCP client for interface %d\n", index);
+
+ dhcp_client = g_dhcp_client_new(G_DHCP_IPV4, index, &error);
+ if (!dhcp_client) {
+ handle_error(error);
+ exit(0);
+ }
+
+ g_dhcp_client_set_send(dhcp_client, G_DHCP_HOST_NAME, "<hostname>");
+
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_HOST_NAME);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_SUBNET);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_DNS_SERVER);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_DOMAIN_NAME);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_NTP_SERVER);
+ g_dhcp_client_set_request(dhcp_client, G_DHCP_ROUTER);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_LEASE_AVAILABLE,
+ lease_available_cb, NULL);
+
+ g_dhcp_client_register_event(dhcp_client,
+ G_DHCP_CLIENT_EVENT_NO_LEASE, no_lease_cb, NULL);
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ printf("Start DHCP operation\n");
+
+ timer = g_timer_new();
+
+ g_dhcp_client_start(dhcp_client, NULL);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_timer_destroy(timer);
+
+ g_dhcp_client_unref(dhcp_client);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
diff --git a/tools/dnsproxy-test.c b/tools/dnsproxy-test.c
new file mode 100644
index 0000000..551cae9
--- /dev/null
+++ b/tools/dnsproxy-test.c
@@ -0,0 +1,466 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netdb.h>
+#include <resolv.h>
+#include <glib.h>
+#include <fcntl.h>
+
+#if 0
+#define DEBUG
+#endif
+#ifdef DEBUG
+#include <stdio.h>
+
+#define LOG(fmt, arg...) do { \
+ fprintf(stdout, "%s:%s() " fmt "\n", \
+ __FILE__, __func__ , ## arg); \
+} while (0)
+#else
+#define LOG(fmt, arg...)
+#endif
+
+static unsigned char msg[] = {
+ 0x00, 0x1c, /* len 28 */
+ 0x31, 0x82, /* tran id */
+ 0x01, 0x00, /* flags (recursion required) */
+ 0x00, 0x01, /* questions (1) */
+ 0x00, 0x00, /* answer rr */
+ 0x00, 0x00, /* authority rr */
+ 0x00, 0x00, /* additional rr */
+ 0x06, 0x6c, 0x6f, 0x6c, 0x67, 0x65, 0x30, /* lolge0, just some name */
+ 0x03, 0x63, 0x6f, 0x6d, /* com */
+ 0x00, /* null terminator */
+ 0x00, 0x01, /* type A */
+ 0x00, 0x01, /* class IN */
+};
+
+static unsigned char msg2[] = {
+ 0x00, 0x1c, /* len 28 */
+ 0x31, 0x83, /* tran id */
+ 0x01, 0x00, /* flags (recursion required) */
+ 0x00, 0x01, /* questions (1) */
+ 0x00, 0x00, /* answer rr */
+ 0x00, 0x00, /* authority rr */
+ 0x00, 0x00, /* additional rr */
+ 0x06, 0x6c, 0x6f, 0x67, 0x6c, 0x67, 0x65, /* loelge */
+ 0x03, 0x63, 0x6f, 0x6d, /* com */
+ 0x00, /* null terminator */
+ 0x00, 0x01, /* type A */
+ 0x00, 0x01, /* class IN */
+
+ 0x00, 0x1c, /* len 28 */
+ 0x31, 0x84, /* tran id */
+ 0x01, 0x00, /* flags (recursion required) */
+ 0x00, 0x01, /* questions (1) */
+ 0x00, 0x00, /* answer rr */
+ 0x00, 0x00, /* authority rr */
+ 0x00, 0x00, /* additional rr */
+ 0x06, 0x6c, 0x6f, 0x67, 0x6c, 0x67, 0x65, /* loelge */
+ 0x03, 0x6e, 0x65, 0x74, /* net */
+ 0x00, /* null terminator */
+ 0x00, 0x01, /* type A */
+ 0x00, 0x01, /* class IN */
+};
+
+static unsigned char msg_invalid[] = {
+ 0x00, 0x1c, /* len 28 */
+ 0x31, 0xC0, /* tran id */
+};
+
+static int create_tcp_socket(int family)
+{
+ int sk, err;
+
+ sk = socket(family, SOCK_STREAM, IPPROTO_TCP);
+ if (sk < 0) {
+ err = errno;
+ LOG("Failed to create TCP socket %d/%s", err, strerror(err));
+ return -err;
+ }
+
+ return sk;
+}
+
+static int create_udp_socket(int family)
+{
+ int sk, err;
+
+ sk = socket(family, SOCK_DGRAM, IPPROTO_UDP);
+ if (sk < 0) {
+ err = errno;
+ LOG("Failed to create UDP socket %d/%s", err, strerror(err));
+ return -err;
+ }
+
+ return sk;
+}
+
+static int connect_tcp_socket(char *server)
+{
+ int sk;
+ int err = 0;
+
+ struct addrinfo hints, *rp;
+
+ memset(&hints, 0, sizeof(hints));
+
+ hints.ai_socktype = SOCK_STREAM;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_flags = AI_NUMERICSERV | AI_NUMERICHOST;
+ getaddrinfo(server, "53", &hints, &rp);
+
+ sk = create_tcp_socket(rp->ai_family);
+ err = sk;
+
+ LOG("sk %d family %d", sk, rp->ai_family);
+
+ if (sk >= 0 && connect(sk, rp->ai_addr, rp->ai_addrlen) < 0) {
+ err = -errno;
+ close(sk);
+ sk = -1;
+
+ fprintf(stderr, "Failed to connect to DNS server at %s "
+ "errno %d/%s\n",
+ server, -err, strerror(-err));
+ }
+
+ if (sk >= 0)
+ fcntl(sk, F_SETFL, O_NONBLOCK);
+
+ freeaddrinfo(rp);
+
+ return err;
+}
+
+static int send_msg(int sk, unsigned char *msg, unsigned int len,
+ int sleep_between)
+{
+ unsigned int i;
+ int err;
+
+ for (i = 0; i < len; i++) {
+ err = write(sk, &msg[i], 1);
+ if (err < 0) {
+ err = -errno;
+ LOG("write failed errno %d/%s", -err, strerror(-err));
+ }
+
+ g_assert_cmpint(err, >=, 0);
+ if (err < 0)
+ return err;
+
+ if (sleep_between)
+ usleep(1000);
+ }
+
+ return 0;
+}
+
+static int connect_udp_socket(char *server, struct sockaddr *sa,
+ socklen_t *sa_len)
+{
+ int sk;
+ int err = 0;
+
+ struct addrinfo hints, *rp;
+
+ memset(&hints, 0, sizeof(hints));
+
+ hints.ai_socktype = SOCK_DGRAM;
+ hints.ai_family = AF_UNSPEC;
+ hints.ai_flags = AI_NUMERICSERV | AI_NUMERICHOST;
+ getaddrinfo(server, "53", &hints, &rp);
+
+ sk = create_udp_socket(rp->ai_family);
+ err = sk;
+
+ LOG("sk %d family %d", sk, rp->ai_family);
+
+ if (sk < 0) {
+ err = -errno;
+ fprintf(stderr, "Failed to connect to DNS server at %s "
+ "errno %d/%s\n",
+ server, -err, strerror(-err));
+ } else {
+ memcpy(sa, rp->ai_addr, *sa_len);
+ *sa_len = rp->ai_addrlen;
+ }
+
+ freeaddrinfo(rp);
+
+ return err;
+}
+
+static int sendto_msg(int sk, struct sockaddr *sa, socklen_t salen,
+ unsigned char *msg, unsigned int len)
+{
+ int err;
+
+ err = sendto(sk, msg, len, MSG_NOSIGNAL, sa, salen);
+ if (err < 0) {
+ err = -errno;
+ LOG("sendto failed errno %d/%s", -err, strerror(-err));
+ }
+
+ g_assert_cmpint(err, >=, 0);
+ if (err < 0)
+ return err;
+
+ return 0;
+}
+
+static unsigned short get_id(void)
+{
+ return random();
+}
+
+static void change_msg(unsigned char *msg, unsigned int tranid,
+ unsigned int host_loc, unsigned char host_count)
+{
+ unsigned short id = get_id();
+
+ msg[tranid] = id >> 8;
+ msg[tranid+1] = id;
+ msg[host_loc] = host_count;
+}
+
+static void change_msg2(unsigned char *msg, unsigned char host_count)
+{
+ change_msg(msg, 2, 20, host_count);
+ change_msg(msg, 32, 50, host_count+1);
+}
+
+static int receive_message(int sk, int timeout, int expected, int *server_closed)
+{
+ int ret, received = 0;
+ unsigned char buf[512];
+
+ while (timeout > 0) {
+ ret = read(sk, buf, sizeof(buf));
+ if (ret > 0) {
+ LOG("received %d bytes from server %d", ret, sk);
+ received += ret;
+ if (received >= expected)
+ break;
+ } else if (ret == 0) {
+ LOG("server %d closed socket", sk);
+ if (server_closed)
+ *server_closed = 1;
+ break;
+ } else {
+ if (errno != EAGAIN && errno != EWOULDBLOCK)
+ break;
+ }
+
+ sleep(1);
+ timeout--;
+ }
+
+ return received;
+}
+
+static int receive_from_message(int sk, struct sockaddr *sa, socklen_t len,
+ int timeout, int expected)
+{
+ int ret, received = 0;
+ unsigned char buf[512];
+
+ fcntl(sk, F_SETFL, O_NONBLOCK);
+
+ while (timeout > 0) {
+ ret = recvfrom(sk, buf, sizeof(buf), 0, sa, &len);
+ if (ret > 0) {
+ LOG("received %d bytes from server %d", ret, sk);
+ received += ret;
+ if (received >= expected)
+ break;
+ } else if (ret < 0) {
+ if (errno != EAGAIN && errno != EWOULDBLOCK)
+ break;
+ }
+
+ sleep(1);
+ timeout--;
+ }
+
+ return received;
+}
+
+static void test_ipv4_udp_msg(void)
+{
+ int sk, received = 0;
+ struct sockaddr_in sa;
+ socklen_t len = sizeof(sa);
+
+ sk = connect_udp_socket("127.0.0.1", (struct sockaddr *)&sa, &len);
+ g_assert_cmpint(sk, >=, 0);
+ change_msg(msg, 2, 20, '1');
+ sendto_msg(sk, (struct sockaddr *)&sa, len, msg, sizeof(msg));
+ received = receive_from_message(sk, (struct sockaddr *)&sa, len,
+ 10, sizeof(msg));
+ close(sk);
+
+ g_assert_cmpint(received, >=, sizeof(msg));
+}
+
+static void test_ipv6_udp_msg(void)
+{
+ int sk, received = 0;
+ struct sockaddr_in6 sa;
+ socklen_t len = sizeof(sa);
+
+ sk = connect_udp_socket("::1", (struct sockaddr *)&sa, &len);
+ g_assert_cmpint(sk, >=, 0);
+ change_msg(msg, 2, 20, '1');
+ sendto_msg(sk, (struct sockaddr *)&sa, len, msg, sizeof(msg));
+ received = receive_from_message(sk, (struct sockaddr *)&sa, len,
+ 10, sizeof(msg));
+ close(sk);
+
+ g_assert_cmpint(received, >=, sizeof(msg));
+}
+
+static void test_partial_ipv4_tcp_msg(void)
+{
+ int sk, received = 0;
+
+ sk = connect_tcp_socket("127.0.0.1");
+ g_assert_cmpint(sk, >=, 0);
+ change_msg(msg, 2, 20, '1');
+ send_msg(sk, msg, sizeof(msg), 1);
+ received = receive_message(sk, 10, sizeof(msg), NULL);
+ close(sk);
+
+ g_assert_cmpint(received, >=, sizeof(msg));
+}
+
+static void test_partial_ipv6_tcp_msg(void)
+{
+ int sk, received = 0;
+
+ sk = connect_tcp_socket("::1");
+ g_assert_cmpint(sk, >=, 0);
+ change_msg(msg, 2, 20, '2');
+ send_msg(sk, msg, sizeof(msg), 1);
+ received = receive_message(sk, 10, sizeof(msg), NULL);
+ close(sk);
+
+ g_assert_cmpint(received, >=, sizeof(msg));
+}
+
+static void test_multiple_ipv4_tcp_msg(void)
+{
+ int sk, received = 0, server_closed = 0;
+
+ sk = connect_tcp_socket("127.0.0.1");
+ g_assert_cmpint(sk, >=, 0);
+ change_msg2(msg2, '1');
+ send_msg(sk, msg2, sizeof(msg2), 0);
+ received = receive_message(sk, 35, sizeof(msg2), &server_closed);
+ close(sk);
+
+ /* If the final DNS server refuses to serve us, then do not consider
+ * it an error. This happens very often with unbound.
+ */
+ if (server_closed == 0)
+ g_assert_cmpint(received, >=, sizeof(msg2));
+}
+
+static void test_multiple_ipv6_tcp_msg(void)
+{
+ int sk, received = 0, server_closed = 0;
+
+ sk = connect_tcp_socket("::1");
+ g_assert_cmpint(sk, >=, 0);
+ change_msg2(msg2, '2');
+ send_msg(sk, msg2, sizeof(msg2), 0);
+ received = receive_message(sk, 35, sizeof(msg2), &server_closed);
+ close(sk);
+
+ if (server_closed == 0)
+ g_assert_cmpint(received, >=, sizeof(msg2));
+}
+
+static void test_failure_tcp_msg(void)
+{
+ int sk, received = 0;
+
+ sk = connect_tcp_socket("127.0.0.1");
+ g_assert_cmpint(sk, >=, 0);
+ send_msg(sk, msg_invalid, sizeof(msg_invalid), 0);
+ received = receive_message(sk, 10, 0, NULL);
+ close(sk);
+
+ g_assert_cmpint(received, ==, 0);
+}
+
+int main(int argc, char *argv[])
+{
+ g_test_init(&argc, &argv, NULL);
+
+ g_test_add_func("/dnsproxy/ipv4 udp msg",
+ test_ipv4_udp_msg);
+
+ g_test_add_func("/dnsproxy/ipv6 udp msg",
+ test_ipv6_udp_msg);
+
+ g_test_add_func("/dnsproxy/failure tcp msg ",
+ test_failure_tcp_msg);
+
+ g_test_add_func("/dnsproxy/partial ipv4 tcp msg",
+ test_partial_ipv4_tcp_msg);
+
+ g_test_add_func("/dnsproxy/partial ipv6 tcp msg",
+ test_partial_ipv6_tcp_msg);
+
+ g_test_add_func("/dnsproxy/partial ipv4 tcp msg from cache",
+ test_partial_ipv4_tcp_msg);
+
+ g_test_add_func("/dnsproxy/partial ipv6 tcp msg from cache",
+ test_partial_ipv6_tcp_msg);
+
+ g_test_add_func("/dnsproxy/multiple ipv4 tcp msg",
+ test_multiple_ipv4_tcp_msg);
+
+ g_test_add_func("/dnsproxy/multiple ipv6 tcp msg",
+ test_multiple_ipv6_tcp_msg);
+
+ g_test_add_func("/dnsproxy/multiple ipv4 tcp msg from cache",
+ test_multiple_ipv4_tcp_msg);
+
+ g_test_add_func("/dnsproxy/multiple ipv6 tcp msg from cache",
+ test_multiple_ipv6_tcp_msg);
+
+ return g_test_run();
+}
diff --git a/tools/iptables-test.c b/tools/iptables-test.c
new file mode 100644
index 0000000..2df53cc
--- /dev/null
+++ b/tools/iptables-test.c
@@ -0,0 +1,161 @@
+/*
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2013 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <getopt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include "../src/connman.h"
+
+enum iptables_command {
+ IPTABLES_COMMAND_APPEND,
+ IPTABLES_COMMAND_INSERT,
+ IPTABLES_COMMAND_DELETE,
+ IPTABLES_COMMAND_POLICY,
+ IPTABLES_COMMAND_CHAIN_INSERT,
+ IPTABLES_COMMAND_CHAIN_DELETE,
+ IPTABLES_COMMAND_CHAIN_FLUSH,
+ IPTABLES_COMMAND_DUMP,
+ IPTABLES_COMMAND_UNKNOWN,
+};
+
+int main(int argc, char *argv[])
+{
+ enum iptables_command cmd = IPTABLES_COMMAND_UNKNOWN;
+ char *table = NULL, *chain = NULL, *rule = NULL, *tmp;
+ int err, c, i;
+
+ opterr = 0;
+
+ while ((c = getopt_long(argc, argv,
+ "-A:I:D:P:N:X:F:Lt:", NULL, NULL)) != -1) {
+ switch (c) {
+ case 'A':
+ chain = optarg;
+ cmd = IPTABLES_COMMAND_APPEND;
+ break;
+ case 'I':
+ chain = optarg;
+ cmd = IPTABLES_COMMAND_INSERT;
+ break;
+ case 'D':
+ chain = optarg;
+ cmd = IPTABLES_COMMAND_DELETE;
+ break;
+ case 'P':
+ chain = optarg;
+ /* The policy will be stored in rule. */
+ cmd = IPTABLES_COMMAND_POLICY;
+ break;
+ case 'N':
+ chain = optarg;
+ cmd = IPTABLES_COMMAND_CHAIN_INSERT;
+ break;
+ case 'X':
+ chain = optarg;
+ cmd = IPTABLES_COMMAND_CHAIN_DELETE;
+ break;
+ case 'F':
+ chain = optarg;
+ cmd = IPTABLES_COMMAND_CHAIN_FLUSH;
+ break;
+ case 'L':
+ cmd = IPTABLES_COMMAND_DUMP;
+ break;
+ case 't':
+ table = optarg;
+ break;
+ default:
+ goto out;
+ }
+ }
+
+out:
+ if (!table)
+ table = "filter";
+
+ for (i = optind - 1; i < argc; i++) {
+ if (rule) {
+ tmp = rule;
+ rule = g_strdup_printf("%s %s", rule, argv[i]);
+ g_free(tmp);
+ } else
+ rule = g_strdup(argv[i]);
+ }
+
+ __connman_iptables_init();
+
+ switch (cmd) {
+ case IPTABLES_COMMAND_APPEND:
+ err = __connman_iptables_append(table, chain, rule);
+ break;
+ case IPTABLES_COMMAND_INSERT:
+ err = __connman_iptables_insert(table, chain, rule);
+ break;
+ case IPTABLES_COMMAND_DELETE:
+ err = __connman_iptables_delete(table, chain, rule);
+ break;
+ case IPTABLES_COMMAND_POLICY:
+ err = __connman_iptables_change_policy(table, chain, rule);
+ break;
+ case IPTABLES_COMMAND_CHAIN_INSERT:
+ err = __connman_iptables_new_chain(table, chain);
+ break;
+ case IPTABLES_COMMAND_CHAIN_DELETE:
+ err = __connman_iptables_delete_chain(table, chain);
+ break;
+ case IPTABLES_COMMAND_CHAIN_FLUSH:
+ err = __connman_iptables_flush_chain(table, chain);
+ break;
+ case IPTABLES_COMMAND_DUMP:
+ __connman_log_init(argv[0], "*", false, false,
+ "iptables-test", "1");
+ err = __connman_iptables_dump(table);
+ break;
+ case IPTABLES_COMMAND_UNKNOWN:
+ printf("Missing command\n");
+ printf("usage: iptables-test [-t table] {-A|-I|-D} chain rule\n");
+ printf(" iptables-test [-t table] {-N|-X|-F} chain\n");
+ printf(" iptables-test [-t table] -L\n");
+ printf(" iptables-test [-t table] -P chain target\n");
+ exit(-EINVAL);
+ }
+
+ if (err < 0) {
+ printf("Error: %s\n", strerror(-err));
+ exit(err);
+ }
+
+ err = __connman_iptables_commit(table);
+ if (err < 0) {
+ printf("Failed to commit changes: %s\n", strerror(-err));
+ exit(err);
+ }
+
+ g_free(rule);
+
+ __connman_iptables_cleanup();
+
+ return 0;
+}
diff --git a/tools/iptables-unit.c b/tools/iptables-unit.c
new file mode 100644
index 0000000..7e427e2
--- /dev/null
+++ b/tools/iptables-unit.c
@@ -0,0 +1,556 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+
+#include "../src/connman.h"
+
+static bool assert_rule(const char *table_name, const char *rule)
+{
+ char *cmd, *output, **lines;
+ GError **error = NULL;
+ int i;
+
+ cmd = g_strdup_printf(IPTABLES_SAVE " -t %s", table_name);
+ g_spawn_command_line_sync(cmd, &output, NULL, NULL, error);
+ g_free(cmd);
+
+ lines = g_strsplit(output, "\n", 0);
+ g_free(output);
+
+ for (i = 0; lines[i]; i++) {
+ DBG("lines[%02d]: %s\n", i, lines[i]);
+ if (g_strcmp0(lines[i], rule) == 0)
+ break;
+ }
+ g_strfreev(lines);
+
+ if (!lines[i])
+ return false;
+
+ return true;
+}
+
+static void assert_rule_exists(const char *table_name, const char *rule)
+{
+ if (g_strcmp0(IPTABLES_SAVE, "") == 0) {
+ DBG("iptables-save is missing, no assertion possible");
+ return;
+ }
+
+ g_assert(assert_rule(table_name, rule));
+}
+
+static void assert_rule_not_exists(const char *table_name, const char *rule)
+{
+ if (g_strcmp0(IPTABLES_SAVE, "") == 0) {
+ DBG("iptables-save is missing, no assertion possible");
+ return;
+ }
+
+ g_assert(!assert_rule(table_name, rule));
+}
+
+static void test_iptables_chain0(void)
+{
+ int err;
+
+ err = __connman_iptables_new_chain("filter", "foo");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter", ":foo - [0:0]");
+
+ err = __connman_iptables_delete_chain("filter", "foo");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("filter", ":foo - [0:0]");
+}
+
+static void test_iptables_chain1(void)
+{
+ int err;
+
+ err = __connman_iptables_new_chain("filter", "foo");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ err = __connman_iptables_flush_chain("filter", "foo");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ err = __connman_iptables_delete_chain("filter", "foo");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+}
+
+static void test_iptables_chain2(void)
+{
+ int err;
+
+ err = __connman_iptables_change_policy("filter", "INPUT", "DROP");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ err = __connman_iptables_change_policy("filter", "INPUT", "ACCEPT");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+}
+
+static void test_iptables_chain3(void)
+{
+ int err;
+
+ err = __connman_iptables_new_chain("filter", "user-chain-0");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter", ":user-chain-0 - [0:0]");
+
+ err = __connman_iptables_new_chain("filter", "user-chain-1");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter", ":user-chain-0 - [0:0]");
+ assert_rule_exists("filter", ":user-chain-1 - [0:0]");
+
+ err = __connman_iptables_delete_chain("filter", "user-chain-1");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter", ":user-chain-0 - [0:0]");
+ assert_rule_not_exists("filter", ":user-chain-1 - [0:0]");
+
+ err = __connman_iptables_delete_chain("filter", "user-chain-0");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("filter", ":user-chain-0 - [0:0]");
+}
+
+static void test_iptables_rule0(void)
+{
+ int err;
+
+ /* Test simple appending and removing a rule */
+
+ err = __connman_iptables_append("filter", "INPUT",
+ "-m mark --mark 1 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter",
+ "-A INPUT -m mark --mark 0x1 -j LOG");
+
+ err = __connman_iptables_delete("filter", "INPUT",
+ "-m mark --mark 1 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("filter",
+ "-A INPUT -m mark --mark 0x1 -j LOG");
+}
+
+static void test_iptables_rule1(void)
+{
+ int err;
+
+ /* Test if we can do NAT stuff */
+
+ err = __connman_iptables_append("nat", "POSTROUTING",
+ "-s 10.10.1.0/24 -o eth0 -j MASQUERADE");
+
+ err = __connman_iptables_commit("nat");
+ g_assert(err == 0);
+
+ assert_rule_exists("nat",
+ "-A POSTROUTING -s 10.10.1.0/24 -o eth0 -j MASQUERADE");
+
+ err = __connman_iptables_delete("nat", "POSTROUTING",
+ "-s 10.10.1.0/24 -o eth0 -j MASQUERADE");
+
+ err = __connman_iptables_commit("nat");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("nat",
+ "-A POSTROUTING -s 10.10.1.0/24 -o eth0 -j MASQUERADE");
+}
+
+static void test_iptables_rule2(void)
+{
+ int err;
+
+ /* Test if the right rule is removed */
+
+ err = __connman_iptables_append("filter", "INPUT",
+ "-m mark --mark 1 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter",
+ "-A INPUT -m mark --mark 0x1 -j LOG");
+
+ err = __connman_iptables_append("filter", "INPUT",
+ "-m mark --mark 2 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter",
+ "-A INPUT -m mark --mark 0x1 -j LOG");
+ assert_rule_exists("filter",
+ "-A INPUT -m mark --mark 0x2 -j LOG");
+
+ err = __connman_iptables_delete("filter", "INPUT",
+ "-m mark --mark 2 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter",
+ "-A INPUT -m mark --mark 0x1 -j LOG");
+ assert_rule_not_exists("filter",
+ "-A INPUT -m mark --mark 0x2 -j LOG");
+
+ err = __connman_iptables_delete("filter", "INPUT",
+ "-m mark --mark 1 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("filter",
+ "-A INPUT -m mark --mark 0x1 -j LOG");
+}
+
+static void test_iptables_target0(void)
+{
+ int err;
+
+ /* Test if 'fallthrough' targets work */
+
+ err = __connman_iptables_append("filter", "INPUT",
+ "-m mark --mark 1");
+ g_assert(err == 0);
+
+ err = __connman_iptables_append("filter", "INPUT",
+ "-m mark --mark 2");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_exists("filter", "-A INPUT -m mark --mark 0x1");
+ assert_rule_exists("filter", "-A INPUT -m mark --mark 0x2");
+
+ err = __connman_iptables_delete("filter", "INPUT",
+ "-m mark --mark 1");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ err = __connman_iptables_delete("filter", "INPUT",
+ "-m mark --mark 2");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("filter");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("filter", "-A INPUT -m mark --mark 0x1");
+ assert_rule_not_exists("filter", "-A INPUT -m mark --mark 0x2");
+}
+
+struct connman_notifier *nat_notifier;
+
+struct connman_service {
+ char *dummy;
+};
+
+char *connman_service_get_interface(struct connman_service *service)
+{
+ return "eth0";
+}
+
+int connman_notifier_register(struct connman_notifier *notifier)
+{
+ nat_notifier = notifier;
+
+ return 0;
+}
+
+void connman_notifier_unregister(struct connman_notifier *notifier)
+{
+ nat_notifier = NULL;
+}
+
+static void test_nat_basic0(void)
+{
+ int err;
+
+ err = __connman_nat_enable("bridge", "192.168.2.1", 24);
+ g_assert(err == 0);
+
+ /* test that table is empty */
+ err = __connman_iptables_append("nat", "POSTROUTING",
+ "-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("nat");
+ g_assert(err == 0);
+
+ assert_rule_exists("nat",
+ "-A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE");
+
+ err = __connman_iptables_delete("nat", "POSTROUTING",
+ "-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("nat");
+ g_assert(err == 0);
+
+ assert_rule_not_exists("nat",
+ "-A POSTROUTING -s 192.168.2.0/24 -o eth0 -j MASQUERADE");
+
+ __connman_nat_disable("bridge");
+}
+
+static void test_nat_basic1(void)
+{
+ struct connman_service *service;
+ int err;
+
+ service = g_try_new0(struct connman_service, 1);
+ g_assert(service);
+
+ nat_notifier->default_changed(service);
+
+ err = __connman_nat_enable("bridge", "192.168.2.1", 24);
+ g_assert(err == 0);
+
+ /* test that table is not empty */
+ err = __connman_iptables_append("nat", "POSTROUTING",
+ "-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("nat");
+ g_assert(err == 0);
+
+ __connman_nat_disable("bridge");
+
+ /* test that table is empty again */
+ err = __connman_iptables_delete("nat", "POSTROUTING",
+ "-s 192.168.2.1/24 -o eth0 -j MASQUERADE");
+ g_assert(err == 0);
+
+ err = __connman_iptables_commit("nat");
+ g_assert(err == 0);
+
+ g_free(service);
+}
+
+static void test_firewall_basic0(void)
+{
+ struct firewall_context *ctx;
+ int err;
+
+ ctx = __connman_firewall_create();
+ g_assert(ctx);
+
+ err = __connman_firewall_add_rule(ctx, "filter", "INPUT",
+ "-m mark --mark 999 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_firewall_enable(ctx);
+ g_assert(err == 0);
+
+ assert_rule_exists("filter", ":connman-INPUT - [0:0]");
+ assert_rule_exists("filter", "-A INPUT -j connman-INPUT");
+ assert_rule_exists("filter", "-A connman-INPUT -m mark --mark 0x3e7 -j LOG");
+
+ err = __connman_firewall_disable(ctx);
+ g_assert(err == 0);
+
+ assert_rule_not_exists("filter", ":connman-INPUT - [0:0]");
+ assert_rule_not_exists("filter", "-A INPUT -j connman-INPUT");
+ assert_rule_not_exists("filter", "-A connman-INPUT -m mark --mark 0x3e7 -j LOG");
+
+ __connman_firewall_destroy(ctx);
+}
+
+static void test_firewall_basic1(void)
+{
+ struct firewall_context *ctx;
+ int err;
+
+ ctx = __connman_firewall_create();
+ g_assert(ctx);
+
+ err = __connman_firewall_add_rule(ctx, "filter", "INPUT",
+ "-m mark --mark 999 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_firewall_add_rule(ctx, "filter", "OUTPUT",
+ "-m mark --mark 999 -j LOG");
+ g_assert(err == 0);
+
+ err = __connman_firewall_enable(ctx);
+ g_assert(err == 0);
+
+ err = __connman_firewall_disable(ctx);
+ g_assert(err == 0);
+
+ __connman_firewall_destroy(ctx);
+}
+
+static void test_firewall_basic2(void)
+{
+ struct firewall_context *ctx;
+ int err;
+
+ ctx = __connman_firewall_create();
+ g_assert(ctx);
+
+ err = __connman_firewall_add_rule(ctx, "mangle", "INPUT",
+ "-j CONNMARK --restore-mark");
+ g_assert(err == 0);
+
+ err = __connman_firewall_add_rule(ctx, "mangle", "POSTROUTING",
+ "-j CONNMARK --save-mark");
+ g_assert(err == 0);
+
+ err = __connman_firewall_enable(ctx);
+ g_assert(err == 0);
+
+ err = __connman_firewall_disable(ctx);
+ g_assert(err == 0);
+
+ __connman_firewall_destroy(ctx);
+}
+
+static gchar *option_debug = NULL;
+
+static bool parse_debug(const char *key, const char *value,
+ gpointer user_data, GError **error)
+{
+ if (value)
+ option_debug = g_strdup(value);
+ else
+ option_debug = g_strdup("*");
+
+ return true;
+}
+
+static GOptionEntry options[] = {
+ { "debug", 'd', G_OPTION_FLAG_OPTIONAL_ARG,
+ G_OPTION_ARG_CALLBACK, parse_debug,
+ "Specify debug options to enable", "DEBUG" },
+ { NULL },
+};
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ int err;
+
+ g_test_init(&argc, &argv, NULL);
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ return 1;
+ }
+
+ g_option_context_free(context);
+
+ __connman_log_init(argv[0], option_debug, false, false,
+ "Unit Tests Connection Manager", VERSION);
+
+ __connman_iptables_init();
+ __connman_firewall_init();
+ __connman_nat_init();
+
+ g_test_add_func("/iptables/chain0", test_iptables_chain0);
+ g_test_add_func("/iptables/chain1", test_iptables_chain1);
+ g_test_add_func("/iptables/chain2", test_iptables_chain2);
+ g_test_add_func("/iptables/chain3", test_iptables_chain3);
+ g_test_add_func("/iptables/rule0", test_iptables_rule0);
+ g_test_add_func("/iptables/rule1", test_iptables_rule1);
+ g_test_add_func("/iptables/rule2", test_iptables_rule2);
+ g_test_add_func("/iptables/target0", test_iptables_target0);
+ g_test_add_func("/nat/basic0", test_nat_basic0);
+ g_test_add_func("/nat/basic1", test_nat_basic1);
+ g_test_add_func("/firewall/basic0", test_firewall_basic0);
+ g_test_add_func("/firewall/basic1", test_firewall_basic1);
+ g_test_add_func("/firewall/basic2", test_firewall_basic2);
+
+ err = g_test_run();
+
+ __connman_nat_cleanup();
+ __connman_firewall_cleanup();
+ __connman_iptables_cleanup();
+
+ g_free(option_debug);
+
+ return err;
+}
diff --git a/tools/manager-api.c b/tools/manager-api.c
new file mode 100644
index 0000000..e082962
--- /dev/null
+++ b/tools/manager-api.c
@@ -0,0 +1,264 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+
+#include "session-test.h"
+
+static DBusMessage *set_property(DBusConnection *connection,
+ const char *property, int type, void *value)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+ DBusMessageIter iter;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE,
+ "SetProperty");
+ if (!message)
+ return NULL;
+
+ dbus_message_iter_init_append(message, &iter);
+ connman_dbus_property_append_basic(&iter, property, type, value);
+
+ dbus_error_init(&error);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("Failed to get properties");
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
+
+DBusMessage *manager_get_services(DBusConnection *connection)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE,
+ "GetServices");
+ if (!message)
+ return NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("Failed to get properties");
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
+
+DBusMessage *manager_get_properties(DBusConnection *connection)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE,
+ "GetProperties");
+ if (!message)
+ return NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("%s", error.message);
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
+
+DBusMessage *manager_create_session(DBusConnection *connection,
+ struct test_session_info *info,
+ const char *notifier_path)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+ DBusMessageIter array, dict;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE,
+ "CreateSession");
+ if (!message)
+ return NULL;
+
+ dbus_error_init(&error);
+
+ dbus_message_iter_init_append(message, &array);
+
+ connman_dbus_dict_open(&array, &dict);
+
+ session_append_settings(&dict, info);
+
+ connman_dbus_dict_close(&array, &dict);
+
+ dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
+ ¬ifier_path);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("Failed to get properties");
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
+
+DBusMessage *manager_destroy_session(DBusConnection *connection,
+ const char *notifier_path)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+ DBusMessageIter array;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE,
+ "DestroySession");
+ if (!message)
+ return NULL;
+
+ dbus_error_init(&error);
+
+ dbus_message_iter_init_append(message, &array);
+
+ dbus_message_iter_append_basic(&array, DBUS_TYPE_OBJECT_PATH,
+ ¬ifier_path);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("%s", error.message);
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
+
+DBusMessage *manager_set_session_mode(DBusConnection *connection,
+ bool enable)
+{
+ dbus_bool_t val = enable;
+
+ return set_property(connection, "SessionMode",
+ DBUS_TYPE_BOOLEAN, &val);
+}
+
+int manager_parse_properties(DBusMessage *msg,
+ struct test_manager *manager)
+{
+ DBusMessageIter iter, array;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ switch (dbus_message_iter_get_arg_type(&value)) {
+ case DBUS_TYPE_STRING:
+ if (g_str_equal(key, "State")) {
+ const char *val;
+ dbus_message_iter_get_basic(&value, &val);
+
+ if (manager->state)
+ g_free(manager->state);
+
+ LOG("State %s", val);
+
+ manager->state = g_strdup(val);
+ }
+ break;
+ default:
+ break;
+ }
+ dbus_message_iter_next(&array);
+ }
+
+ return 0;
+}
diff --git a/tools/netlink-test.c b/tools/netlink-test.c
new file mode 100644
index 0000000..221e349
--- /dev/null
+++ b/tools/netlink-test.c
@@ -0,0 +1,123 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2013-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <sys/socket.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <linux/genetlink.h>
+#include <linux/netfilter/nfnetlink.h>
+#include <net/if.h>
+
+#include <string.h>
+#include <stdio.h>
+#include <inttypes.h>
+#include <errno.h>
+
+#include <glib.h>
+
+#include "../src/shared/netlink.h"
+
+#define NFGEN_DATA(nlh) ((void *)((char *)(nlh) + \
+ NLMSG_ALIGN(sizeof(struct nfgenmsg))))
+#define NLA_DATA(nla) ((void *)((char*)(nla) + NLA_HDRLEN))
+#define NLA_OK(nla,len) ((len) >= (int)sizeof(struct nlattr) && \
+ (nla)->nla_len >= sizeof(struct nlattr) && \
+ (nla)->nla_len <= (len))
+#define NLA_NEXT(nla,attrlen) ((attrlen) -= NLA_ALIGN((nla)->nla_len), \
+ (struct nlattr*)(((char*)(nla)) + \
+ NLA_ALIGN((nla)->nla_len)))
+
+static GMainLoop *mainloop;
+
+static void do_debug(const char *str, void *user_data)
+{
+ const char *prefix = user_data;
+
+ printf("%s%s\n", prefix, str);
+}
+
+static void getlink_callback(unsigned int error, uint16_t type, const void *data,
+ uint32_t len, void *user_data)
+{
+ const struct ifinfomsg *ifi = data;
+ struct rtattr *rta;
+ int bytes;
+ char ifname[IF_NAMESIZE];
+ uint32_t index, flags;
+
+ g_assert_cmpuint(error, ==, 0);
+
+ bytes = len - NLMSG_ALIGN(sizeof(struct ifinfomsg));
+
+ memset(ifname, 0, sizeof(ifname));
+
+ index = ifi->ifi_index;
+ flags = ifi->ifi_flags;
+
+ for (rta = IFLA_RTA(ifi); RTA_OK(rta, bytes);
+ rta = RTA_NEXT(rta, bytes)) {
+ switch (rta->rta_type) {
+ case IFLA_IFNAME:
+ if (RTA_PAYLOAD(rta) <= IF_NAMESIZE)
+ strcpy(ifname, RTA_DATA(rta));
+ break;
+ }
+ }
+
+ printf("index=%d flags=0x%08x name=%s\n", index, flags, ifname);
+
+ g_main_loop_quit(mainloop);
+}
+
+static void test_case_1(void)
+{
+ struct netlink_info *netlink;
+ struct ifinfomsg msg;
+
+ netlink = netlink_new(NETLINK_ROUTE);
+
+ printf("\n");
+ netlink_set_debug(netlink, do_debug, "[NETLINK] ", NULL);
+
+ memset(&msg, 0, sizeof(msg));
+
+ netlink_send(netlink, RTM_GETLINK, NLM_F_DUMP, &msg, sizeof(msg),
+ getlink_callback, NULL, NULL);
+
+ mainloop = g_main_loop_new(NULL, FALSE);
+ g_main_loop_run(mainloop);
+ g_main_loop_unref(mainloop);
+
+ netlink_destroy(netlink);
+}
+
+int main(int argc, char *argv[])
+{
+ g_test_init(&argc, &argv, NULL);
+
+ g_test_add_func("/netlink/Test case 1", test_case_1);
+
+ return g_test_run();
+}
diff --git a/tools/polkit-test.c b/tools/polkit-test.c
new file mode 100644
index 0000000..ea1d24a
--- /dev/null
+++ b/tools/polkit-test.c
@@ -0,0 +1,184 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <errno.h>
+
+#include <string.h>
+#include <signal.h>
+
+#include <dbus/dbus.h>
+
+static volatile sig_atomic_t __io_terminate = 0;
+
+static void sig_term(int sig)
+{
+ __io_terminate = 1;
+}
+
+static void add_dict_with_string_value(DBusMessageIter *iter,
+ const char *key, const char *str)
+{
+ DBusMessageIter dict, entry, value;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+ dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT,
+ DBUS_TYPE_STRING_AS_STRING, &value);
+ dbus_message_iter_append_basic(&value, DBUS_TYPE_STRING, &str);
+ dbus_message_iter_close_container(&entry, &value);
+
+ dbus_message_iter_close_container(&dict, &entry);
+ dbus_message_iter_close_container(iter, &dict);
+}
+
+static void add_empty_string_dict(DBusMessageIter *iter)
+{
+ DBusMessageIter dict;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_STRING_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict);
+
+ dbus_message_iter_close_container(iter, &dict);
+}
+
+static void add_arguments(DBusConnection *conn, DBusMessageIter *iter)
+{
+ const char *busname = dbus_bus_get_unique_name(conn);
+ const char *kind = "system-bus-name";
+ const char *action = "org.freedesktop.policykit.exec";
+ const char *cancel = "";
+ dbus_uint32_t flags = 0x00000001;
+ DBusMessageIter subject;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
+ NULL, &subject);
+ dbus_message_iter_append_basic(&subject, DBUS_TYPE_STRING, &kind);
+ add_dict_with_string_value(&subject, "name", busname);
+ dbus_message_iter_close_container(iter, &subject);
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &action);
+ add_empty_string_dict(iter);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_UINT32, &flags);
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &cancel);
+}
+
+static void print_arguments(DBusMessageIter *iter)
+{
+ DBusMessageIter result;
+ dbus_bool_t authorized, challenge;
+
+ dbus_message_iter_recurse(iter, &result);
+
+ dbus_message_iter_get_basic(&result, &authorized);
+ dbus_message_iter_get_basic(&result, &challenge);
+
+ printf("Authorized %d (Challenge %d)\n", authorized, challenge);
+}
+
+#define AUTHORITY_DBUS "org.freedesktop.PolicyKit1"
+#define AUTHORITY_INTF "org.freedesktop.PolicyKit1.Authority"
+#define AUTHORITY_PATH "/org/freedesktop/PolicyKit1/Authority"
+
+static int check_authorization(DBusConnection *conn)
+{
+ DBusMessage *msg, *reply;
+ DBusMessageIter iter;
+ DBusError err;
+
+ msg = dbus_message_new_method_call(AUTHORITY_DBUS, AUTHORITY_PATH,
+ AUTHORITY_INTF, "CheckAuthorization");
+ if (!msg) {
+ fprintf(stderr, "Can't allocate new method call\n");
+ return -ENOMEM;
+ }
+
+ dbus_message_iter_init_append(msg, &iter);
+ add_arguments(conn, &iter);
+
+ dbus_error_init(&err);
+
+ reply = dbus_connection_send_with_reply_and_block(conn, msg, -1, &err);
+
+ dbus_message_unref(msg);
+
+ if (!reply) {
+ if (dbus_error_is_set(&err)) {
+ fprintf(stderr, "%s\n", err.message);
+ dbus_error_free(&err);
+ } else
+ fprintf(stderr, "Can't check authorization\n");
+ return -EIO;
+ }
+
+ if (dbus_message_has_signature(reply, "(bba{ss})")) {
+ dbus_message_iter_init(reply, &iter);
+ print_arguments(&iter);
+ }
+
+ dbus_message_unref(reply);
+
+ return 0;
+}
+
+int main(int argc, char *argv[])
+{
+ DBusConnection *conn;
+ struct sigaction sa;
+
+ conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (!conn) {
+ fprintf(stderr, "Can't get on system bus");
+ return 1;
+ }
+
+ check_authorization(conn);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_flags = SA_NOCLDSTOP;
+ sa.sa_handler = sig_term;
+ sigaction(SIGTERM, &sa, NULL);
+ sigaction(SIGINT, &sa, NULL);
+
+#if 0
+ while (!__io_terminate) {
+ if (dbus_connection_read_write_dispatch(conn, 500) == FALSE)
+ break;
+ }
+#endif
+
+ dbus_connection_unref(conn);
+
+ return 0;
+}
diff --git a/tools/private-network-test.c b/tools/private-network-test.c
new file mode 100644
index 0000000..3dd115b
--- /dev/null
+++ b/tools/private-network-test.c
@@ -0,0 +1,268 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2011 ProFUSION embedded systems
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#define CONNMAN_SERVICE "net.connman"
+
+#define MANAGER_PATH "/"
+#define MANAGER_INTERFACE CONNMAN_SERVICE ".Manager"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <gdbus.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/poll.h>
+#include <sys/signalfd.h>
+#include <unistd.h>
+
+#include <dbus/dbus.h>
+
+#ifndef DBUS_TYPE_UNIX_FD
+#define DBUS_TYPE_UNIX_FD -1
+#endif
+
+static int release_private_network(DBusConnection *conn)
+{
+ DBusMessage *msg, *reply;
+ DBusError error;
+
+ msg = dbus_message_new_method_call(CONNMAN_SERVICE, MANAGER_PATH,
+ MANAGER_INTERFACE, "ReleasePrivateNetwork");
+
+ dbus_error_init(&error);
+
+ printf("Releasing private-network...\n");
+ reply = dbus_connection_send_with_reply_and_block(conn, msg, -1,
+ &error);
+ dbus_message_unref(msg);
+
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ fprintf(stderr, "1. %s\n", error.message);
+ dbus_error_free(&error);
+ } else {
+ fprintf(stderr, "Release() failed");
+ }
+
+ return -1;
+ }
+
+ return 0;
+}
+
+static void request_private_network(DBusConnection *conn, int *out_fd,
+ char **out_server_ip,
+ char **out_peer_ip,
+ char **out_primary_dns,
+ char **out_secondary_dns)
+{
+ DBusMessageIter array, dict, entry;
+ DBusMessage *msg, *reply;
+ DBusError error;
+
+ msg = dbus_message_new_method_call(CONNMAN_SERVICE, MANAGER_PATH,
+ MANAGER_INTERFACE, "RequestPrivateNetwork");
+
+ dbus_error_init(&error);
+
+ printf("Requesting private-network...\n");
+ reply = dbus_connection_send_with_reply_and_block(conn, msg, -1,
+ &error);
+ dbus_message_unref(msg);
+
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ fprintf(stderr, "1. %s\n", error.message);
+ dbus_error_free(&error);
+ } else {
+ fprintf(stderr, "Request() failed");
+ }
+ return;
+ }
+
+ if (!dbus_message_iter_init(reply, &array))
+ goto done;
+
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_UNIX_FD)
+ goto done;
+
+ dbus_message_iter_get_basic(&array, out_fd);
+ printf("Fildescriptor = %d\n", *out_fd);
+
+ dbus_message_iter_next(&array);
+
+ if (dbus_message_iter_get_arg_type(&array) != DBUS_TYPE_ARRAY)
+ goto done;
+
+ dbus_message_iter_recurse(&array, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter iter;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ printf("key %s", key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &iter);
+
+ type = dbus_message_iter_get_arg_type(&iter);
+ if (type != DBUS_TYPE_STRING)
+ break;
+
+ if (g_str_equal(key, "ServerIPv4")
+ && type == DBUS_TYPE_STRING) {
+ dbus_message_iter_get_basic(&iter, out_server_ip);
+ printf(" = %s\n", *out_server_ip);
+
+ } else if (g_str_equal(key, "PeerIPv4")
+ && type == DBUS_TYPE_STRING) {
+ dbus_message_iter_get_basic(&iter, out_peer_ip);
+ printf(" = %s\n", *out_peer_ip);
+
+ } else if (g_str_equal(key, "PrimaryDNS")
+ && type == DBUS_TYPE_STRING) {
+ dbus_message_iter_get_basic(&iter, out_primary_dns);
+ printf(" = %s\n", *out_primary_dns);
+
+ } else if (g_str_equal(key, "SecondaryDNS")
+ && type == DBUS_TYPE_STRING) {
+ dbus_message_iter_get_basic(&iter, out_secondary_dns);
+ printf(" = %s\n", *out_secondary_dns);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ dbus_message_unref(reply);
+}
+
+int main(int argc, char *argv[])
+{
+ DBusConnection *conn;
+ int fd = -1;
+ char *server_ip;
+ char *peer_ip;
+ char *primary_dns;
+ char *secondary_dns;
+
+ /*
+ * IP packet: src: 192.168.219.2 dst www.connman.net
+ * HTTP GET / request
+ */
+ int buf1[81] = { 0x45, 0x00, 0x00, 0x51, 0x5a, 0xbe, 0x00, 0x00, 0x40,
+ 0x06, 0x50, 0x73, 0xc0, 0xa8, 0xdb, 0x01, 0x3e, 0x4b,
+ 0xf5, 0x80, 0x30, 0x3b, 0x00, 0x50, 0x00, 0x00, 0x00,
+ 0x28, 0x04, 0xfd, 0xac, 0x9b, 0x50, 0x18, 0x02, 0x00,
+ 0xa1, 0xb3, 0x00, 0x00, 0x47, 0x45, 0x54, 0x20, 0x2f,
+ 0x20, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31,
+ 0x0d, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x3a, 0x20, 0x77,
+ 0x77, 0x77, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x6d, 0x61,
+ 0x6e, 0x2e, 0x6e, 0x65, 0x74, 0x0d, 0x0a, 0x0d, 0x0a};
+
+
+ int buf2[81] = { 0x45, 0x00, 0x00, 0x51, 0x57, 0x9d, 0x00, 0x00, 0x40,
+ 0x06, 0x53, 0x93, 0xc0, 0xa8, 0xdb, 0x02, 0x3e, 0x4b,
+ 0xf5, 0x80, 0x30, 0x3b, 0x00, 0x50, 0x00, 0x00, 0x00,
+ 0x28, 0x17, 0xdb, 0x2e, 0x6d, 0x50, 0x18, 0x02, 0x00,
+ 0x0d, 0x03, 0x00, 0x00, 0x47, 0x45, 0x54, 0x20, 0x2f,
+ 0x20, 0x48, 0x54, 0x54, 0x50, 0x2f, 0x31, 0x2e, 0x31,
+ 0x0d, 0x0a, 0x48, 0x6f, 0x73, 0x74, 0x3a, 0x20, 0x77,
+ 0x77, 0x77, 0x2e, 0x63, 0x6f, 0x6e, 0x6e, 0x6d, 0x61,
+ 0x6e, 0x2e, 0x6e, 0x65, 0x74, 0x0d, 0x0a, 0x0d, 0x0a};
+
+ if (DBUS_TYPE_UNIX_FD < 0) {
+ fprintf(stderr, "File-descriptor passing not supported\n");
+ exit(1);
+ }
+
+ conn = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (!conn) {
+ fprintf(stderr, "Can't get on system bus\n");
+ exit(1);
+ }
+
+ request_private_network(conn, &fd, &server_ip, &peer_ip,
+ &primary_dns, &secondary_dns);
+ if (fd < 0)
+ return -1;
+
+ fcntl(fd, F_SETFL, O_NONBLOCK);
+
+ printf("Press ENTER to write data to the network.\n");
+ getchar();
+
+
+ if (!fork()) {
+ if (write(fd, buf1, sizeof(buf1)) < 0) {
+ fprintf(stderr, "err on write() buf1\n");
+ return -1;
+ }
+
+ if (write(fd, buf2, sizeof(buf2)) < 0) {
+ fprintf(stderr, "err on write() buf2\n");
+ return -1;
+ }
+
+ printf("Press ENTER to release private network.\n");
+ getchar();
+
+ if (release_private_network(conn) < 0)
+ return -1;
+
+ close(fd);
+
+ dbus_connection_unref(conn);
+
+ } else {
+ struct pollfd p;
+ char buf[1500];
+ int len;
+
+ p.fd = fd;
+ p.events = POLLIN | POLLERR | POLLHUP;
+
+ while (1) {
+ p.revents = 0;
+ if (poll(&p, 1, -1) <= 0)
+ return -1;
+
+ if (p.revents & (POLLERR | POLLHUP))
+ return -1;
+
+ len = read(fd, buf, sizeof(buf));
+ if (len < 0)
+ return -1;
+
+ printf("%d bytes received\n", len);
+ }
+ }
+
+ return 0;
+}
diff --git a/tools/resolv-test.c b/tools/resolv-test.c
new file mode 100644
index 0000000..8953acd
--- /dev/null
+++ b/tools/resolv-test.c
@@ -0,0 +1,166 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+
+#include <gweb/gresolv.h>
+
+static GTimer *timer;
+
+static GMainLoop *main_loop;
+
+static void resolv_debug(const char *str, void *data)
+{
+ g_print("%s: %s\n", (const char *) data, str);
+}
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static const char *status2str(GResolvResultStatus status)
+{
+ switch (status) {
+ case G_RESOLV_RESULT_STATUS_SUCCESS:
+ return "success";
+ case G_RESOLV_RESULT_STATUS_ERROR:
+ return "error";
+ case G_RESOLV_RESULT_STATUS_NO_RESPONSE:
+ return "no response";
+ case G_RESOLV_RESULT_STATUS_FORMAT_ERROR:
+ return "format error";
+ case G_RESOLV_RESULT_STATUS_SERVER_FAILURE:
+ return "server failure";
+ case G_RESOLV_RESULT_STATUS_NAME_ERROR:
+ return "name error";
+ case G_RESOLV_RESULT_STATUS_NOT_IMPLEMENTED:
+ return "not implemented";
+ case G_RESOLV_RESULT_STATUS_REFUSED:
+ return "refused";
+ }
+
+ return NULL;
+}
+
+static void resolv_result(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+ gdouble elapsed;
+ int i;
+
+ elapsed = g_timer_elapsed(timer, NULL);
+
+ g_print("elapse: %f seconds\n", elapsed);
+
+ g_print("status: %s\n", status2str(status));
+
+ if (results) {
+ for (i = 0; results[i]; i++)
+ g_print("result: %s\n", results[i]);
+ }
+
+ g_main_loop_quit(main_loop);
+}
+
+static bool option_debug = false;
+
+static GOptionEntry options[] = {
+ { "debug", 'd', 0, G_OPTION_ARG_NONE, &option_debug,
+ "Enable debug output" },
+ { NULL },
+};
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ struct sigaction sa;
+ GResolv *resolv;
+ int index = 0;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ exit(1);
+ }
+
+ g_option_context_free(context);
+
+ if (argc < 2) {
+ printf("missing argument\n");
+ return 1;
+ }
+
+ resolv = g_resolv_new(index);
+ if (!resolv) {
+ printf("failed to create resolver\n");
+ return 1;
+ }
+
+ if (option_debug)
+ g_resolv_set_debug(resolv, resolv_debug, "RESOLV");
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ if (argc > 2) {
+ int i;
+
+ for (i = 2; i < argc; i++)
+ g_resolv_add_nameserver(resolv, argv[i], 53, 0);
+ }
+
+ timer = g_timer_new();
+
+ if (g_resolv_lookup_hostname(resolv, argv[1],
+ resolv_result, NULL) == 0) {
+ printf("failed to start lookup\n");
+ return 1;
+ }
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_timer_destroy(timer);
+
+ g_resolv_unref(resolv);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
diff --git a/tools/session-api.c b/tools/session-api.c
new file mode 100644
index 0000000..b97cfc0
--- /dev/null
+++ b/tools/session-api.c
@@ -0,0 +1,326 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <gdbus.h>
+
+#include "session-test.h"
+
+static enum connman_session_state string2state(const char *state)
+{
+ if (g_strcmp0(state, "connected") == 0)
+ return CONNMAN_SESSION_STATE_CONNECTED;
+ if (g_strcmp0(state, "online") == 0)
+ return CONNMAN_SESSION_STATE_ONLINE;
+
+ return CONNMAN_SESSION_STATE_DISCONNECTED;
+}
+
+static enum connman_session_type string2type(const char *type)
+{
+ if (g_strcmp0(type, "any") == 0)
+ return CONNMAN_SESSION_TYPE_ANY;
+ if (g_strcmp0(type, "local") == 0)
+ return CONNMAN_SESSION_TYPE_LOCAL;
+ if (g_strcmp0(type, "internet") == 0)
+ return CONNMAN_SESSION_TYPE_INTERNET;
+
+ return CONNMAN_SESSION_TYPE_UNKNOWN;
+}
+
+void bearer_info_cleanup(gpointer data, gpointer user_data)
+{
+ struct test_bearer_info *info = data;
+
+ g_free(info->name);
+ g_free(info);
+}
+
+static GSList *session_parse_allowed_bearers(DBusMessageIter *iter)
+{
+ struct test_bearer_info *info;
+ DBusMessageIter array;
+ GSList *list = NULL;
+
+ dbus_message_iter_recurse(iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_STRING) {
+ char *bearer = NULL;
+
+ dbus_message_iter_get_basic(&array, &bearer);
+
+ info = g_try_new0(struct test_bearer_info, 1);
+ if (!info) {
+ g_slist_foreach(list, bearer_info_cleanup, NULL);
+ g_slist_free(list);
+
+ return NULL;
+ }
+
+ info->name = g_strdup(bearer);
+
+ list = g_slist_append(list, info);
+
+ dbus_message_iter_next(&array);
+ }
+
+ return list;
+}
+
+static DBusMessage *notify_release(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct test_session *session = user_data;
+
+ LOG("session %p", session);
+
+ if (session->notify)
+ session->notify(session);
+
+ return NULL;
+}
+
+static DBusMessage *notify_update(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ struct test_session *session = user_data;
+ struct test_session_info *info = session->info;
+ DBusMessageIter iter, array;
+ GSList *allowed_bearers;
+
+ LOG("session %p notify %s", session, session->notify_path);
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ switch (dbus_message_iter_get_arg_type(&value)) {
+ case DBUS_TYPE_ARRAY:
+ if (g_str_equal(key, "AllowedBearers")) {
+ allowed_bearers = session_parse_allowed_bearers(&value);
+
+ g_slist_foreach(info->allowed_bearers,
+ bearer_info_cleanup, NULL);
+ g_slist_free(info->allowed_bearers);
+
+ info->allowed_bearers = allowed_bearers;
+
+ } else if (g_str_equal(key, "IPv4")) {
+ /* XXX */
+
+ } else if (g_str_equal(key, "IPv6")) {
+ /* XXX */
+
+ } else {
+ g_assert(FALSE);
+ return __connman_error_invalid_arguments(msg);
+ }
+ break;
+ case DBUS_TYPE_STRING:
+ if (g_str_equal(key, "State")) {
+ const char *val;
+ dbus_message_iter_get_basic(&value, &val);
+
+ info->state = string2state(val);
+ } else if (g_str_equal(key, "Bearer")) {
+ const char *val;
+ dbus_message_iter_get_basic(&value, &val);
+
+ if (info->bearer)
+ g_free(info->bearer);
+
+ info->bearer = g_strdup(val);
+
+ } else if (g_str_equal(key, "Name")) {
+ const char *val;
+ dbus_message_iter_get_basic(&value, &val);
+
+ if (info->name)
+ g_free(info->name);
+
+ info->name = g_strdup(val);
+
+ } else if (g_str_equal(key, "Interface")) {
+ const char *val;
+ dbus_message_iter_get_basic(&value, &val);
+
+ if (info->interface)
+ g_free(info->interface);
+
+ info->interface = g_strdup(val);
+
+ } else if (g_str_equal(key, "ConnectionType")
+ ) {
+ const char *val;
+ dbus_message_iter_get_basic(&value, &val);
+
+ info->type = string2type(val);
+ } else {
+ g_assert(FALSE);
+ return __connman_error_invalid_arguments(msg);
+ }
+ break;
+ default:
+ g_assert(FALSE);
+ return __connman_error_invalid_arguments(msg);
+ }
+ dbus_message_iter_next(&array);
+ }
+
+ if (session->notify)
+ session->notify(session);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable notify_methods[] = {
+ { GDBUS_METHOD("Release", NULL, NULL, notify_release) },
+ { GDBUS_METHOD("Update",
+ GDBUS_ARGS({ "settings", "a{sv}" }), NULL,
+ notify_update) },
+ { },
+};
+
+int session_notify_register(struct test_session *session,
+ const char *notify_path)
+{
+ if (!g_dbus_register_interface(session->connection, notify_path, CONNMAN_NOTIFICATION_INTERFACE, notify_methods, NULL, NULL, session, NULL)) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+int session_notify_unregister(struct test_session *session,
+ const char *notify_path)
+{
+ if (!g_dbus_unregister_interface(session->connection, notify_path, CONNMAN_NOTIFICATION_INTERFACE)) {
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+static void append_allowed_bearers(DBusMessageIter *iter, void *user_data)
+{
+ struct test_session_info *info = user_data;
+ GSList *list;
+
+ for (list = info->allowed_bearers;
+ list; list = list->next) {
+ struct test_bearer_info *bearer_info = list->data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING,
+ &bearer_info->name);
+ }
+}
+
+void session_append_settings(DBusMessageIter *dict,
+ struct test_session_info *info)
+{
+ if (!info->allowed_bearers)
+ return;
+
+ connman_dbus_dict_append_array(dict, "AllowedBearers",
+ DBUS_TYPE_STRING,
+ append_allowed_bearers,
+ info);
+}
+
+DBusMessage *session_connect(DBusConnection *connection,
+ struct test_session *session)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ session->session_path,
+ CONNMAN_SESSION_INTERFACE,
+ "Connect");
+ if (!message)
+ return NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("Failed to get properties");
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
+
+DBusMessage *session_disconnect(DBusConnection *connection,
+ struct test_session *session)
+{
+ DBusMessage *message, *reply;
+ DBusError error;
+
+ message = dbus_message_new_method_call(CONNMAN_SERVICE,
+ session->session_path,
+ CONNMAN_SESSION_INTERFACE,
+ "Disconnect");
+ if (!message)
+ return NULL;
+
+ dbus_error_init(&error);
+
+ reply = dbus_connection_send_with_reply_and_block(connection,
+ message, -1, &error);
+ if (!reply) {
+ if (dbus_error_is_set(&error)) {
+ LOG("%s", error.message);
+ dbus_error_free(&error);
+ } else {
+ LOG("Failed to get properties");
+ }
+ dbus_message_unref(message);
+ return NULL;
+ }
+
+ dbus_message_unref(message);
+
+ return reply;
+}
diff --git a/tools/session-test.c b/tools/session-test.c
new file mode 100644
index 0000000..4319e5a
--- /dev/null
+++ b/tools/session-test.c
@@ -0,0 +1,699 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <sys/types.h>
+
+#include <gdbus.h>
+
+#include "session-test.h"
+
+#define POLICYDIR STORAGEDIR "/session_policy_local"
+
+enum test_session_state {
+ TEST_SESSION_STATE_0 = 0,
+ TEST_SESSION_STATE_1 = 1,
+ TEST_SESSION_STATE_2 = 2,
+ TEST_SESSION_STATE_3 = 3,
+};
+
+static enum test_session_state get_session_state(struct test_session *session)
+{
+ return GPOINTER_TO_UINT(session->fix->user_data);
+}
+
+static void set_session_state(struct test_session *session,
+ enum test_session_state state)
+{
+ session->fix->user_data = GUINT_TO_POINTER(state);
+}
+
+static struct test_session *get_session(struct test_session *session,
+ unsigned int index)
+{
+ return &session->fix->session[index];
+}
+
+static void test_session_create_no_notify(struct test_fix *fix)
+{
+ DBusMessage *msg;
+
+ util_session_create(fix, 1);
+
+ msg = manager_create_session(fix->session->connection,
+ fix->session->info, "/foo");
+ g_assert(msg);
+ g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
+
+ dbus_message_unref(msg);
+
+ util_idle_call(fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_destroy_no_notify(struct test_fix *fix)
+{
+ DBusMessage *msg;
+
+ util_session_create(fix, 1);
+
+ msg = manager_destroy_session(fix->session->connection, "/foo");
+ g_assert(!msg);
+
+ util_idle_call(fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_create_notify(struct test_session *session)
+{
+ LOG("session %p", session);
+
+ util_idle_call(session->fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_create(struct test_fix *fix)
+{
+ struct test_session *session;
+ DBusMessage *msg;
+ int err;
+
+ util_session_create(fix, 1);
+ session = fix->session;
+
+ session->notify_path = "/foo";
+ session->notify = test_session_create_notify;
+
+ err = session_notify_register(session, session->notify_path);
+ g_assert(err == 0);
+
+ msg = manager_create_session(session->connection,
+ session->info,
+ session->notify_path);
+ g_assert(msg);
+ g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
+
+ dbus_message_unref(msg);
+}
+
+static void test_session_create_destroy(struct test_fix *fix)
+{
+ struct test_session *session;
+
+ util_session_create(fix, 1);
+ session = fix->session;
+
+ session->notify_path = g_strdup("/foo");
+
+ util_session_init(fix->session);
+ util_session_cleanup(fix->session);
+
+ util_idle_call(fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_create_dup_notification(struct test_fix *fix)
+{
+ struct test_session *session0, *session1;
+ DBusMessage *msg;
+
+ util_session_create(fix, 2);
+ session0 = &fix->session[0];
+ session1 = &fix->session[1];
+
+ session0->notify_path = g_strdup("/foo");
+ session1->notify_path = session0->notify_path;
+
+ util_session_init(session0);
+
+ msg = manager_create_session(session1->connection,
+ session1->info,
+ session1->notify_path);
+ g_assert(msg);
+
+ util_session_cleanup(session0);
+
+ util_idle_call(fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_create_many_notify(struct test_session *session)
+{
+ unsigned int nr;
+
+ LOG("session %p", session);
+
+ nr = GPOINTER_TO_UINT(session->fix->user_data);
+ nr--;
+ session->fix->user_data = GUINT_TO_POINTER(nr);
+
+ if (nr > 0)
+ return;
+
+ util_idle_call(session->fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_create_many(struct test_fix *fix)
+{
+ struct test_session *session;
+ unsigned int i, max;
+
+ max = 100;
+
+ fix->user_data = GUINT_TO_POINTER(max);
+
+ util_session_create(fix, max);
+
+ for (i = 0; i < max; i++) {
+ session = &fix->session[i];
+
+ session->notify_path = g_strdup_printf("/foo/%d", i);
+ session->notify = test_session_create_many_notify;
+
+ util_session_init(session);
+ }
+}
+
+static void set_session_mode(struct test_fix *fix,
+ bool enable)
+{
+ DBusMessage *msg;
+
+ msg = manager_set_session_mode(fix->main_connection, enable);
+ g_assert(msg);
+ g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
+
+ dbus_message_unref(msg);
+}
+
+static void test_session_connect_notify(struct test_session *session)
+{
+ LOG("session %p state %d", session, session->info->state);
+
+ if (session->info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
+ return;
+
+ util_session_cleanup(session);
+
+ util_idle_call(session->fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_connect(struct test_fix *fix)
+{
+ struct test_session *session;
+ DBusMessage *msg;
+
+ util_session_create(fix, 1);
+ session = fix->session;
+
+ session->notify_path = g_strdup("/foo");
+ session->notify = test_session_connect_notify;
+ util_session_init(session);
+
+ msg = session_connect(session->connection, session);
+ g_assert(msg);
+ g_assert(dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_ERROR);
+
+ dbus_message_unref(msg);
+}
+
+static void test_session_disconnect_notify(struct test_session *session)
+{
+ LOG("session %p state %d", session, session->info->state);
+
+ if (session->info->state >= CONNMAN_SESSION_STATE_CONNECTED)
+ return;
+
+ util_session_cleanup(session);
+
+ util_idle_call(session->fix, util_quit_loop, util_session_destroy);
+}
+
+static void test_session_disconnect(struct test_fix *fix)
+{
+ struct test_session *session;
+ DBusMessage *msg;
+
+ util_session_create(fix, 1);
+ session = fix->session;
+
+ session->notify_path = g_strdup("/foo");
+ session->notify = test_session_disconnect_notify;
+ util_session_init(session);
+
+ msg = session_disconnect(session->connection, session);
+ g_assert(msg);
+ dbus_message_unref(msg);
+}
+
+static void test_session_connect_disconnect_notify(struct test_session *session)
+{
+ enum test_session_state state = get_session_state(session);
+ enum test_session_state next_state = state;
+ DBusMessage *msg;
+
+ LOG("state %d session %p %s state %d", state, session,
+ session->notify_path, session->info->state);
+
+ switch (state) {
+ case TEST_SESSION_STATE_0:
+ if (session->info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
+ next_state = TEST_SESSION_STATE_1;
+ if (session->info->state == CONNMAN_SESSION_STATE_CONNECTED) {
+ LOG("state was already connected, continuing");
+ next_state = TEST_SESSION_STATE_2;
+ }
+ break;
+ case TEST_SESSION_STATE_1:
+ if (session->info->state >= CONNMAN_SESSION_STATE_CONNECTED)
+ next_state = TEST_SESSION_STATE_2;
+ break;
+ case TEST_SESSION_STATE_2:
+ if (session->info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
+ next_state = TEST_SESSION_STATE_3;
+ default:
+ break;
+ }
+
+ if (state == next_state)
+ return;
+
+ set_session_state(session, next_state);
+
+ LOG("next_state %d", next_state);
+
+ switch (next_state) {
+ case TEST_SESSION_STATE_1:
+ msg = session_connect(session->connection, session);
+ g_assert(msg);
+ dbus_message_unref(msg);
+ return;
+ case TEST_SESSION_STATE_2:
+ msg = session_disconnect(session->connection, session);
+ g_assert(msg);
+ dbus_message_unref(msg);
+ return;
+ case TEST_SESSION_STATE_3:
+ util_session_cleanup(session);
+ util_idle_call(session->fix, util_quit_loop,
+ util_session_destroy);
+ return;
+ default:
+ return;
+ }
+}
+
+static void test_session_connect_disconnect(struct test_fix *fix)
+{
+ struct test_session *session;
+
+ /*
+ * +-------------------+
+ * | START |
+ * +-------------------+
+ * |
+ * | connect foo
+ * v
+ * +-------------------+
+ * | FOO-CONNECTED |
+ * +-------------------+
+ * |
+ * | disconnect foo
+ * v
+ * +-------------------+
+ * | END |
+ * +-------------------+
+ */
+
+ util_session_create(fix, 1);
+ session = fix->session;
+
+ session->notify_path = g_strdup("/foo");
+ session->notify = test_session_connect_disconnect_notify;
+
+ util_session_init(session);
+
+ set_session_state(session, TEST_SESSION_STATE_0);
+}
+
+static void test_session_connect_free_ride_notify(struct test_session *session)
+{
+ struct test_session *session0 = get_session(session, 0);
+ struct test_session *session1 = get_session(session, 1);
+ enum test_session_state state = get_session_state(session);
+ enum test_session_state next_state = state;
+ DBusMessage *msg;
+
+ LOG("state %d session %p %s state %d", state, session,
+ session->notify_path, session->info->state);
+
+ switch (state) {
+ case TEST_SESSION_STATE_0:
+ if (session0->info->state == CONNMAN_SESSION_STATE_DISCONNECTED
+ && session1->info->state ==
+ CONNMAN_SESSION_STATE_DISCONNECTED) {
+ next_state = TEST_SESSION_STATE_1;
+ }
+ if (session0->info->state == CONNMAN_SESSION_STATE_CONNECTED &&
+ session1->info->state ==
+ CONNMAN_SESSION_STATE_CONNECTED) {
+ LOG("state was already connected, continuing");
+ next_state = TEST_SESSION_STATE_2;
+ }
+
+ break;
+ case TEST_SESSION_STATE_1:
+ if (session0->info->state >= CONNMAN_SESSION_STATE_CONNECTED &&
+ session1->info->state >=
+ CONNMAN_SESSION_STATE_CONNECTED) {
+ next_state = TEST_SESSION_STATE_2;
+ }
+
+ break;
+ case TEST_SESSION_STATE_2:
+ if (session0->info->state == CONNMAN_SESSION_STATE_DISCONNECTED
+ && (session1->info->state ==
+ CONNMAN_SESSION_STATE_DISCONNECTED ||
+ session1->info->state ==
+ CONNMAN_SESSION_STATE_CONNECTED) ) {
+ LOG("session0 /foo is disconnected, session1 /bar "
+ "can be either connected or disconnected");
+ next_state = TEST_SESSION_STATE_3;
+ }
+
+ break;
+ case TEST_SESSION_STATE_3:
+
+ return;
+ }
+
+ if (state == next_state)
+ return;
+
+ set_session_state(session, next_state);
+
+ LOG("next_state %d", next_state);
+
+ switch (next_state) {
+ case TEST_SESSION_STATE_0:
+
+ return;
+ case TEST_SESSION_STATE_1:
+ msg = session_connect(session0->connection, session0);
+ g_assert(msg);
+ dbus_message_unref(msg);
+
+ return;
+
+ case TEST_SESSION_STATE_2:
+ msg = session_disconnect(session0->connection, session0);
+ g_assert(msg);
+ dbus_message_unref(msg);
+
+ return;
+ case TEST_SESSION_STATE_3:
+ util_session_cleanup(session0);
+ util_session_cleanup(session1);
+
+ util_idle_call(session0->fix, util_quit_loop,
+ util_session_destroy);
+
+ return;
+ }
+}
+
+static void test_session_connect_free_ride(struct test_fix *fix)
+{
+ struct test_session *session0, *session1;
+
+ /*
+ * +-------------------+
+ * | START |
+ * +-------------------+
+ * |
+ * | connect foo
+ * v
+ * +-------------------+
+ * | FOO-CONNECTED |
+ * +-------------------+
+ * |
+ * | free-ride bar
+ * v
+ * +-------------------+
+ * | FOO-BAR-CONNECTED |
+ * +-------------------+
+ * |
+ * | disconnect foo
+ * v
+ * +-------------------+
+ * | END |
+ * +-------------------+
+ */
+
+ util_session_create(fix, 2);
+ session0 = &fix->session[0];
+ session1 = &fix->session[1];
+
+ session0->notify_path = g_strdup("/foo");
+ session1->notify_path = g_strdup("/bar");
+ session0->notify = test_session_connect_free_ride_notify;
+ session1->notify = test_session_connect_free_ride_notify;
+
+ util_session_init(session0);
+ util_session_init(session1);
+
+ set_session_state(session0, TEST_SESSION_STATE_0);
+}
+
+static void policy_save(GKeyFile *keyfile, char *pathname)
+{
+ gchar *data = NULL;
+ gsize length = 0;
+ GError *error = NULL;
+
+ data = g_key_file_to_data(keyfile, &length, NULL);
+
+ if (!g_file_set_contents(pathname, data, length, &error)) {
+ DBG("Failed to store information: %s", error->message);
+ g_error_free(error);
+ g_assert(0);
+ }
+
+ g_free(data);
+}
+
+static void policy_allowed_bearers(const char *allowed_bearers)
+{
+ struct passwd *pwd;
+ uid_t uid;
+ char *pathname;
+ GKeyFile *keyfile;
+
+ LOG("update to '%s'", allowed_bearers);
+
+ uid = getuid();
+ pwd = getpwuid(uid);
+ g_assert(pwd);
+
+ keyfile = g_key_file_new();
+ g_key_file_set_string(keyfile, "policy_foo", "uid", pwd->pw_name);
+ g_key_file_set_string(keyfile, "policy_foo", "AllowedBearers",
+ allowed_bearers);
+
+ pathname = g_strdup_printf("%s/foo.policy", POLICYDIR);
+ policy_save(keyfile, pathname);
+
+ g_free(pathname);
+ g_key_file_free(keyfile);
+}
+
+static void policy_remove_file(void)
+{
+ char *pathname;
+
+ pathname = g_strdup_printf("%s/foo.policy", POLICYDIR);
+ unlink(pathname);
+ g_free(pathname);
+}
+
+static void test_session_policy_notify(struct test_session *session)
+{
+ enum test_session_state state = get_session_state(session);
+ enum test_session_state next_state = state;
+ DBusMessage *msg;
+
+ LOG("state %d session %p %s state %d", state, session,
+ session->notify_path, session->info->state);
+
+ switch (state) {
+ case TEST_SESSION_STATE_0:
+ if (session->info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
+ next_state = TEST_SESSION_STATE_1;
+ break;
+ case TEST_SESSION_STATE_1:
+ if (session->info->state >= CONNMAN_SESSION_STATE_CONNECTED)
+ next_state = TEST_SESSION_STATE_2;
+ break;
+ case TEST_SESSION_STATE_2:
+ if (session->info->state == CONNMAN_SESSION_STATE_DISCONNECTED)
+ next_state = TEST_SESSION_STATE_3;
+ default:
+ break;
+ }
+
+ if (state == next_state)
+ return;
+
+ set_session_state(session, next_state);
+
+ LOG("next_state %d", next_state);
+
+ switch (next_state) {
+ case TEST_SESSION_STATE_1:
+ policy_allowed_bearers("ethernet");
+
+ msg = session_connect(session->connection, session);
+ g_assert(msg);
+ dbus_message_unref(msg);
+ return;
+ case TEST_SESSION_STATE_2:
+ policy_allowed_bearers("");
+ return;
+ case TEST_SESSION_STATE_3:
+ policy_remove_file();
+ util_session_cleanup(session);
+ util_idle_call(session->fix, util_quit_loop,
+ util_session_destroy);
+ return;
+ default:
+ return;
+ }
+}
+
+static void test_session_policy(struct test_fix *fix)
+{
+ struct test_session *session;
+
+ /*
+ * +-------------------+
+ * | START |
+ * +-------------------+
+ * |
+ * | write policy AllowedBearers = ethernet
+ * v
+ * +-------------------+
+ * | FOO-CONNECTED |
+ * +-------------------+
+ * |
+ * | write policy AllowedBearers =
+ * v
+ * +-------------------+
+ * | END |
+ * +-------------------+
+ */
+
+ policy_remove_file();
+
+ util_session_create(fix, 1);
+ session = fix->session;
+
+ session->notify_path = g_strdup("/foo");
+ session->notify = test_session_policy_notify;
+
+ util_session_init(session);
+
+ set_session_state(session, TEST_SESSION_STATE_0);
+}
+
+static bool is_online(struct test_fix *fix)
+{
+ if (g_strcmp0(fix->manager.state, "online") == 0)
+ return true;
+
+ return false;
+}
+
+static void enable_session_mode(struct test_fix *fix)
+{
+ set_session_mode(fix, true);
+
+ if (!is_online(fix))
+ util_idle_call(fix, util_quit_loop, NULL);
+}
+
+static void manager_state_changed(struct test_fix *fix)
+{
+ if (!is_online(fix)) {
+ fix->manager_changed = NULL;
+ util_idle_call(fix, util_quit_loop, NULL);
+ }
+}
+
+static void disable_session_mode(struct test_fix *fix)
+{
+ set_session_mode(fix, false);
+}
+
+static void setup_cb(struct test_fix *fix)
+{
+ fix->manager_changed = manager_state_changed;
+
+ util_call(fix, enable_session_mode, NULL);
+}
+
+static void teardown_cb(struct test_fix *fix)
+{
+ util_call(fix, disable_session_mode, NULL);
+ util_idle_call(fix, util_quit_loop, NULL);
+}
+
+int main(int argc, char *argv[])
+{
+ g_test_init(&argc, &argv, NULL);
+
+ util_test_add("/manager/session create no notify",
+ test_session_create_no_notify, setup_cb, teardown_cb);
+ util_test_add("/manager/session destroy no notify",
+ test_session_destroy_no_notify, setup_cb, teardown_cb);
+ util_test_add("/manager/session create",
+ test_session_create, setup_cb, teardown_cb);
+ util_test_add("/manager/session create destroy",
+ test_session_create_destroy, setup_cb, teardown_cb);
+ util_test_add("/manager/session create duplicate notification",
+ test_session_create_dup_notification, setup_cb, teardown_cb);
+ util_test_add("/manager/session create many",
+ test_session_create_many, setup_cb, teardown_cb);
+
+ util_test_add("/session/connect",
+ test_session_connect, setup_cb, teardown_cb);
+ util_test_add("/session/disconnect",
+ test_session_disconnect, setup_cb, teardown_cb);
+ util_test_add("/session/connect disconnect",
+ test_session_connect_disconnect, setup_cb, teardown_cb);
+ util_test_add("/session/connect free-ride",
+ test_session_connect_free_ride, setup_cb, teardown_cb);
+
+ util_test_add("/session/policy",
+ test_session_policy, setup_cb, teardown_cb);
+
+ return g_test_run();
+}
diff --git a/tools/session-test.h b/tools/session-test.h
new file mode 100644
index 0000000..5e6d196
--- /dev/null
+++ b/tools/session-test.h
@@ -0,0 +1,142 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <glib.h>
+
+#include <connman/dbus.h>
+
+#include "../src/connman.h"
+
+struct test_session;
+struct test_fix;
+
+struct test_manager {
+ char *state;
+};
+
+typedef void (* util_test_func_t) (struct test_fix *fix);
+
+struct test_fix {
+ gpointer user_data;
+
+ GMainLoop *main_loop;
+ DBusConnection *main_connection;
+ unsigned int watch;
+ unsigned int manager_watch;
+
+ struct test_manager manager;
+ util_test_func_t manager_changed;
+
+ /* session test cases */
+ unsigned int max_sessions;
+ struct test_session *session;
+};
+
+void util_quit_loop(struct test_fix *fix);
+void util_idle_call(struct test_fix *fix, util_test_func_t func,
+ util_test_func_t destroy);
+void util_call(struct test_fix *fix, util_test_func_t func,
+ util_test_func_t destroy);
+void util_test_add(const char *test_name, util_test_func_t test,
+ util_test_func_t setup,
+ util_test_func_t teardown);
+void util_setup(struct test_fix *fix);
+void util_teardown(struct test_fix *fix);
+
+void util_session_create(struct test_fix *fix, unsigned int max_sessions);
+void util_session_destroy(struct test_fix *fix);
+void util_session_init(struct test_session *session);
+void util_session_cleanup(struct test_session *session);
+
+typedef void (* notify_func_t) (struct test_session *session);
+
+enum connman_session_state {
+ CONNMAN_SESSION_STATE_DISCONNECTED = 0,
+ CONNMAN_SESSION_STATE_CONNECTED = 1,
+ CONNMAN_SESSION_STATE_ONLINE = 2,
+};
+
+struct test_session_info {
+ enum connman_session_state state;
+ char *name;
+ char *bearer;
+ char *interface;
+ enum connman_session_type type;
+ /* ipv4, ipv6 dicts */
+ GSList *allowed_bearers;
+};
+
+struct test_session {
+ void *user_data;
+
+ struct test_fix *fix;
+ DBusConnection *connection;
+
+ char *session_path;
+ char *notify_path;
+ notify_func_t notify;
+
+ struct test_session_info *info;
+};
+
+struct test_bearer_info {
+ char *name;
+};
+
+/* session-api.c */
+void bearer_info_cleanup(gpointer bearer_info, gpointer user_data);
+
+void session_append_settings(DBusMessageIter *dict,
+ struct test_session_info *info);
+int session_notify_register(struct test_session *session,
+ const char *notify_path);
+int session_notify_unregister(struct test_session *session,
+ const char *notify_path);
+
+DBusMessage *session_connect(DBusConnection *connection,
+ struct test_session *session);
+DBusMessage *session_disconnect(DBusConnection *connection,
+ struct test_session *session);
+
+/* manager-api.c */
+DBusMessage *manager_get_services(DBusConnection *connection);
+DBusMessage *manager_get_properties(DBusConnection *connection);
+DBusMessage *manager_create_session(DBusConnection *connection,
+ struct test_session_info *info,
+ const char *notifier_path);
+DBusMessage *manager_destroy_session(DBusConnection *connection,
+ const char *notifier_path);
+DBusMessage *manager_set_session_mode(DBusConnection *connection,
+ bool enable);
+int manager_parse_properties(DBusMessage *msg,
+ struct test_manager *manager);
+
+/* #define DEBUG */
+#ifdef DEBUG
+#include <stdio.h>
+
+#define LOG(fmt, arg...) do { \
+ fprintf(stdout, "%s:%s() " fmt "\n", \
+ __FILE__, __FUNCTION__ , ## arg); \
+} while (0)
+#else
+#define LOG(fmt, arg...)
+#endif
diff --git a/tools/session-utils.c b/tools/session-utils.c
new file mode 100644
index 0000000..51cec5c
--- /dev/null
+++ b/tools/session-utils.c
@@ -0,0 +1,311 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2011-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+#include <gdbus.h>
+
+#include "../src/shared/util.h"
+#include "session-test.h"
+
+#define ENABLE_WRAPPER 1
+#define PROPERTY_CHANGED "PropertyChanged"
+
+void util_quit_loop(struct test_fix *fix)
+{
+ g_main_loop_quit(fix->main_loop);
+}
+
+static gboolean func_cb(gpointer data)
+{
+ struct cb_data *cbd = data;
+ util_test_func_t cb = cbd->cb;
+ struct test_fix *fix = cbd->user_data;
+
+ (*cb)(fix);
+
+ return FALSE;
+}
+
+static void destroy_cb(gpointer data)
+{
+ struct cb_data *cbd = data;
+ util_test_func_t cb = cbd->data;
+ struct test_fix *fix = cbd->user_data;
+
+ if (cb)
+ (*cb)(fix);
+
+ g_free(cbd);
+}
+
+void util_call(struct test_fix *fix, util_test_func_t func,
+ util_test_func_t destroy)
+{
+ struct cb_data *cbd = cb_data_new(func, fix);
+ GSource *source;
+
+ cbd->data = destroy;
+
+ source = g_timeout_source_new(0);
+ g_source_set_callback(source, func_cb, cbd, destroy_cb);
+ g_source_attach(source, g_main_loop_get_context(fix->main_loop));
+ g_source_unref(source);
+}
+
+void util_idle_call(struct test_fix *fix, util_test_func_t func,
+ util_test_func_t destroy)
+{
+ struct cb_data *cbd = cb_data_new(func, fix);
+ GSource *source;
+
+ cbd->data = destroy;
+
+ source = g_idle_source_new();
+ g_source_set_callback(source, func_cb, cbd, destroy_cb);
+ g_source_attach(source, g_main_loop_get_context(fix->main_loop));
+ g_source_unref(source);
+}
+
+static void connman_died(DBusConnection *connection, void *user_data)
+{
+ g_assert(FALSE);
+}
+
+static void manager_changed(struct test_fix *fix, DBusMessageIter *entry)
+{
+ DBusMessageIter iter;
+ const char *key;
+ const char *value;
+ int type;
+
+ dbus_message_iter_get_basic(entry, &key);
+
+ LOG("key %s", key);
+
+ dbus_message_iter_next(entry);
+
+ dbus_message_iter_recurse(entry, &iter);
+
+ type = dbus_message_iter_get_arg_type(&iter);
+
+ if (type != DBUS_TYPE_STRING)
+ return;
+
+ dbus_message_iter_get_basic(&iter, &value);
+
+ if (g_str_equal(key, "State")) {
+ LOG("State %s", value);
+
+ if (fix->manager.state)
+ g_free(fix->manager.state);
+
+ fix->manager.state = g_strdup(value);
+ }
+
+ if (fix->manager_changed)
+ fix->manager_changed(fix);
+}
+
+static gboolean handle_manager_changed(DBusConnection *connection,
+ DBusMessage *message,
+ void *user_data)
+{
+ struct test_fix *fix = user_data;
+
+ DBusMessageIter iter;
+
+ if (dbus_message_iter_init(message, &iter))
+ manager_changed(fix, &iter);
+
+ return TRUE;
+}
+
+static struct test_fix *create_fix(void)
+{
+ struct test_fix *fix;
+ DBusMessage *msg;
+
+ fix = g_new0(struct test_fix, 1);
+
+ fix->main_loop = g_main_loop_new(NULL, FALSE);
+ fix->main_connection = g_dbus_setup_private(DBUS_BUS_SYSTEM,
+ NULL, NULL);
+ fix->watch = g_dbus_add_service_watch(fix->main_connection,
+ CONNMAN_SERVICE,
+ NULL,
+ connman_died,
+ NULL, NULL);
+ fix->manager_watch = g_dbus_add_signal_watch(fix->main_connection,
+ CONNMAN_SERVICE, NULL,
+ CONNMAN_MANAGER_INTERFACE,
+ PROPERTY_CHANGED,
+ handle_manager_changed,
+ fix, NULL);
+
+ msg = manager_get_properties(fix->main_connection);
+ manager_parse_properties(msg, &fix->manager);
+ dbus_message_unref(msg);
+
+ return fix;
+}
+
+static void cleanup_fix(struct test_fix *fix)
+{
+ g_dbus_remove_watch(fix->main_connection, fix->watch);
+ g_dbus_remove_watch(fix->main_connection, fix->manager_watch);
+ dbus_connection_close(fix->main_connection);
+ dbus_connection_unref(fix->main_connection);
+
+ g_main_loop_unref(fix->main_loop);
+
+ g_free(fix);
+}
+
+struct test_data_cb {
+ util_test_func_t func;
+ util_test_func_t setup;
+ util_test_func_t teardown;
+};
+
+static void run_test_cb(gconstpointer data)
+{
+ const struct test_data_cb *cbd = data;
+ struct test_fix *fix;
+
+ fix = create_fix();
+
+ util_call(fix, cbd->setup, NULL);
+ g_main_loop_run(fix->main_loop);
+
+#if ENABLE_WRAPPER
+ if (g_test_trap_fork(60 * 1000 * 1000, 0)) {
+ util_call(fix, cbd->func, NULL);
+ g_main_loop_run(fix->main_loop);
+ exit(0);
+ }
+
+ g_test_trap_assert_passed();
+#else
+ util_call(fix, func, NULL);
+ g_main_loop_run(fix->main_loop);
+#endif
+
+ util_call(fix, cbd->teardown, NULL);
+ g_main_loop_run(fix->main_loop);
+
+ cleanup_fix(fix);
+}
+
+void util_test_add(const char *test_name, util_test_func_t test_func,
+ util_test_func_t setup, util_test_func_t teardown)
+{
+ struct test_data_cb *cbd = g_new0(struct test_data_cb, 1);
+
+ cbd->func = test_func;
+ cbd->setup = setup;
+ cbd->teardown = teardown;
+
+ g_test_add_vtable(test_name, 0, cbd, NULL,
+ (GTestFixtureFunc) run_test_cb,
+ (GTestFixtureFunc) g_free);
+}
+
+void util_session_create(struct test_fix *fix, unsigned int max_sessions)
+{
+ unsigned int i;
+
+ fix->max_sessions = max_sessions;
+ fix->session = g_try_new0(struct test_session, max_sessions);
+
+ for (i = 0; i < max_sessions; i++) {
+ fix->session[i].fix = fix;
+ fix->session[i].info = g_try_new0(struct test_session_info, 1);
+ fix->session[i].connection = g_dbus_setup_private(
+ DBUS_BUS_SYSTEM, NULL, NULL);
+ }
+}
+
+void util_session_destroy(struct test_fix *fix)
+{
+ unsigned int i;
+
+ for (i = 0; i < fix->max_sessions; i++) {
+ dbus_connection_close(fix->session[i].connection);
+ g_free(fix->session[i].info);
+ }
+
+ g_free(fix->session);
+}
+
+void util_session_init(struct test_session *session)
+{
+ DBusMessage *msg;
+ DBusMessageIter iter;
+ const char *path;
+ int err;
+
+ err = session_notify_register(session, session->notify_path);
+ g_assert(err == 0);
+
+ msg = manager_create_session(session->connection,
+ session->info,
+ session->notify_path);
+ g_assert(msg);
+ dbus_message_iter_init(msg, &iter);
+
+ dbus_message_iter_get_basic(&iter, &path);
+ session->session_path = g_strdup(path);
+
+ dbus_message_unref(msg);
+}
+
+void util_session_cleanup(struct test_session *session)
+{
+ DBusMessage *msg;
+ int err;
+
+ msg = manager_destroy_session(session->connection,
+ session->session_path);
+ g_assert(msg);
+ dbus_message_unref(msg);
+
+ err = session_notify_unregister(session,
+ session->notify_path);
+ g_assert(err == 0);
+
+ g_free(session->info->bearer);
+ g_free(session->info->name);
+ g_free(session->info->interface);
+ g_slist_foreach(session->info->allowed_bearers,
+ bearer_info_cleanup, NULL);
+ g_slist_free(session->info->allowed_bearers);
+
+ session->notify = NULL;
+ g_free(session->notify_path);
+ g_free(session->session_path);
+}
diff --git a/tools/stats-tool.c b/tools/stats-tool.c
new file mode 100644
index 0000000..7d117fd
--- /dev/null
+++ b/tools/stats-tool.c
@@ -0,0 +1,915 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2010-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/time.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+
+#include <sys/time.h>
+#include <time.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <errno.h>
+
+#include <glib.h>
+#include <glib/gstdio.h>
+
+#ifdef TEMP_FAILURE_RETRY
+#define TFR TEMP_FAILURE_RETRY
+#else
+#define TFR
+#endif
+
+#define MAGIC 0xFA00B916
+
+struct connman_stats_data {
+ unsigned int rx_packets;
+ unsigned int tx_packets;
+ unsigned int rx_bytes;
+ unsigned int tx_bytes;
+ unsigned int rx_errors;
+ unsigned int tx_errors;
+ unsigned int rx_dropped;
+ unsigned int tx_dropped;
+ unsigned int time;
+};
+
+struct stats_file_header {
+ unsigned int magic;
+ unsigned int begin;
+ unsigned int end;
+ unsigned int home;
+ unsigned int roaming;
+};
+
+struct stats_record {
+ time_t ts;
+ unsigned int roaming;
+ struct connman_stats_data data;
+};
+
+struct stats_file {
+ int fd;
+ char *name;
+ char *addr;
+ size_t len;
+ size_t max_len;
+
+ /* cached values */
+ int max_nr;
+ int nr;
+ struct stats_record *first;
+ struct stats_record *last;
+ struct stats_record *home_first;
+ struct stats_record *roaming_first;
+};
+
+struct stats_iter {
+ struct stats_file *file;
+ struct stats_record *begin;
+ struct stats_record *end;
+ struct stats_record *it;
+};
+
+static gint option_create = 0;
+static gint option_interval = 3;
+static bool option_dump = false;
+static bool option_summary = false;
+static char *option_info_file_name = NULL;
+static time_t option_start_ts = -1;
+static char *option_last_file_name = NULL;
+
+static bool parse_start_ts(const char *key, const char *value,
+ gpointer user_data, GError **error)
+{
+ GTimeVal time_val;
+
+ if (!g_time_val_from_iso8601(value, &time_val))
+ return false;
+
+ option_start_ts = time_val.tv_sec;
+
+ return true;
+}
+
+static GOptionEntry options[] = {
+ { "create", 'c', 0, G_OPTION_ARG_INT, &option_create,
+ "Create a .data file with NR faked entries", "NR" },
+ { "interval", 'i', 0, G_OPTION_ARG_INT, &option_interval,
+ "Interval in seconds (used with create)", "INTERVAL" },
+ { "dump", 'd', 0, G_OPTION_ARG_NONE, &option_dump,
+ "Dump contents of .data file" },
+ { "summary", 's', 0, G_OPTION_ARG_NONE, &option_summary,
+ "Summary of .data file" },
+ { "info", 'f', 0, G_OPTION_ARG_FILENAME, &option_info_file_name,
+ ".info file name" },
+ { "startts", 't', 0, G_OPTION_ARG_CALLBACK, parse_start_ts,
+ "Set start time for creating .data file "
+ "(example 2010-11-05T23:00:12Z)", "TS"},
+ { "last", 'l', 0, G_OPTION_ARG_FILENAME, &option_last_file_name,
+ "Start values from last .data file" },
+ { NULL },
+};
+
+static struct stats_file_header *get_hdr(struct stats_file *file)
+{
+ return (struct stats_file_header *)file->addr;
+}
+
+static struct stats_record *get_begin(struct stats_file *file)
+{
+ unsigned int off = get_hdr(file)->begin;
+
+ return (struct stats_record *)(file->addr + off);
+}
+
+static struct stats_record *get_end(struct stats_file *file)
+{
+ unsigned int off = get_hdr(file)->end;
+
+ return (struct stats_record *)(file->addr + off);
+}
+
+static struct stats_record *get_home(struct stats_file *file)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+
+ if (hdr->home == UINT_MAX)
+ return NULL;
+
+ return (struct stats_record *)(file->addr + hdr->home);
+}
+
+static struct stats_record *get_roaming(struct stats_file *file)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+
+ if (hdr->roaming == UINT_MAX)
+ return NULL;
+
+ return (struct stats_record *)(file->addr + hdr->roaming);
+}
+
+static void set_end(struct stats_file *file, struct stats_record *end)
+{
+ struct stats_file_header *hdr;
+
+ hdr = get_hdr(file);
+ hdr->end = (char *)end - file->addr;
+}
+
+static int get_index(struct stats_file *file, struct stats_record *rec)
+{
+ return rec - file->first;
+}
+
+static struct stats_record *get_next(struct stats_file *file,
+ struct stats_record *cur)
+{
+ cur++;
+
+ if (cur > file->last)
+ cur = file->first;
+
+ return cur;
+}
+
+static struct stats_record *get_iterator_begin(struct stats_file *file)
+{
+ return get_next(file, get_begin(file));
+}
+
+static struct stats_record *get_iterator_end(struct stats_file *file)
+{
+ return get_next(file, get_end(file));
+}
+
+static void stats_print_record(struct stats_record *rec)
+{
+ char buffer[30];
+
+ strftime(buffer, 30, "%d-%m-%Y %T", localtime(&rec->ts));
+ printf("%p %lld %s %01d %d %d %d %d %d %d %d %d %d\n",
+ rec, (long long int)rec->ts, buffer,
+ rec->roaming,
+ rec->data.rx_packets,
+ rec->data.tx_packets,
+ rec->data.rx_bytes,
+ rec->data.tx_bytes,
+ rec->data.rx_errors,
+ rec->data.tx_errors,
+ rec->data.rx_dropped,
+ rec->data.tx_dropped,
+ rec->data.time);
+}
+
+static void stats_hdr_info(struct stats_file *file)
+{
+ struct stats_file_header *hdr;
+ struct stats_record *begin, *end, *home, *roaming;
+ unsigned int home_idx, roaming_idx;
+
+ hdr = get_hdr(file);
+ begin = get_begin(file);
+ end = get_end(file);
+
+ home = get_home(file);
+ if (!home)
+ home_idx = UINT_MAX;
+ else
+ home_idx = get_index(file, home);
+
+ roaming = get_roaming(file);
+ if (!roaming)
+ roaming_idx = UINT_MAX;
+ else
+ roaming_idx = get_index(file, roaming);
+
+ printf("Data Structure Sizes\n");
+ printf(" sizeof header %zd/0x%02zx\n",
+ sizeof(struct stats_file_header),
+ sizeof(struct stats_file_header));
+ printf(" sizeof entry %zd/0%02zx\n\n",
+ sizeof(struct stats_record),
+ sizeof(struct stats_record));
+
+ printf("File\n");
+ printf(" addr %p\n", file->addr);
+ printf(" len %zd\n", file->len);
+
+ printf(" max nr entries %d\n", file->max_nr);
+ printf(" nr entries %d\n\n", file->nr);
+
+ printf("Header\n");
+ printf(" magic 0x%08x\n", hdr->magic);
+ printf(" begin [%d] 0x%08x\n",
+ get_index(file, begin), hdr->begin);
+ printf(" end [%d] 0x%08x\n",
+ get_index(file, end), hdr->end);
+ printf(" home [%d] 0x%08x\n",
+ home_idx, hdr->home);
+ printf(" roaming [%d] 0x%08x\n\n",
+ roaming_idx, hdr->roaming);
+
+
+ printf("Pointers\n");
+ printf(" hdr %p\n", hdr);
+ printf(" begin %p\n", begin);
+ printf(" end %p\n", end);
+ printf(" home %p\n", home);
+ printf(" romaing %p\n", roaming);
+ printf(" first %p\n", file->first);
+ printf(" last %p\n\n", file->last);
+}
+
+static void stats_print_entries(struct stats_file *file)
+{
+ struct stats_record *it;
+ int i;
+
+ printf("[ idx] ptr ts ts rx_packets tx_packets rx_bytes "
+ "tx_bytes rx_errors tx_errors rx_dropped tx_dropped time\n\n");
+
+ for (i = 0, it = file->first; it <= file->last; it++, i++) {
+ printf("[%04d] ", i);
+ stats_print_record(it);
+ }
+}
+
+static void stats_print_rec_diff(struct stats_record *begin,
+ struct stats_record *end)
+{
+ printf("\trx_packets: %d\n",
+ end->data.rx_packets - begin->data.rx_packets);
+ printf("\ttx_packets: %d\n",
+ end->data.tx_packets - begin->data.tx_packets);
+ printf("\trx_bytes: %d\n",
+ end->data.rx_bytes - begin->data.rx_bytes);
+ printf("\ttx_bytes: %d\n",
+ end->data.tx_bytes - begin->data.tx_bytes);
+ printf("\trx_errors: %d\n",
+ end->data.rx_errors - begin->data.rx_errors);
+ printf("\ttx_errors: %d\n",
+ end->data.tx_errors - begin->data.tx_errors);
+ printf("\trx_dropped: %d\n",
+ end->data.rx_dropped - begin->data.rx_dropped);
+ printf("\ttx_dropped: %d\n",
+ end->data.tx_dropped - begin->data.tx_dropped);
+ printf("\ttime: %d\n",
+ end->data.time - begin->data.time);
+}
+
+static void stats_print_diff(struct stats_file *file)
+{
+ struct stats_record *begin, *end;
+
+ begin = get_begin(file);
+ begin = get_next(file, begin);
+ end = get_end(file);
+
+ printf("\n(begin + 1)\n");
+ printf("\t[%04d] ", get_index(file, begin));
+ stats_print_record(begin);
+ printf("end\n");
+ printf("\t[%04d] ", get_index(file, end));
+ stats_print_record(end);
+
+ if (file->home_first && get_home(file)) {
+ printf("\nhome\n");
+ stats_print_rec_diff(file->home_first, get_home(file));
+ }
+
+ if (file->roaming_first && get_roaming(file)) {
+ printf("\roaming\n");
+ stats_print_rec_diff(file->roaming_first, get_roaming(file));
+ }
+}
+
+static void update_max_nr_entries(struct stats_file *file)
+{
+ file->max_nr = (file->len - sizeof(struct stats_file_header)) /
+ sizeof(struct stats_record);
+}
+
+static void update_nr_entries(struct stats_file *file)
+{
+ struct stats_record *begin, *end;
+ int nr;
+
+ begin = get_begin(file);
+ end = get_end(file);
+
+ nr = get_index(file, end) - get_index(file, begin);
+
+ if (nr < 0)
+ nr += file->max_nr;
+
+ file->nr = nr;
+}
+
+static void update_first(struct stats_file *file)
+{
+ file->first = (struct stats_record *)(file->addr +
+ sizeof(struct stats_file_header));
+}
+
+static void update_last(struct stats_file *file)
+{
+ struct stats_record *last;
+
+ last = file->first;
+ last += file->max_nr - 1;
+
+ file->last = last;
+}
+
+static int stats_file_update_cache(struct stats_file *file)
+{
+ struct stats_record *it, *end;
+
+ update_max_nr_entries(file);
+ update_nr_entries(file);
+ update_first(file);
+ update_last(file);
+ file->home_first = NULL;
+ file->roaming_first = NULL;
+
+ end = get_iterator_end(file);
+ for (it = get_iterator_begin(file);
+ it != end;
+ it = get_next(file, it)) {
+
+ if (!file->home_first && it->roaming == 0)
+ file->home_first = it;
+
+ if (!file->roaming_first && it->roaming == 1)
+ file->roaming_first = it;
+
+ if (file->home_first && file->roaming_first)
+ break;
+ }
+
+ return 0;
+}
+
+static int stats_file_remap(struct stats_file *file, size_t size)
+{
+ size_t page_size, new_size;
+ void *addr;
+ int err;
+
+ page_size = sysconf(_SC_PAGESIZE);
+ new_size = (size + page_size - 1) & ~(page_size - 1);
+
+ err = ftruncate(file->fd, new_size);
+ if (err < 0) {
+ fprintf(stderr, "ftrunctate error %s for %s",
+ strerror(errno), file->name);
+ return -errno;
+ }
+
+ if (!file->addr) {
+ addr = mmap(NULL, new_size, PROT_READ | PROT_WRITE,
+ MAP_SHARED, file->fd, 0);
+ } else {
+ addr = mremap(file->addr, file->len, new_size, MREMAP_MAYMOVE);
+ }
+
+ if (addr == MAP_FAILED) {
+ fprintf(stderr, "mmap error %s for %s\n",
+ strerror(errno), file->name);
+ return -errno;
+ }
+
+ file->addr = addr;
+ file->len = new_size;
+ file->max_len = new_size;
+
+ return 0;
+}
+
+static int stats_open(struct stats_file *file, const char *name)
+{
+ struct stats_file_header *hdr;
+ struct stat tm;
+ int err;
+ size_t size = 0;
+
+ bzero(file, sizeof(struct stats_file));
+
+ if (name) {
+ file->name = g_strdup(name);
+
+ file->fd = TFR(open(file->name,
+ O_RDWR | O_CREAT | O_CLOEXEC, 0644));
+ if (file->fd == -1) {
+ fprintf(stderr, "open error %s for %s\n",
+ strerror(errno), file->name);
+ return -errno;
+ }
+
+ err = fstat(file->fd, &tm);
+ if (err < 0) {
+ fprintf(stderr, "fstat error %s for %s\n",
+ strerror(errno), file->name);
+ return err;
+ }
+
+ size = (size_t)tm.st_size;
+ } else {
+ file->name = g_strdup("stats.XXXXXX.tmp");
+ file->fd = g_mkstemp_full(file->name, O_RDWR | O_CREAT, 0644);
+ if (file->fd == -1) {
+ fprintf(stderr, "creating tmp failed\n");
+ return -1;
+ }
+ }
+
+ if (size == 0)
+ size = sysconf(_SC_PAGESIZE);
+
+ err = stats_file_remap(file, size);
+ if (err < 0) {
+ fprintf(stderr, "remap failed\n");
+ return err;
+ }
+
+ /* Initialize new file */
+ hdr = get_hdr(file);
+ if (hdr->magic != MAGIC ||
+ hdr->begin < sizeof(struct stats_file_header) ||
+ hdr->end < sizeof(struct stats_file_header) ||
+ hdr->home < sizeof(struct stats_file_header) ||
+ hdr->roaming < sizeof(struct stats_file_header) ||
+ hdr->begin > file->len ||
+ hdr->end > file->len) {
+ hdr->magic = MAGIC;
+ hdr->begin = sizeof(struct stats_file_header);
+ hdr->end = sizeof(struct stats_file_header);
+ hdr->home = UINT_MAX;
+ hdr->roaming = UINT_MAX;
+
+ }
+ stats_file_update_cache(file);
+
+ return 0;
+}
+
+static void stats_close(struct stats_file *file)
+{
+ munmap(file->addr, file->len);
+ close(file->fd);
+ g_free(file->name);
+}
+
+static int stats_create(struct stats_file *file, unsigned int nr,
+ unsigned int interval, time_t start_ts,
+ struct stats_record *start)
+{
+ unsigned int i;
+ int err;
+ struct stats_record *cur, *next;
+ struct stats_file_header *hdr;
+ unsigned int pkt;
+ unsigned int step_ts;
+ unsigned int roaming = FALSE;
+
+ hdr = get_hdr(file);
+
+ hdr->magic = MAGIC;
+ hdr->begin = sizeof(struct stats_file_header);
+ hdr->end = sizeof(struct stats_file_header);
+ hdr->home = UINT_MAX;
+ hdr->roaming = UINT_MAX;
+
+ stats_file_update_cache(file);
+
+ if (start) {
+ struct stats_record *rec;
+
+ rec = get_end(file);
+ memcpy(rec, start, sizeof(struct stats_record));
+ } else {
+ get_end(file)->ts = start_ts;
+ }
+
+ for (i = 0; i < nr; i++) {
+ if (file->last == get_end(file)) {
+ err = stats_file_remap(file, file->len +
+ sysconf(_SC_PAGESIZE));
+ if (err < 0)
+ return err;
+
+ stats_file_update_cache(file);
+ }
+ cur = get_end(file);
+ next = get_next(file, cur);
+
+ step_ts = (rand() % interval);
+ if (step_ts == 0)
+ step_ts = 1;
+
+ next->ts = cur->ts + step_ts;
+ next->roaming = roaming;
+ next->data.time = cur->data.time + step_ts;
+
+ next->data.rx_packets = cur->data.rx_packets;
+ next->data.rx_bytes = cur->data.rx_bytes;
+
+ if (rand() % 3 == 0) {
+ pkt = rand() % 5;
+ next->data.rx_packets += pkt;
+ next->data.rx_bytes += pkt * (rand() % 1500);
+ }
+
+ next->data.tx_packets = cur->data.tx_packets;
+ next->data.tx_bytes = cur->data.tx_bytes;
+
+ if (rand() % 3 == 0) {
+ pkt = rand() % 5;
+ next->data.tx_packets += pkt;
+ next->data.tx_bytes += pkt * (rand() % 1500);
+ }
+
+ set_end(file, next);
+
+ if ((rand() % 50) == 0)
+ roaming = roaming ? FALSE : TRUE;
+
+ }
+
+ return 0;
+}
+
+static struct stats_record *get_next_record(struct stats_iter *iter)
+{
+ if (iter->it != iter->end) {
+ struct stats_record *tmp;
+
+ tmp = iter->it;
+ iter->it = get_next(iter->file, iter->it);
+
+ return tmp;
+ }
+
+ return NULL;
+}
+
+static int append_record(struct stats_file *file,
+ struct stats_record *rec)
+{
+ struct stats_record *cur, *next;
+ int err;
+
+ if (file->last == get_end(file)) {
+ err = stats_file_remap(file, file->len +
+ sysconf(_SC_PAGESIZE));
+ if (err < 0)
+ return err;
+
+ stats_file_update_cache(file);
+ }
+
+ cur = get_end(file);
+ next = get_next(file, cur);
+
+ memcpy(next, rec, sizeof(struct stats_record));
+
+ set_end(file, next);
+
+ return 0;
+}
+
+static struct stats_record *process_file(struct stats_iter *iter,
+ struct stats_file *temp_file,
+ struct stats_record *cur,
+ GDate *date_change_step_size,
+ int account_period_offset)
+{
+ struct stats_record *home, *roaming;
+ struct stats_record *next;
+
+ home = NULL;
+ roaming = NULL;
+
+ if (!cur)
+ cur = get_next_record(iter);
+ next = get_next_record(iter);
+
+ while (next) {
+ GDate date_cur;
+ GDate date_next;
+ int append;
+
+ append = FALSE;
+
+ if (cur->roaming)
+ roaming = cur;
+ else
+ home = cur;
+
+ g_date_set_time_t(&date_cur, cur->ts);
+ g_date_set_time_t(&date_next, next->ts);
+
+ if (g_date_compare(&date_cur, date_change_step_size) < 0) {
+ /* month period size */
+ GDateDay day_cur, day_next;
+ GDateMonth month_cur, month_next;
+
+ month_cur = g_date_get_month(&date_cur);
+ month_next = g_date_get_month(&date_next);
+
+ day_cur = g_date_get_day(&date_cur);
+ day_next = g_date_get_day(&date_next);
+
+ if (day_cur == day_next && month_cur != month_next)
+ append = TRUE;
+ else if (day_cur < account_period_offset
+ && day_next >= account_period_offset)
+ append = TRUE;
+ } else {
+ /* day period size */
+ if (g_date_days_between(&date_cur, &date_next) > 0)
+ append = TRUE;
+ }
+
+ if (append) {
+ if (home) {
+ append_record(temp_file, home);
+ home = NULL;
+ }
+
+ if (roaming) {
+ append_record(temp_file, roaming);
+ roaming = NULL;
+ }
+ }
+
+ cur = next;
+ next = get_next_record(iter);
+ }
+
+ return cur;
+}
+
+static int summarize(struct stats_file *data_file,
+ struct stats_file *history_file,
+ struct stats_file *temp_file,
+ int account_period_offset)
+{
+ struct stats_iter data_iter;
+ struct stats_iter history_iter;
+ struct stats_record *cur, *next;
+
+ GDate today, date_change_step_size;
+
+ /*
+ * First calculate the date when switch from monthly
+ * accounting period size to daily size
+ */
+ g_date_set_time_t(&today, time(NULL));
+
+ date_change_step_size = today;
+ if (g_date_get_day(&today) - account_period_offset >= 0)
+ g_date_subtract_months(&date_change_step_size, 2);
+ else
+ g_date_subtract_months(&date_change_step_size, 3);
+
+ g_date_set_day(&date_change_step_size, account_period_offset);
+
+
+ /* Now process history file */
+ cur = NULL;
+
+ if (history_file) {
+ history_iter.file = history_file;
+ history_iter.begin = get_iterator_begin(history_iter.file);
+ history_iter.end = get_iterator_end(history_iter.file);
+ history_iter.it = history_iter.begin;
+
+ cur = process_file(&history_iter, temp_file, NULL,
+ &date_change_step_size,
+ account_period_offset);
+ }
+
+ data_iter.file = data_file;
+ data_iter.begin = get_iterator_begin(data_iter.file);
+ data_iter.end = get_iterator_end(data_iter.file);
+ data_iter.it = data_iter.begin;
+
+ /*
+ * Ensure date_file records are newer than the history_file
+ * record
+ */
+ if (cur) {
+ next = get_next_record(&data_iter);
+ while (next && cur->ts > next->ts)
+ next = get_next_record(&data_iter);
+ }
+
+ /* And finally process the new data records */
+ cur = process_file(&data_iter, temp_file, cur,
+ &date_change_step_size, account_period_offset);
+
+ if (cur)
+ append_record(temp_file, cur);
+
+ return 0;
+}
+
+static void swap_and_close_files(struct stats_file *history_file,
+ struct stats_file *temp_file)
+{
+ munmap(history_file->addr, history_file->len);
+ munmap(temp_file->addr, temp_file->len);
+
+ TFR(close(temp_file->fd));
+
+ unlink(history_file->name);
+
+ if (link(temp_file->name, history_file->name) < 0)
+ return;
+
+ unlink(temp_file->name);
+ TFR(close(history_file->fd));
+}
+
+static void history_file_update(struct stats_file *data_file,
+ const char *history_file_name)
+{
+ struct stats_file _history_file;
+ struct stats_file tempory_file;
+
+ struct stats_file *history_file = NULL;
+
+ if (stats_open(&_history_file, history_file_name) == 0)
+ history_file = &_history_file;
+
+ if (stats_open(&tempory_file, NULL) < 0) {
+ if (history_file)
+ stats_close(history_file);
+ return;
+ }
+
+ summarize(data_file, history_file, &tempory_file, 13);
+
+ swap_and_close_files(history_file, &tempory_file);
+}
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+
+ struct stats_file_header *hdr;
+ struct stats_file data, *data_file;
+ struct stats_record *rec;
+ time_t start_ts;
+ int err;
+
+ rec = NULL;
+
+ data_file = &data;
+
+ putenv("TZ=GMT0");
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ exit(1);
+ }
+
+ g_option_context_free(context);
+
+ if (argc < 2) {
+ printf("Usage: %s [FILENAME]\n", argv[0]);
+ exit(0);
+ }
+
+ err = stats_open(data_file, argv[1]);
+ if (err < 0) {
+ fprintf(stderr, "failed open file %s\n", argv[1]);
+ exit(1);
+ }
+
+ if (option_last_file_name) {
+ struct stats_file last;
+ if (stats_open(&last, option_last_file_name) < 0) {
+ fprintf(stderr, "failed open file %s\n",
+ option_last_file_name);
+ exit(1);
+ }
+
+ rec = get_end(&last);
+ }
+
+ if (option_start_ts == -1)
+ start_ts = time(NULL);
+ else
+ start_ts = option_start_ts;
+
+ if (option_create > 0)
+ stats_create(data_file, option_create, option_interval,
+ start_ts, rec);
+
+ hdr = get_hdr(data_file);
+ if (hdr->magic != MAGIC) {
+ fprintf(stderr, "header file magic test failed\n");
+ goto err;
+ }
+
+ stats_file_update_cache(data_file);
+
+ stats_hdr_info(data_file);
+
+ if (option_dump)
+ stats_print_entries(data_file);
+
+ if (option_summary)
+ stats_print_diff(data_file);
+
+ if (option_info_file_name)
+ history_file_update(data_file, option_info_file_name);
+
+err:
+ stats_close(data_file);
+
+ return 0;
+}
diff --git a/tools/supplicant-dbus.c b/tools/supplicant-dbus.c
new file mode 100644
index 0000000..d409da2
--- /dev/null
+++ b/tools/supplicant-dbus.c
@@ -0,0 +1,411 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <dbus/dbus.h>
+
+#include "supplicant-dbus.h"
+
+#define TIMEOUT 5000
+
+static DBusConnection *connection = NULL;
+
+void supplicant_dbus_setup(DBusConnection *conn)
+{
+ connection = conn;
+}
+
+void supplicant_dbus_array_foreach(DBusMessageIter *iter,
+ supplicant_dbus_array_function function,
+ void *user_data)
+{
+ DBusMessageIter entry;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_INVALID) {
+ if (function)
+ function(&entry, user_data);
+
+ dbus_message_iter_next(&entry);
+ }
+}
+
+void supplicant_dbus_property_foreach(DBusMessageIter *iter,
+ supplicant_dbus_property_function function,
+ void *user_data)
+{
+ DBusMessageIter dict;
+
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY)
+ return;
+
+ dbus_message_iter_recurse(iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return;
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return;
+
+ dbus_message_iter_recurse(&entry, &value);
+
+ if (key) {
+ if (strcmp(key, "Properties") == 0)
+ supplicant_dbus_property_foreach(&value,
+ function, user_data);
+ else if (function)
+ function(key, &value, user_data);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+}
+
+struct property_get_data {
+ supplicant_dbus_property_function function;
+ void *user_data;
+};
+
+static void property_get_all_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_get_data *data = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ goto done;
+
+ if (!dbus_message_iter_init(reply, &iter))
+ goto done;
+
+ supplicant_dbus_property_foreach(&iter, data->function,
+ data->user_data);
+
+ if (data->function)
+ data->function(NULL, NULL, data->user_data);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_property_get_all(const char *path, const char *interface,
+ supplicant_dbus_property_function function,
+ void *user_data)
+{
+ struct property_get_data *data;
+ DBusMessage *message;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface)
+ return -EINVAL;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ DBUS_INTERFACE_PROPERTIES, "GetAll");
+ if (!message) {
+ dbus_free(data);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_append_args(message, DBUS_TYPE_STRING, &interface, NULL);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ data->function = function;
+ data->user_data = user_data;
+
+ dbus_pending_call_set_notify(call, property_get_all_reply,
+ data, dbus_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+struct property_set_data {
+ supplicant_dbus_result_function function;
+ void *user_data;
+};
+
+static void property_set_reply(DBusPendingCall *call, void *user_data)
+{
+ struct property_set_data *data = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ const char *error;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ error = dbus_message_get_error_name(reply);
+ else
+ error = NULL;
+
+ if (!dbus_message_iter_init(reply, &iter))
+ goto done;
+
+ if (data->function)
+ data->function(error, &iter, data->user_data);
+
+done:
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_property_set(const char *path, const char *interface,
+ const char *key, const char *signature,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data)
+{
+ struct property_set_data *data;
+ DBusMessage *message;
+ DBusMessageIter iter, value;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface)
+ return -EINVAL;
+
+ if (!key || !signature || !setup)
+ return -EINVAL;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ DBUS_INTERFACE_PROPERTIES, "Set");
+ if (!message) {
+ dbus_free(data);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_iter_init_append(message, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &interface);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &key);
+
+ dbus_message_iter_open_container(&iter, DBUS_TYPE_VARIANT,
+ signature, &value);
+ setup(&value, user_data);
+ dbus_message_iter_close_container(&iter, &value);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ data->function = function;
+ data->user_data = user_data;
+
+ dbus_pending_call_set_notify(call, property_set_reply,
+ data, dbus_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+struct method_call_data {
+ supplicant_dbus_result_function function;
+ void *user_data;
+};
+
+static void method_call_reply(DBusPendingCall *call, void *user_data)
+{
+ struct method_call_data *data = user_data;
+ DBusMessage *reply;
+ DBusMessageIter iter;
+ const char *error;
+
+ reply = dbus_pending_call_steal_reply(call);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ error = dbus_message_get_error_name(reply);
+ else
+ error = NULL;
+
+ dbus_message_iter_init(reply, &iter);
+
+ if (data->function)
+ data->function(error, &iter, data->user_data);
+
+ dbus_message_unref(reply);
+
+ dbus_pending_call_unref(call);
+}
+
+int supplicant_dbus_method_call(const char *path,
+ const char *interface, const char *method,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data)
+{
+ struct method_call_data *data;
+ DBusMessage *message;
+ DBusMessageIter iter;
+ DBusPendingCall *call;
+
+ if (!connection)
+ return -EINVAL;
+
+ if (!path || !interface || !method)
+ return -EINVAL;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ message = dbus_message_new_method_call(SUPPLICANT_SERVICE, path,
+ interface, method);
+ if (!message) {
+ dbus_free(data);
+ return -ENOMEM;
+ }
+
+ dbus_message_set_auto_start(message, FALSE);
+
+ dbus_message_iter_init_append(message, &iter);
+ if (setup)
+ setup(&iter, user_data);
+
+ if (!dbus_connection_send_with_reply(connection, message,
+ &call, TIMEOUT)) {
+ dbus_message_unref(message);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ if (!call) {
+ dbus_message_unref(message);
+ dbus_free(data);
+ return -EIO;
+ }
+
+ data->function = function;
+ data->user_data = user_data;
+
+ dbus_pending_call_set_notify(call, method_call_reply,
+ data, dbus_free);
+
+ dbus_message_unref(message);
+
+ return 0;
+}
+
+void supplicant_dbus_property_append_basic(DBusMessageIter *iter,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter value;
+ const char *signature;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &key);
+
+ switch (type) {
+ case DBUS_TYPE_BOOLEAN:
+ signature = DBUS_TYPE_BOOLEAN_AS_STRING;
+ break;
+ case DBUS_TYPE_STRING:
+ signature = DBUS_TYPE_STRING_AS_STRING;
+ break;
+ case DBUS_TYPE_BYTE:
+ signature = DBUS_TYPE_BYTE_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT16:
+ signature = DBUS_TYPE_UINT16_AS_STRING;
+ break;
+ case DBUS_TYPE_INT16:
+ signature = DBUS_TYPE_INT16_AS_STRING;
+ break;
+ case DBUS_TYPE_UINT32:
+ signature = DBUS_TYPE_UINT32_AS_STRING;
+ break;
+ case DBUS_TYPE_INT32:
+ signature = DBUS_TYPE_INT32_AS_STRING;
+ break;
+ case DBUS_TYPE_OBJECT_PATH:
+ signature = DBUS_TYPE_OBJECT_PATH_AS_STRING;
+ break;
+ default:
+ signature = DBUS_TYPE_VARIANT_AS_STRING;
+ break;
+ }
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_VARIANT,
+ signature, &value);
+ dbus_message_iter_append_basic(&value, type, val);
+ dbus_message_iter_close_container(iter, &value);
+}
diff --git a/tools/supplicant-dbus.h b/tools/supplicant-dbus.h
new file mode 100644
index 0000000..4452894
--- /dev/null
+++ b/tools/supplicant-dbus.h
@@ -0,0 +1,93 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <dbus/dbus.h>
+
+#define SUPPLICANT_SERVICE "fi.w1.wpa_supplicant1"
+#define SUPPLICANT_INTERFACE "fi.w1.wpa_supplicant1"
+#define SUPPLICANT_PATH "/fi/w1/wpa_supplicant1"
+
+typedef void (* supplicant_dbus_array_function) (DBusMessageIter *iter,
+ void *user_data);
+
+typedef void (* supplicant_dbus_property_function) (const char *key,
+ DBusMessageIter *iter, void *user_data);
+
+typedef void (* supplicant_dbus_setup_function) (DBusMessageIter *iter,
+ void *user_data);
+
+typedef void (* supplicant_dbus_result_function) (const char *error,
+ DBusMessageIter *iter, void *user_data);
+
+void supplicant_dbus_setup(DBusConnection *conn);
+
+void supplicant_dbus_array_foreach(DBusMessageIter *iter,
+ supplicant_dbus_array_function function,
+ void *user_data);
+
+void supplicant_dbus_property_foreach(DBusMessageIter *iter,
+ supplicant_dbus_property_function function,
+ void *user_data);
+
+int supplicant_dbus_property_get_all(const char *path, const char *interface,
+ supplicant_dbus_property_function function,
+ void *user_data);
+
+int supplicant_dbus_property_set(const char *path, const char *interface,
+ const char *key, const char *signature,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data);
+
+int supplicant_dbus_method_call(const char *path,
+ const char *interface, const char *method,
+ supplicant_dbus_setup_function setup,
+ supplicant_dbus_result_function function,
+ void *user_data);
+
+void supplicant_dbus_property_append_basic(DBusMessageIter *iter,
+ const char *key, int type, void *val);
+
+static inline void supplicant_dbus_dict_open(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_open_container(iter, DBUS_TYPE_ARRAY,
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING, dict);
+}
+
+static inline void supplicant_dbus_dict_close(DBusMessageIter *iter,
+ DBusMessageIter *dict)
+{
+ dbus_message_iter_close_container(iter, dict);
+}
+
+static inline void supplicant_dbus_dict_append_basic(DBusMessageIter *dict,
+ const char *key, int type, void *val)
+{
+ DBusMessageIter entry;
+
+ dbus_message_iter_open_container(dict, DBUS_TYPE_DICT_ENTRY,
+ NULL, &entry);
+ supplicant_dbus_property_append_basic(&entry, key, type, val);
+ dbus_message_iter_close_container(dict, &entry);
+}
diff --git a/tools/supplicant-test.c b/tools/supplicant-test.c
new file mode 100644
index 0000000..a640807
--- /dev/null
+++ b/tools/supplicant-test.c
@@ -0,0 +1,198 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <syslog.h>
+
+#include <gdbus.h>
+
+#include "supplicant.h"
+
+#define DBG(fmt, arg...) do { \
+ syslog(LOG_DEBUG, "%s() " fmt, __FUNCTION__ , ## arg); \
+} while (0)
+
+static void create_callback(int result, struct supplicant_interface *interface,
+ void *user_data)
+{
+ DBG("* result %d ifname %s", result,
+ supplicant_interface_get_ifname(interface));
+
+ if (result < 0)
+ return;
+
+ //supplicant_set_debug_level(1);
+}
+
+static void system_ready(void)
+{
+ DBG("*");
+
+ supplicant_interface_create("wlan0", "nl80211,wext",
+ create_callback, NULL);
+}
+
+static void system_killed(void)
+{
+ DBG("*");
+}
+
+static void scan_callback(int result, void *user_data)
+{
+ DBG("* result %d", result);
+
+ if (result < 0)
+ return;
+}
+
+static void interface_added(struct supplicant_interface *interface)
+{
+ const char *ifname = supplicant_interface_get_ifname(interface);
+ const char *driver = supplicant_interface_get_driver(interface);
+
+ DBG("* ifname %s driver %s", ifname, driver);
+
+ if (supplicant_interface_scan(interface, scan_callback, NULL) < 0)
+ DBG("scan failed");
+}
+
+static void interface_removed(struct supplicant_interface *interface)
+{
+ const char *ifname = supplicant_interface_get_ifname(interface);
+
+ DBG("* ifname %s", ifname);
+}
+
+static void scan_started(struct supplicant_interface *interface)
+{
+ const char *ifname = supplicant_interface_get_ifname(interface);
+
+ DBG("* ifname %s", ifname);
+}
+
+static void scan_finished(struct supplicant_interface *interface)
+{
+ const char *ifname = supplicant_interface_get_ifname(interface);
+
+ DBG("* ifname %s", ifname);
+}
+
+static void network_added(struct supplicant_network *network)
+{
+ const char *name = supplicant_network_get_name(network);
+
+ DBG("* name %s", name);
+
+ DBG("* %s", supplicant_network_get_identifier(network));
+}
+
+static void network_removed(struct supplicant_network *network)
+{
+ const char *name = supplicant_network_get_name(network);
+
+ DBG("* name %s", name);
+}
+
+static const struct supplicant_callbacks callbacks = {
+ .system_ready = system_ready,
+ .system_killed = system_killed,
+ .interface_added = interface_added,
+ .interface_removed = interface_removed,
+ .scan_started = scan_started,
+ .scan_finished = scan_finished,
+ .network_added = network_added,
+ .network_removed = network_removed,
+};
+
+static GMainLoop *main_loop = NULL;
+
+static void sig_term(int sig)
+{
+ syslog(LOG_INFO, "Terminating");
+
+ g_main_loop_quit(main_loop);
+}
+
+static void disconnect_callback(DBusConnection *conn, void *user_data)
+{
+ syslog(LOG_ERR, "D-Bus disconnect");
+
+ g_main_loop_quit(main_loop);
+}
+
+int main(int argc, char *argv[])
+{
+ DBusConnection *conn;
+ DBusError err;
+ struct sigaction sa;
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ dbus_error_init(&err);
+
+ conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, NULL, &err);
+ if (!conn) {
+ if (dbus_error_is_set(&err)) {
+ fprintf(stderr, "%s\n", err.message);
+ dbus_error_free(&err);
+ } else
+ fprintf(stderr, "Can't register with system bus\n");
+ exit(1);
+ }
+
+ openlog("supplicant", LOG_NDELAY | LOG_PERROR, LOG_USER);
+
+ g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ syslog(LOG_INFO, "Startup");
+
+ if (supplicant_register(&callbacks) < 0) {
+ syslog(LOG_ERR, "Failed to init supplicant");
+ goto done;
+ }
+
+ g_main_loop_run(main_loop);
+
+ supplicant_unregister(&callbacks);
+
+done:
+ syslog(LOG_INFO, "Exit");
+
+ dbus_connection_unref(conn);
+
+ g_main_loop_unref(main_loop);
+
+ closelog();
+
+ return 0;
+}
diff --git a/tools/supplicant.c b/tools/supplicant.c
new file mode 100644
index 0000000..e2e6fea
--- /dev/null
+++ b/tools/supplicant.c
@@ -0,0 +1,1939 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <string.h>
+#include <stdint.h>
+#include <syslog.h>
+
+#include <glib.h>
+#include <gdbus.h>
+
+#include "supplicant-dbus.h"
+#include "supplicant.h"
+
+#define DBG(fmt, arg...) do { \
+ syslog(LOG_DEBUG, "%s() " fmt, __FUNCTION__ , ## arg); \
+} while (0)
+
+#define TIMEOUT 5000
+
+#define IEEE80211_CAP_ESS 0x0001
+#define IEEE80211_CAP_IBSS 0x0002
+#define IEEE80211_CAP_PRIVACY 0x0010
+
+static DBusConnection *connection;
+
+static const struct supplicant_callbacks *callbacks_pointer;
+
+static dbus_bool_t system_available = FALSE;
+static dbus_bool_t system_ready = FALSE;
+
+static dbus_int32_t debug_level = 0;
+static dbus_bool_t debug_timestamp = FALSE;
+static dbus_bool_t debug_showkeys = FALSE;
+
+static const char *debug_strings[] = {
+ "msgdump", "debug", "info", "warning", "error", NULL
+};
+
+static unsigned int eap_methods;
+
+struct strvalmap {
+ const char *str;
+ unsigned int val;
+};
+
+static struct strvalmap eap_method_map[] = {
+ { "MD5", SUPPLICANT_EAP_METHOD_MD5 },
+ { "TLS", SUPPLICANT_EAP_METHOD_TLS },
+ { "MSCHAPV2", SUPPLICANT_EAP_METHOD_MSCHAPV2 },
+ { "PEAP", SUPPLICANT_EAP_METHOD_PEAP },
+ { "TTLS", SUPPLICANT_EAP_METHOD_TTLS },
+ { "GTC", SUPPLICANT_EAP_METHOD_GTC },
+ { "OTP", SUPPLICANT_EAP_METHOD_OTP },
+ { "LEAP", SUPPLICANT_EAP_METHOD_LEAP },
+ { "WSC", SUPPLICANT_EAP_METHOD_WSC },
+ { }
+};
+
+static struct strvalmap keymgmt_capa_map[] = {
+ { "none", SUPPLICANT_CAPABILITY_KEYMGMT_NONE },
+ { "ieee8021x", SUPPLICANT_CAPABILITY_KEYMGMT_IEEE8021X },
+ { "wpa-none", SUPPLICANT_CAPABILITY_KEYMGMT_WPA_NONE },
+ { "wpa-psk", SUPPLICANT_CAPABILITY_KEYMGMT_WPA_PSK },
+ { "wpa-eap", SUPPLICANT_CAPABILITY_KEYMGMT_WPA_EAP },
+ { "wps", SUPPLICANT_CAPABILITY_KEYMGMT_WPS },
+ { }
+};
+
+static struct strvalmap authalg_capa_map[] = {
+ { "open", SUPPLICANT_CAPABILITY_AUTHALG_OPEN },
+ { "shared", SUPPLICANT_CAPABILITY_AUTHALG_SHARED },
+ { "leap", SUPPLICANT_CAPABILITY_AUTHALG_LEAP },
+ { }
+};
+
+static struct strvalmap proto_capa_map[] = {
+ { "wpa", SUPPLICANT_CAPABILITY_PROTO_WPA },
+ { "rsn", SUPPLICANT_CAPABILITY_PROTO_RSN },
+ { }
+};
+
+static struct strvalmap group_capa_map[] = {
+ { "wep40", SUPPLICANT_CAPABILITY_GROUP_WEP40 },
+ { "wep104", SUPPLICANT_CAPABILITY_GROUP_WEP104 },
+ { "tkip", SUPPLICANT_CAPABILITY_GROUP_TKIP },
+ { "ccmp", SUPPLICANT_CAPABILITY_GROUP_CCMP },
+ { }
+};
+
+static struct strvalmap pairwise_capa_map[] = {
+ { "none", SUPPLICANT_CAPABILITY_PAIRWISE_NONE },
+ { "tkip", SUPPLICANT_CAPABILITY_PAIRWISE_TKIP },
+ { "ccmp", SUPPLICANT_CAPABILITY_PAIRWISE_CCMP },
+ { }
+};
+
+static struct strvalmap scan_capa_map[] = {
+ { "active", SUPPLICANT_CAPABILITY_SCAN_ACTIVE },
+ { "passive", SUPPLICANT_CAPABILITY_SCAN_PASSIVE },
+ { "ssid", SUPPLICANT_CAPABILITY_SCAN_SSID },
+ { }
+};
+
+static struct strvalmap mode_capa_map[] = {
+ { "infrastructure", SUPPLICANT_CAPABILITY_MODE_INFRA },
+ { "ad-hoc", SUPPLICANT_CAPABILITY_MODE_IBSS },
+ { "ap", SUPPLICANT_CAPABILITY_MODE_AP },
+ { }
+};
+
+static GHashTable *interface_table;
+static GHashTable *bss_mapping;
+
+struct supplicant_interface {
+ char *path;
+ unsigned int keymgmt_capa;
+ unsigned int authalg_capa;
+ unsigned int proto_capa;
+ unsigned int group_capa;
+ unsigned int pairwise_capa;
+ unsigned int scan_capa;
+ unsigned int mode_capa;
+ dbus_bool_t ready;
+ enum supplicant_state state;
+ dbus_bool_t scanning;
+ supplicant_interface_scan_callback scan_callback;
+ void *scan_data;
+ int apscan;
+ char *ifname;
+ char *driver;
+ char *bridge;
+ GHashTable *network_table;
+ GHashTable *net_mapping;
+ GHashTable *bss_mapping;
+};
+
+struct supplicant_network {
+ struct supplicant_interface *interface;
+ char *path;
+ char *group;
+ char *name;
+ enum supplicant_mode mode;
+ GHashTable *bss_table;
+ GHashTable *config_table;
+};
+
+struct supplicant_bss {
+ struct supplicant_interface *interface;
+ char *path;
+ unsigned char bssid[6];
+ unsigned char ssid[32];
+ unsigned int ssid_len;
+ dbus_uint16_t frequency;
+ dbus_uint32_t maxrate;
+ enum supplicant_mode mode;
+ enum supplicant_security security;
+ dbus_bool_t privacy;
+ dbus_bool_t psk;
+ dbus_bool_t ieee8021x;
+};
+
+static enum supplicant_mode string2mode(const char *mode)
+{
+ if (!mode)
+ return SUPPLICANT_MODE_UNKNOWN;
+
+ if (g_str_equal(mode, "infrastructure"))
+ return SUPPLICANT_MODE_INFRA;
+ else if (g_str_equal(mode, "ad-hoc"))
+ return SUPPLICANT_MODE_IBSS;
+
+ return SUPPLICANT_MODE_UNKNOWN;
+}
+
+static const char *mode2string(enum supplicant_mode mode)
+{
+ switch (mode) {
+ case SUPPLICANT_MODE_UNKNOWN:
+ break;
+ case SUPPLICANT_MODE_INFRA:
+ return "infra";
+ case SUPPLICANT_MODE_IBSS:
+ return "adhoc";
+ }
+
+ return NULL;
+}
+
+static const char *security2string(enum supplicant_security security)
+{
+ switch (security) {
+ case SUPPLICANT_SECURITY_UNKNOWN:
+ break;
+ case SUPPLICANT_SECURITY_NONE:
+ return "none";
+ case SUPPLICANT_SECURITY_WEP:
+ return "wep";
+ case SUPPLICANT_SECURITY_PSK:
+ return "psk";
+ case SUPPLICANT_SECURITY_IEEE8021X:
+ return "ieee8021x";
+ }
+
+ return NULL;
+}
+
+static enum supplicant_state string2state(const char *state)
+{
+ if (!state)
+ return SUPPLICANT_STATE_UNKNOWN;
+
+ if (g_str_equal(state, "unknown"))
+ return SUPPLICANT_STATE_UNKNOWN;
+ else if (g_str_equal(state, "disconnected"))
+ return SUPPLICANT_STATE_DISCONNECTED;
+ else if (g_str_equal(state, "inactive"))
+ return SUPPLICANT_STATE_INACTIVE;
+ else if (g_str_equal(state, "scanning"))
+ return SUPPLICANT_STATE_SCANNING;
+ else if (g_str_equal(state, "authenticating"))
+ return SUPPLICANT_STATE_AUTHENTICATING;
+ else if (g_str_equal(state, "associating"))
+ return SUPPLICANT_STATE_ASSOCIATING;
+ else if (g_str_equal(state, "associated"))
+ return SUPPLICANT_STATE_ASSOCIATED;
+ else if (g_str_equal(state, "group_handshake"))
+ return SUPPLICANT_STATE_GROUP_HANDSHAKE;
+ else if (g_str_equal(state, "4way_handshake"))
+ return SUPPLICANT_STATE_4WAY_HANDSHAKE;
+ else if (g_str_equal(state, "completed"))
+ return SUPPLICANT_STATE_COMPLETED;
+
+ return SUPPLICANT_STATE_UNKNOWN;
+}
+
+static void callback_system_ready(void)
+{
+ if (system_ready)
+ return;
+
+ system_ready = TRUE;
+
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->system_ready)
+ return;
+
+ callbacks_pointer->system_ready();
+}
+
+static void callback_system_killed(void)
+{
+ system_ready = FALSE;
+
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->system_killed)
+ return;
+
+ callbacks_pointer->system_killed();
+}
+
+static void callback_interface_added(struct supplicant_interface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->interface_added)
+ return;
+
+ callbacks_pointer->interface_added(interface);
+}
+
+static void callback_interface_removed(struct supplicant_interface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->interface_removed)
+ return;
+
+ callbacks_pointer->interface_removed(interface);
+}
+
+static void callback_scan_started(struct supplicant_interface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->scan_started)
+ return;
+
+ callbacks_pointer->scan_started(interface);
+}
+
+static void callback_scan_finished(struct supplicant_interface *interface)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->scan_finished)
+ return;
+
+ callbacks_pointer->scan_finished(interface);
+}
+
+static void callback_network_added(struct supplicant_network *network)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->network_added)
+ return;
+
+ callbacks_pointer->network_added(network);
+}
+
+static void callback_network_removed(struct supplicant_network *network)
+{
+ if (!callbacks_pointer)
+ return;
+
+ if (!callbacks_pointer->network_removed)
+ return;
+
+ callbacks_pointer->network_removed(network);
+}
+
+static void remove_interface(gpointer data)
+{
+ struct supplicant_interface *interface = data;
+
+ g_hash_table_destroy(interface->bss_mapping);
+ g_hash_table_destroy(interface->net_mapping);
+ g_hash_table_destroy(interface->network_table);
+
+ callback_interface_removed(interface);
+
+ g_free(interface->path);
+ g_free(interface->ifname);
+ g_free(interface->driver);
+ g_free(interface->bridge);
+ g_free(interface);
+}
+
+static void remove_network(gpointer data)
+{
+ struct supplicant_network *network = data;
+
+ g_hash_table_destroy(network->bss_table);
+
+ callback_network_removed(network);
+
+ g_hash_table_destroy(network->config_table);
+
+ g_free(network->group);
+ g_free(network->name);
+ g_free(network);
+}
+
+static void remove_bss(gpointer data)
+{
+ struct supplicant_bss *bss = data;
+
+ g_free(bss->path);
+ g_free(bss);
+}
+
+static void debug_strvalmap(const char *label, struct strvalmap *map,
+ unsigned int val)
+{
+ int i;
+
+ for (i = 0; map[i].str; i++) {
+ if (val & map[i].val)
+ DBG("%s: %s", label, map[i].str);
+ }
+}
+
+static void interface_capability_keymgmt(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; keymgmt_capa_map[i].str; i++)
+ if (strcmp(str, keymgmt_capa_map[i].str) == 0) {
+ interface->keymgmt_capa |= keymgmt_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_authalg(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; authalg_capa_map[i].str; i++)
+ if (strcmp(str, authalg_capa_map[i].str) == 0) {
+ interface->authalg_capa |= authalg_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_proto(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; proto_capa_map[i].str; i++)
+ if (strcmp(str, proto_capa_map[i].str) == 0) {
+ interface->proto_capa |= proto_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_pairwise(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; pairwise_capa_map[i].str; i++)
+ if (strcmp(str, pairwise_capa_map[i].str) == 0) {
+ interface->pairwise_capa |= pairwise_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_group(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; group_capa_map[i].str; i++)
+ if (strcmp(str, group_capa_map[i].str) == 0) {
+ interface->group_capa |= group_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_scan(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; scan_capa_map[i].str; i++)
+ if (strcmp(str, scan_capa_map[i].str) == 0) {
+ interface->scan_capa |= scan_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability_mode(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; mode_capa_map[i].str; i++)
+ if (strcmp(str, mode_capa_map[i].str) == 0) {
+ interface->mode_capa |= mode_capa_map[i].val;
+ break;
+ }
+}
+
+static void interface_capability(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+
+ if (!key)
+ return;
+
+ if (g_strcmp0(key, "KeyMgmt") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_keymgmt, interface);
+ else if (g_strcmp0(key, "AuthAlg") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_authalg, interface);
+ else if (g_strcmp0(key, "Protocol") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_proto, interface);
+ else if (g_strcmp0(key, "Pairwise") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_pairwise, interface);
+ else if (g_strcmp0(key, "Group") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_group, interface);
+ else if (g_strcmp0(key, "Scan") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_scan, interface);
+ else if (g_strcmp0(key, "Modes") == 0)
+ supplicant_dbus_array_foreach(iter,
+ interface_capability_mode, interface);
+ else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+const char *supplicant_interface_get_ifname(struct supplicant_interface *interface)
+{
+ if (!interface)
+ return NULL;
+
+ return interface->ifname;
+}
+
+const char *supplicant_interface_get_driver(struct supplicant_interface *interface)
+{
+ if (!interface)
+ return NULL;
+
+ return interface->driver;
+}
+
+struct supplicant_interface *supplicant_network_get_interface(struct supplicant_network *network)
+{
+ if (!network)
+ return NULL;
+
+ return network->interface;
+}
+
+const char *supplicant_network_get_name(struct supplicant_network *network)
+{
+ if (!network || !network->name)
+ return "";
+
+ return network->name;
+}
+
+const char *supplicant_network_get_identifier(struct supplicant_network *network)
+{
+ if (!network || !network->group)
+ return "";
+
+ return network->group;
+}
+
+enum supplicant_mode supplicant_network_get_mode(struct supplicant_network *network)
+{
+ if (!network)
+ return SUPPLICANT_MODE_UNKNOWN;
+
+ return network->mode;
+}
+
+static void merge_network(struct supplicant_network *network)
+{
+ GString *str;
+ const char *ssid, *mode, *key_mgmt;
+ unsigned int i, ssid_len;
+ char *group;
+
+ ssid = g_hash_table_lookup(network->config_table, "ssid");
+ mode = g_hash_table_lookup(network->config_table, "mode");
+ key_mgmt = g_hash_table_lookup(network->config_table, "key_mgmt");
+
+ DBG("ssid %s mode %s", ssid, mode);
+
+ if (ssid)
+ ssid_len = strlen(ssid);
+ else
+ ssid_len = 0;
+
+ str = g_string_sized_new((ssid_len * 2) + 24);
+ if (!str)
+ return;
+
+ for (i = 0; i < ssid_len; i++)
+ g_string_append_printf(str, "%02x", ssid[i]);
+
+ if (g_strcmp0(mode, "0") == 0)
+ g_string_append_printf(str, "_infra");
+ else if (g_strcmp0(mode, "1") == 0)
+ g_string_append_printf(str, "_adhoc");
+
+ if (g_strcmp0(key_mgmt, "WPA-PSK") == 0)
+ g_string_append_printf(str, "_psk");
+
+ group = g_string_free(str, FALSE);
+
+ DBG("%s", group);
+
+ g_free(group);
+
+ g_hash_table_destroy(network->config_table);
+
+ g_free(network->path);
+ g_free(network);
+}
+
+static void network_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_network *network = user_data;
+
+ if (!network->interface)
+ return;
+
+ if (!key) {
+ merge_network(network);
+ return;
+ }
+
+ if (g_strcmp0(key, "Enabled") == 0) {
+ dbus_bool_t enabled = FALSE;
+
+ dbus_message_iter_get_basic(iter, &enabled);
+ } else if (dbus_message_iter_get_arg_type(iter) == DBUS_TYPE_STRING) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ g_hash_table_replace(network->config_table,
+ g_strdup(key), g_strdup(str));
+ } else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static void interface_network_added(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ struct supplicant_network *network;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ if (g_strcmp0(path, "/") == 0)
+ return;
+
+ network = g_hash_table_lookup(interface->net_mapping, path);
+ if (network)
+ return;
+
+ network = g_try_new0(struct supplicant_network, 1);
+ if (!network)
+ return;
+
+ network->interface = interface;
+ network->path = g_strdup(path);
+
+ network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ supplicant_dbus_property_foreach(iter, network_property,
+ network);
+ network_property(NULL, NULL, network);
+ return;
+ }
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface.Network",
+ network_property, network);
+}
+
+static void interface_network_removed(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ struct supplicant_network *network;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ network = g_hash_table_lookup(interface->net_mapping, path);
+ if (!network)
+ return;
+
+ g_hash_table_remove(interface->net_mapping, path);
+}
+
+static char *create_name(unsigned char *ssid, int ssid_len)
+{
+ char *name;
+ int i;
+
+ if (ssid_len < 1 || ssid[0] == '\0')
+ name = NULL;
+ else
+ name = g_try_malloc0(ssid_len + 1);
+
+ if (!name)
+ return g_strdup("");
+
+ for (i = 0; i < ssid_len; i++) {
+ if (g_ascii_isprint(ssid[i]))
+ name[i] = ssid[i];
+ else
+ name[i] = ' ';
+ }
+
+ return name;
+}
+
+static char *create_group(struct supplicant_bss *bss)
+{
+ GString *str;
+ unsigned int i;
+ const char *mode, *security;
+
+ str = g_string_sized_new((bss->ssid_len * 2) + 24);
+ if (!str)
+ return NULL;
+
+ if (bss->ssid_len > 0 && bss->ssid[0] != '\0') {
+ for (i = 0; i < bss->ssid_len; i++)
+ g_string_append_printf(str, "%02x", bss->ssid[i]);
+ } else
+ g_string_append_printf(str, "hidden");
+
+ mode = mode2string(bss->mode);
+ if (mode)
+ g_string_append_printf(str, "_%s", mode);
+
+ security = security2string(bss->security);
+ if (security)
+ g_string_append_printf(str, "_%s", security);
+
+ return g_string_free(str, FALSE);
+}
+
+static void add_bss_to_network(struct supplicant_bss *bss)
+{
+ struct supplicant_interface *interface = bss->interface;
+ struct supplicant_network *network;
+ char *group;
+
+ group = create_group(bss);
+ if (!group)
+ return;
+
+ network = g_hash_table_lookup(interface->network_table, group);
+ if (network) {
+ g_free(group);
+ goto done;
+ }
+
+ network = g_try_new0(struct supplicant_network, 1);
+ if (!network) {
+ g_free(group);
+ return;
+ }
+
+ network->group = group;
+ network->name = create_name(bss->ssid, bss->ssid_len);
+ network->mode = bss->mode;
+
+ network->bss_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_bss);
+
+ network->config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, g_free);
+
+ g_hash_table_replace(interface->network_table,
+ network->group, network);
+
+ callback_network_added(network);
+
+done:
+ g_hash_table_replace(interface->bss_mapping, bss->path, network);
+ g_hash_table_replace(network->bss_table, bss->path, bss);
+
+ g_hash_table_replace(bss_mapping, bss->path, interface);
+}
+
+static unsigned char wifi_oui[3] = { 0x00, 0x50, 0xf2 };
+static unsigned char ieee80211_oui[3] = { 0x00, 0x0f, 0xac };
+
+static void extract_rsn(struct supplicant_bss *bss,
+ const unsigned char *buf, int len)
+{
+ uint16_t count;
+ int i;
+
+ /* Version */
+ if (len < 2)
+ return;
+
+ buf += 2;
+ len -= 2;
+
+ /* Group cipher */
+ if (len < 4)
+ return;
+
+ buf += 4;
+ len -= 4;
+
+ /* Pairwise cipher */
+ if (len < 2)
+ return;
+
+ count = buf[0] | (buf[1] << 8);
+ if (2 + (count * 4) > len)
+ return;
+
+ buf += 2 + (count * 4);
+ len -= 2 + (count * 4);
+
+ /* Authentication */
+ if (len < 2)
+ return;
+
+ count = buf[0] | (buf[1] << 8);
+ if (2 + (count * 4) > len)
+ return;
+
+ for (i = 0; i < count; i++) {
+ const unsigned char *ptr = buf + 2 + (i * 4);
+
+ if (memcmp(ptr, wifi_oui, 3) == 0) {
+ switch (ptr[3]) {
+ case 1:
+ bss->ieee8021x = TRUE;
+ break;
+ case 2:
+ bss->psk = TRUE;
+ break;
+ }
+ } else if (memcmp(ptr, ieee80211_oui, 3) == 0) {
+ switch (ptr[3]) {
+ case 1:
+ bss->ieee8021x = TRUE;
+ break;
+ case 2:
+ bss->psk = TRUE;
+ break;
+ }
+ }
+ }
+
+}
+
+static void bss_rates(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_bss *bss = user_data;
+ dbus_uint32_t rate = 0;
+
+ dbus_message_iter_get_basic(iter, &rate);
+ if (rate == 0)
+ return;
+
+ if (rate > bss->maxrate)
+ bss->maxrate = rate;
+}
+
+static void bss_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_bss *bss = user_data;
+
+ if (!bss->interface)
+ return;
+
+ if (!key) {
+ if (bss->ieee8021x)
+ bss->security = SUPPLICANT_SECURITY_IEEE8021X;
+ else if (bss->psk)
+ bss->security = SUPPLICANT_SECURITY_PSK;
+ else if (bss->privacy)
+ bss->security = SUPPLICANT_SECURITY_WEP;
+ else
+ bss->security = SUPPLICANT_SECURITY_NONE;
+
+ add_bss_to_network(bss);
+ return;
+ }
+
+ if (g_strcmp0(key, "BSSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *addr;
+ int addr_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &addr, &addr_len);
+
+ if (addr_len == 6)
+ memcpy(bss->bssid, addr, addr_len);
+ } else if (g_strcmp0(key, "SSID") == 0) {
+ DBusMessageIter array;
+ unsigned char *ssid;
+ int ssid_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ssid, &ssid_len);
+
+ if (ssid_len > 0 && ssid_len < 33) {
+ memcpy(bss->ssid, ssid, ssid_len);
+ bss->ssid_len = ssid_len;
+ } else {
+ memset(bss->ssid, 0, sizeof(bss->ssid));
+ bss->ssid_len = 0;
+ }
+ } else if (g_strcmp0(key, "Capabilities") == 0) {
+ dbus_uint16_t capabilities = 0x0000;
+
+ dbus_message_iter_get_basic(iter, &capabilities);
+
+ if (capabilities & IEEE80211_CAP_ESS)
+ bss->mode = SUPPLICANT_MODE_INFRA;
+ else if (capabilities & IEEE80211_CAP_IBSS)
+ bss->mode = SUPPLICANT_MODE_IBSS;
+
+ if (capabilities & IEEE80211_CAP_PRIVACY)
+ bss->privacy = TRUE;
+ } else if (g_strcmp0(key, "Mode") == 0) {
+ const char *mode = NULL;
+
+ dbus_message_iter_get_basic(iter, &mode);
+ bss->mode = string2mode(mode);
+ } else if (g_strcmp0(key, "Frequency") == 0) {
+ dbus_uint16_t frequency = 0;
+
+ dbus_message_iter_get_basic(iter, &frequency);
+ bss->frequency = frequency;
+ } else if (g_strcmp0(key, "Signal") == 0) {
+ dbus_int16_t signal = 0;
+
+ dbus_message_iter_get_basic(iter, &signal);
+ } else if (g_strcmp0(key, "Level") == 0) {
+ dbus_int32_t level = 0;
+
+ dbus_message_iter_get_basic(iter, &level);
+ } else if (g_strcmp0(key, "Rates") == 0) {
+ supplicant_dbus_array_foreach(iter, bss_rates, bss);
+ } else if (g_strcmp0(key, "MaxRate") == 0) {
+ dbus_uint32_t maxrate = 0;
+
+ dbus_message_iter_get_basic(iter, &maxrate);
+ if (maxrate != 0)
+ bss->maxrate =maxrate;
+ } else if (g_strcmp0(key, "Privacy") == 0) {
+ dbus_bool_t privacy = FALSE;
+
+ dbus_message_iter_get_basic(iter, &privacy);
+ bss->privacy = privacy;
+ } else if (g_strcmp0(key, "RSNIE") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+
+ if (ie_len > 2)
+ extract_rsn(bss, ie + 2, ie_len - 2);
+ } else if (g_strcmp0(key, "WPAIE") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+
+ if (ie_len > 6)
+ extract_rsn(bss, ie + 6, ie_len - 6);
+ } else if (g_strcmp0(key, "WPSIE") == 0) {
+ DBusMessageIter array;
+ unsigned char *ie;
+ int ie_len;
+
+ dbus_message_iter_recurse(iter, &array);
+ dbus_message_iter_get_fixed_array(&array, &ie, &ie_len);
+ } else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static void interface_bss_added(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ struct supplicant_network *network;
+ struct supplicant_bss *bss;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ if (g_strcmp0(path, "/") == 0)
+ return;
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (network) {
+ bss = g_hash_table_lookup(network->bss_table, path);
+ if (bss)
+ return;
+ }
+
+ bss = g_try_new0(struct supplicant_bss, 1);
+ if (!bss)
+ return;
+
+ bss->interface = interface;
+ bss->path = g_strdup(path);
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ supplicant_dbus_property_foreach(iter, bss_property, bss);
+ bss_property(NULL, NULL, bss);
+ return;
+ }
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface.BSS",
+ bss_property, bss);
+}
+
+static void interface_bss_removed(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+ struct supplicant_network *network;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (!network)
+ return;
+
+ g_hash_table_remove(bss_mapping, path);
+
+ g_hash_table_remove(interface->bss_mapping, path);
+ g_hash_table_remove(network->bss_table, path);
+
+ if (g_hash_table_size(network->bss_table) == 0)
+ g_hash_table_remove(interface->network_table, network->group);
+}
+
+static void interface_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct supplicant_interface *interface = user_data;
+
+ if (!interface)
+ return;
+
+ if (!key) {
+ debug_strvalmap("KeyMgmt capability", keymgmt_capa_map,
+ interface->keymgmt_capa);
+ debug_strvalmap("AuthAlg capability", authalg_capa_map,
+ interface->authalg_capa);
+ debug_strvalmap("Protocol capability", proto_capa_map,
+ interface->proto_capa);
+ debug_strvalmap("Pairwise capability", pairwise_capa_map,
+ interface->pairwise_capa);
+ debug_strvalmap("Group capability", group_capa_map,
+ interface->group_capa);
+ debug_strvalmap("Scan capability", scan_capa_map,
+ interface->scan_capa);
+ debug_strvalmap("Mode capability", mode_capa_map,
+ interface->mode_capa);
+
+ interface->ready = TRUE;
+ callback_interface_added(interface);
+ return;
+ }
+
+ if (g_strcmp0(key, "Capabilities") == 0) {
+ supplicant_dbus_property_foreach(iter, interface_capability,
+ interface);
+ } else if (g_strcmp0(key, "State") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ interface->state = string2state(str);
+
+ DBG("state %s (%d)", str, interface->state);
+ } else if (g_strcmp0(key, "Scanning") == 0) {
+ dbus_bool_t scanning = FALSE;
+
+ dbus_message_iter_get_basic(iter, &scanning);
+ interface->scanning = scanning;
+
+ if (interface->ready) {
+ if (interface->scanning)
+ callback_scan_started(interface);
+ else
+ callback_scan_finished(interface);
+ }
+ } else if (g_strcmp0(key, "ApScan") == 0) {
+ int apscan = 1;
+
+ dbus_message_iter_get_basic(iter, &apscan);
+ interface->apscan = apscan;
+ } else if (g_strcmp0(key, "Ifname") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ interface->ifname = g_strdup(str);
+ } else if (g_strcmp0(key, "Driver") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ interface->driver = g_strdup(str);
+ } else if (g_strcmp0(key, "BridgeIfname") == 0) {
+ const char *str = NULL;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (str)
+ interface->bridge = g_strdup(str);
+ } else if (g_strcmp0(key, "CurrentBSS") == 0) {
+ interface_bss_added(iter, interface);
+ } else if (g_strcmp0(key, "CurrentNetwork") == 0) {
+ interface_network_added(iter, interface);
+ } else if (g_strcmp0(key, "BSSs") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_bss_added,
+ interface);
+ } else if (g_strcmp0(key, "Blobs") == 0) {
+ } else if (g_strcmp0(key, "Networks") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_network_added,
+ interface);
+ } else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static struct supplicant_interface *interface_alloc(const char *path)
+{
+ struct supplicant_interface *interface;
+
+ interface = g_try_new0(struct supplicant_interface, 1);
+ if (!interface)
+ return NULL;
+
+ interface->path = g_strdup(path);
+
+ interface->network_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_network);
+
+ interface->net_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+ interface->bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ g_hash_table_replace(interface_table, interface->path, interface);
+
+ return interface;
+}
+
+static void interface_added(DBusMessageIter *iter, void *user_data)
+{
+ struct supplicant_interface *interface;
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ if (g_strcmp0(path, "/") == 0)
+ return;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (interface)
+ return;
+
+ interface = interface_alloc(path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_next(iter);
+ if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INVALID) {
+ supplicant_dbus_property_foreach(iter, interface_property,
+ interface);
+ interface_property(NULL, NULL, interface);
+ return;
+ }
+
+ supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface",
+ interface_property, interface);
+}
+
+static void interface_removed(DBusMessageIter *iter, void *user_data)
+{
+ const char *path = NULL;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path)
+ return;
+
+ g_hash_table_remove(interface_table, path);
+}
+
+static void eap_method(DBusMessageIter *iter, void *user_data)
+{
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ if (!str)
+ return;
+
+ for (i = 0; eap_method_map[i].str; i++)
+ if (strcmp(str, eap_method_map[i].str) == 0) {
+ eap_methods |= eap_method_map[i].val;
+ break;
+ }
+}
+
+static void service_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ if (!key) {
+ callback_system_ready();
+ return;
+ }
+
+ if (g_strcmp0(key, "DebugLevel") == 0) {
+ const char *str = NULL;
+ int i;
+
+ dbus_message_iter_get_basic(iter, &str);
+ for (i = 0; debug_strings[i]; i++)
+ if (g_strcmp0(debug_strings[i], str) == 0) {
+ debug_level = i;
+ break;
+ }
+ DBG("Debug level %d", debug_level);
+ } else if (g_strcmp0(key, "DebugTimestamp") == 0) {
+ dbus_message_iter_get_basic(iter, &debug_timestamp);
+ DBG("Debug timestamp %u", debug_timestamp);
+ } else if (g_strcmp0(key, "DebugShowKeys") == 0) {
+ dbus_message_iter_get_basic(iter, &debug_showkeys);
+ DBG("Debug show keys %u", debug_showkeys);
+ } else if (g_strcmp0(key, "Interfaces") == 0) {
+ supplicant_dbus_array_foreach(iter, interface_added, NULL);
+ } else if (g_strcmp0(key, "EapMethods") == 0) {
+ supplicant_dbus_array_foreach(iter, eap_method, NULL);
+ debug_strvalmap("EAP method", eap_method_map, eap_methods);
+ } else
+ DBG("key %s type %c",
+ key, dbus_message_iter_get_arg_type(iter));
+}
+
+static void supplicant_bootstrap(void)
+{
+ supplicant_dbus_property_get_all(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ service_property, NULL);
+}
+
+static void signal_name_owner_changed(const char *path, DBusMessageIter *iter)
+{
+ const char *name = NULL, *old = NULL, *new = NULL;
+
+ if (g_strcmp0(path, DBUS_PATH_DBUS) != 0)
+ return;
+
+ dbus_message_iter_get_basic(iter, &name);
+ if (!name)
+ return;
+
+ if (g_strcmp0(name, SUPPLICANT_SERVICE) != 0)
+ return;
+
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &old);
+ dbus_message_iter_next(iter);
+ dbus_message_iter_get_basic(iter, &new);
+
+ if (!old || !new)
+ return;
+
+ if (strlen(old) > 0 && strlen(new) == 0) {
+ system_available = FALSE;
+ g_hash_table_remove_all(bss_mapping);
+ g_hash_table_remove_all(interface_table);
+ callback_system_killed();
+ }
+
+ if (strlen(new) > 0 && strlen(old) == 0) {
+ system_available = TRUE;
+ supplicant_bootstrap();
+ }
+}
+
+static void signal_properties_changed(const char *path, DBusMessageIter *iter)
+{
+ if (g_strcmp0(path, SUPPLICANT_PATH) != 0)
+ return;
+
+ supplicant_dbus_property_foreach(iter, service_property, NULL);
+}
+
+static void signal_interface_added(const char *path, DBusMessageIter *iter)
+{
+ if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
+ interface_added(iter, NULL);
+}
+
+static void signal_interface_removed(const char *path, DBusMessageIter *iter)
+{
+ if (g_strcmp0(path, SUPPLICANT_PATH) == 0)
+ interface_removed(iter, NULL);
+}
+
+static void signal_interface_changed(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ supplicant_dbus_property_foreach(iter, interface_property, interface);
+}
+
+static void signal_scan_done(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+ dbus_bool_t success = FALSE;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ dbus_message_iter_get_basic(iter, &success);
+
+ if (interface->scan_callback) {
+ int result = 0;
+
+ if (!success)
+ result = -EIO;
+
+ interface->scan_callback(result, interface->scan_data);
+ }
+
+ interface->scan_callback = NULL;
+ interface->scan_data = NULL;
+}
+
+static void signal_bss_added(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_bss_added(iter, interface);
+}
+
+static void signal_bss_removed(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_bss_removed(iter, interface);
+}
+
+static void signal_network_added(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_network_added(iter, interface);
+}
+
+static void signal_network_removed(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface)
+ return;
+
+ interface_network_removed(iter, interface);
+}
+
+static void signal_bss_changed(const char *path, DBusMessageIter *iter)
+{
+ struct supplicant_interface *interface;
+ struct supplicant_network *network;
+ struct supplicant_bss *bss;
+
+ interface = g_hash_table_lookup(bss_mapping, path);
+ if (!interface)
+ return;
+
+ network = g_hash_table_lookup(interface->bss_mapping, path);
+ if (!network)
+ return;
+
+ bss = g_hash_table_lookup(network->bss_table, path);
+ if (!bss)
+ return;
+
+ supplicant_dbus_property_foreach(iter, bss_property, bss);
+}
+
+static struct {
+ const char *interface;
+ const char *member;
+ void (*function) (const char *path, DBusMessageIter *iter);
+} signal_map[] = {
+ { DBUS_INTERFACE_DBUS, "NameOwnerChanged", signal_name_owner_changed },
+
+ { SUPPLICANT_INTERFACE, "PropertiesChanged", signal_properties_changed },
+ { SUPPLICANT_INTERFACE, "InterfaceAdded", signal_interface_added },
+ { SUPPLICANT_INTERFACE, "InterfaceCreated", signal_interface_added },
+ { SUPPLICANT_INTERFACE, "InterfaceRemoved", signal_interface_removed },
+
+ { SUPPLICANT_INTERFACE ".Interface", "PropertiesChanged", signal_interface_changed },
+ { SUPPLICANT_INTERFACE ".Interface", "ScanDone", signal_scan_done },
+ { SUPPLICANT_INTERFACE ".Interface", "BSSAdded", signal_bss_added },
+ { SUPPLICANT_INTERFACE ".Interface", "BSSRemoved", signal_bss_removed },
+ { SUPPLICANT_INTERFACE ".Interface", "NetworkAdded", signal_network_added },
+ { SUPPLICANT_INTERFACE ".Interface", "NetworkRemoved", signal_network_removed },
+
+ { SUPPLICANT_INTERFACE ".Interface.BSS", "PropertiesChanged", signal_bss_changed },
+
+ { }
+};
+
+static DBusHandlerResult supplicant_filter(DBusConnection *conn,
+ DBusMessage *message, void *data)
+{
+ DBusMessageIter iter;
+ const char *path;
+ int i;
+
+ path = dbus_message_get_path(message);
+ if (!path)
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ if (!dbus_message_iter_init(message, &iter))
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+
+ for (i = 0; signal_map[i].interface; i++) {
+ if (!dbus_message_has_interface(message, signal_map[i].interface))
+ continue;
+
+ if (!dbus_message_has_member(message, signal_map[i].member))
+ continue;
+
+ signal_map[i].function(path, &iter);
+ break;
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+static const char *supplicant_rule0 = "type=signal,"
+ "path=" DBUS_PATH_DBUS ","
+ "sender=" DBUS_SERVICE_DBUS ","
+ "interface=" DBUS_INTERFACE_DBUS ","
+ "member=NameOwnerChanged,"
+ "arg0=" SUPPLICANT_SERVICE;
+static const char *supplicant_rule1 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE;
+static const char *supplicant_rule2 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface";
+static const char *supplicant_rule3 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface.WPS";
+static const char *supplicant_rule4 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface.BSS";
+static const char *supplicant_rule5 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface.Network";
+static const char *supplicant_rule6 = "type=signal,"
+ "interface=" SUPPLICANT_INTERFACE ".Interface.Blob";
+
+int supplicant_register(const struct supplicant_callbacks *callbacks)
+{
+ connection = dbus_bus_get(DBUS_BUS_SYSTEM, NULL);
+ if (!connection)
+ return -EIO;
+
+ if (!dbus_connection_add_filter(connection, supplicant_filter, NULL, NULL)) {
+ dbus_connection_unref(connection);
+ connection = NULL;
+ return -EIO;
+ }
+
+ callbacks_pointer = callbacks;
+ eap_methods = 0;
+
+ interface_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, remove_interface);
+
+ bss_mapping = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, NULL);
+
+ supplicant_dbus_setup(connection);
+
+ dbus_bus_add_match(connection, supplicant_rule0, NULL);
+ dbus_bus_add_match(connection, supplicant_rule1, NULL);
+ dbus_bus_add_match(connection, supplicant_rule2, NULL);
+ dbus_bus_add_match(connection, supplicant_rule3, NULL);
+ dbus_bus_add_match(connection, supplicant_rule4, NULL);
+ dbus_bus_add_match(connection, supplicant_rule5, NULL);
+ dbus_bus_add_match(connection, supplicant_rule6, NULL);
+ dbus_connection_flush(connection);
+
+ if (dbus_bus_name_has_owner(connection,
+ SUPPLICANT_SERVICE, NULL)) {
+ system_available = TRUE;
+ supplicant_bootstrap();
+ }
+
+ return 0;
+}
+
+void supplicant_unregister(const struct supplicant_callbacks *callbacks)
+{
+ if (connection) {
+ dbus_bus_remove_match(connection, supplicant_rule6, NULL);
+ dbus_bus_remove_match(connection, supplicant_rule5, NULL);
+ dbus_bus_remove_match(connection, supplicant_rule4, NULL);
+ dbus_bus_remove_match(connection, supplicant_rule3, NULL);
+ dbus_bus_remove_match(connection, supplicant_rule2, NULL);
+ dbus_bus_remove_match(connection, supplicant_rule1, NULL);
+ dbus_bus_remove_match(connection, supplicant_rule0, NULL);
+ dbus_connection_flush(connection);
+
+ dbus_connection_remove_filter(connection,
+ supplicant_filter, NULL);
+ }
+
+ if (bss_mapping) {
+ g_hash_table_destroy(bss_mapping);
+ bss_mapping = NULL;
+ }
+
+ if (interface_table) {
+ g_hash_table_destroy(interface_table);
+ interface_table = NULL;
+ }
+
+ if (system_available)
+ callback_system_killed();
+
+ if (connection) {
+ dbus_connection_unref(connection);
+ connection = NULL;
+ }
+
+ callbacks_pointer = NULL;
+ eap_methods = 0;
+}
+
+static void debug_level_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ if (error)
+ DBG("debug level failure: %s", error);
+}
+
+static void debug_level_params(DBusMessageIter *iter, void *user_data)
+{
+ guint level = GPOINTER_TO_UINT(user_data);
+ const char *str;
+
+ if (level > 4)
+ level = 4;
+
+ str = debug_strings[level];
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &str);
+}
+
+void supplicant_set_debug_level(unsigned int level)
+{
+ if (!system_available)
+ return;
+
+ supplicant_dbus_property_set(SUPPLICANT_PATH, SUPPLICANT_INTERFACE,
+ "DebugLevel", DBUS_TYPE_STRING_AS_STRING,
+ debug_level_params, debug_level_result,
+ GUINT_TO_POINTER(level));
+}
+
+struct interface_create_data {
+ const char *ifname;
+ const char *driver;
+ struct supplicant_interface *interface;
+ supplicant_interface_create_callback callback;
+ void *user_data;
+};
+
+static void interface_create_property(const char *key, DBusMessageIter *iter,
+ void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ struct supplicant_interface *interface = data->interface;
+
+ if (!key) {
+ if (data->callback)
+ data->callback(0, data->interface, data->user_data);
+
+ dbus_free(data);
+ }
+
+ interface_property(key, iter, interface);
+}
+
+static void interface_create_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ const char *path = NULL;
+ int err;
+
+ if (error) {
+ err = -EIO;
+ goto done;
+ }
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ if (!system_available) {
+ err = -EFAULT;
+ goto done;
+ }
+
+ data->interface = g_hash_table_lookup(interface_table, path);
+ if (!data->interface) {
+ data->interface = interface_alloc(path);
+ if (!data->interface) {
+ err = -ENOMEM;
+ goto done;
+ }
+ }
+
+ err = supplicant_dbus_property_get_all(path,
+ SUPPLICANT_INTERFACE ".Interface",
+ interface_create_property, data);
+ if (err == 0)
+ return;
+
+done:
+ if (data->callback)
+ data->callback(err, NULL, data->user_data);
+
+ dbus_free(data);
+}
+
+static void interface_create_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ DBusMessageIter dict;
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ supplicant_dbus_dict_append_basic(&dict, "Ifname",
+ DBUS_TYPE_STRING, &data->ifname);
+
+ if (data->driver)
+ supplicant_dbus_dict_append_basic(&dict, "Driver",
+ DBUS_TYPE_STRING, &data->driver);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+static void interface_get_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+ struct supplicant_interface *interface;
+ const char *path = NULL;
+ int err;
+
+ if (error)
+ goto create;
+
+ dbus_message_iter_get_basic(iter, &path);
+ if (!path) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ interface = g_hash_table_lookup(interface_table, path);
+ if (!interface) {
+ err = -ENOENT;
+ goto done;
+ }
+
+ if (data->callback)
+ data->callback(0, interface, data->user_data);
+
+ dbus_free(data);
+
+ return;
+
+create:
+ if (!system_available) {
+ err = -EFAULT;
+ goto done;
+ }
+
+ err = supplicant_dbus_method_call(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ "CreateInterface",
+ interface_create_params,
+ interface_create_result, data);
+ if (err == 0)
+ return;
+
+done:
+ if (data->callback)
+ data->callback(err, NULL, data->user_data);
+
+ dbus_free(data);
+}
+
+static void interface_get_params(DBusMessageIter *iter, void *user_data)
+{
+ struct interface_create_data *data = user_data;
+
+ dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &data->ifname);
+}
+
+int supplicant_interface_create(const char *ifname, const char *driver,
+ supplicant_interface_create_callback callback,
+ void *user_data)
+{
+ struct interface_create_data *data;
+
+ if (!ifname)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->ifname = ifname;
+ data->driver = driver;
+ data->callback = callback;
+ data->user_data = user_data;
+
+ return supplicant_dbus_method_call(SUPPLICANT_PATH,
+ SUPPLICANT_INTERFACE,
+ "GetInterface",
+ interface_get_params,
+ interface_get_result, data);
+}
+
+int supplicant_interface_remove(struct supplicant_interface *interface,
+ supplicant_interface_remove_callback callback,
+ void *user_data)
+{
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ return 0;
+}
+
+struct interface_scan_data {
+ struct supplicant_interface *interface;
+ supplicant_interface_scan_callback callback;
+ void *user_data;
+};
+
+static void interface_scan_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_scan_data *data = user_data;
+
+ if (error) {
+ if (data->callback)
+ data->callback(-EIO, data->user_data);
+ } else {
+ data->interface->scan_callback = data->callback;
+ data->interface->scan_data = data->user_data;
+ }
+
+ dbus_free(data);
+}
+
+static void interface_scan_params(DBusMessageIter *iter, void *user_data)
+{
+ DBusMessageIter dict;
+ const char *type = "passive";
+
+ supplicant_dbus_dict_open(iter, &dict);
+
+ supplicant_dbus_dict_append_basic(&dict, "Type",
+ DBUS_TYPE_STRING, &type);
+
+ supplicant_dbus_dict_close(iter, &dict);
+}
+
+int supplicant_interface_scan(struct supplicant_interface *interface,
+ supplicant_interface_scan_callback callback,
+ void *user_data)
+{
+ struct interface_scan_data *data;
+
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ if (interface->scanning)
+ return -EALREADY;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->interface = interface;
+ data->callback = callback;
+ data->user_data = user_data;
+
+ return supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "Scan",
+ interface_scan_params, interface_scan_result, data);
+}
+
+struct interface_disconnect_data {
+ supplicant_interface_disconnect_callback callback;
+ void *user_data;
+};
+
+static void interface_disconnect_result(const char *error,
+ DBusMessageIter *iter, void *user_data)
+{
+ struct interface_disconnect_data *data = user_data;
+ int result = 0;
+
+ if (error)
+ result = -EIO;
+
+ if (data->callback)
+ data->callback(result, data->user_data);
+
+ dbus_free(data);
+}
+
+int supplicant_interface_disconnect(struct supplicant_interface *interface,
+ supplicant_interface_disconnect_callback callback,
+ void *user_data)
+{
+ struct interface_disconnect_data *data;
+
+ if (!interface)
+ return -EINVAL;
+
+ if (!system_available)
+ return -EFAULT;
+
+ data = dbus_malloc0(sizeof(*data));
+ if (!data)
+ return -ENOMEM;
+
+ data->callback = callback;
+ data->user_data = user_data;
+
+ return supplicant_dbus_method_call(interface->path,
+ SUPPLICANT_INTERFACE ".Interface", "Disconnect",
+ NULL, interface_disconnect_result, data);
+}
diff --git a/tools/supplicant.h b/tools/supplicant.h
new file mode 100644
index 0000000..556dc7d
--- /dev/null
+++ b/tools/supplicant.h
@@ -0,0 +1,139 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#define SUPPLICANT_EAP_METHOD_MD5 (1 << 0)
+#define SUPPLICANT_EAP_METHOD_TLS (1 << 1)
+#define SUPPLICANT_EAP_METHOD_MSCHAPV2 (1 << 2)
+#define SUPPLICANT_EAP_METHOD_PEAP (1 << 3)
+#define SUPPLICANT_EAP_METHOD_TTLS (1 << 4)
+#define SUPPLICANT_EAP_METHOD_GTC (1 << 5)
+#define SUPPLICANT_EAP_METHOD_OTP (1 << 6)
+#define SUPPLICANT_EAP_METHOD_LEAP (1 << 7)
+#define SUPPLICANT_EAP_METHOD_WSC (1 << 8)
+
+#define SUPPLICANT_CAPABILITY_KEYMGMT_NONE (1 << 0)
+#define SUPPLICANT_CAPABILITY_KEYMGMT_IEEE8021X (1 << 1)
+#define SUPPLICANT_CAPABILITY_KEYMGMT_WPA_NONE (1 << 2)
+#define SUPPLICANT_CAPABILITY_KEYMGMT_WPA_PSK (1 << 3)
+#define SUPPLICANT_CAPABILITY_KEYMGMT_WPA_EAP (1 << 4)
+#define SUPPLICANT_CAPABILITY_KEYMGMT_WPS (1 << 5)
+
+#define SUPPLICANT_CAPABILITY_AUTHALG_OPEN (1 << 0)
+#define SUPPLICANT_CAPABILITY_AUTHALG_SHARED (1 << 1)
+#define SUPPLICANT_CAPABILITY_AUTHALG_LEAP (1 << 2)
+
+#define SUPPLICANT_CAPABILITY_PROTO_WPA (1 << 0)
+#define SUPPLICANT_CAPABILITY_PROTO_RSN (1 << 1)
+
+#define SUPPLICANT_CAPABILITY_GROUP_WEP40 (1 << 0)
+#define SUPPLICANT_CAPABILITY_GROUP_WEP104 (1 << 1)
+#define SUPPLICANT_CAPABILITY_GROUP_TKIP (1 << 2)
+#define SUPPLICANT_CAPABILITY_GROUP_CCMP (1 << 3)
+
+#define SUPPLICANT_CAPABILITY_PAIRWISE_NONE (1 << 0)
+#define SUPPLICANT_CAPABILITY_PAIRWISE_TKIP (1 << 1)
+#define SUPPLICANT_CAPABILITY_PAIRWISE_CCMP (1 << 2)
+
+#define SUPPLICANT_CAPABILITY_SCAN_ACTIVE (1 << 0)
+#define SUPPLICANT_CAPABILITY_SCAN_PASSIVE (1 << 1)
+#define SUPPLICANT_CAPABILITY_SCAN_SSID (1 << 2)
+
+#define SUPPLICANT_CAPABILITY_MODE_INFRA (1 << 0)
+#define SUPPLICANT_CAPABILITY_MODE_IBSS (1 << 1)
+#define SUPPLICANT_CAPABILITY_MODE_AP (1 << 2)
+
+enum supplicant_mode {
+ SUPPLICANT_MODE_UNKNOWN,
+ SUPPLICANT_MODE_INFRA,
+ SUPPLICANT_MODE_IBSS,
+};
+
+enum supplicant_security {
+ SUPPLICANT_SECURITY_UNKNOWN,
+ SUPPLICANT_SECURITY_NONE,
+ SUPPLICANT_SECURITY_WEP,
+ SUPPLICANT_SECURITY_PSK,
+ SUPPLICANT_SECURITY_IEEE8021X,
+};
+
+enum supplicant_state {
+ SUPPLICANT_STATE_UNKNOWN,
+ SUPPLICANT_STATE_DISCONNECTED,
+ SUPPLICANT_STATE_INACTIVE,
+ SUPPLICANT_STATE_SCANNING,
+ SUPPLICANT_STATE_AUTHENTICATING,
+ SUPPLICANT_STATE_ASSOCIATING,
+ SUPPLICANT_STATE_ASSOCIATED,
+ SUPPLICANT_STATE_4WAY_HANDSHAKE,
+ SUPPLICANT_STATE_GROUP_HANDSHAKE,
+ SUPPLICANT_STATE_COMPLETED,
+};
+
+struct supplicant_interface;
+
+typedef void (* supplicant_interface_create_callback) (int result,
+ struct supplicant_interface *interface,
+ void *user_data);
+typedef void (* supplicant_interface_remove_callback) (int result,
+ void *user_data);
+typedef void (* supplicant_interface_scan_callback) (int result,
+ void *user_data);
+typedef void (* supplicant_interface_disconnect_callback) (int result,
+ void *user_data);
+
+int supplicant_interface_create(const char *ifname, const char *driver,
+ supplicant_interface_create_callback callback,
+ void *user_data);
+int supplicant_interface_remove(struct supplicant_interface *interface,
+ supplicant_interface_remove_callback callback,
+ void *user_data);
+int supplicant_interface_scan(struct supplicant_interface *interface,
+ supplicant_interface_scan_callback callback,
+ void *user_data);
+int supplicant_interface_disconnect(struct supplicant_interface *interface,
+ supplicant_interface_disconnect_callback callback,
+ void *user_data);
+
+const char *supplicant_interface_get_ifname(struct supplicant_interface *interface);
+const char *supplicant_interface_get_driver(struct supplicant_interface *interface);
+
+struct supplicant_network;
+
+struct supplicant_interface *supplicant_network_get_interface(struct supplicant_network *network);
+const char *supplicant_network_get_name(struct supplicant_network *network);
+const char *supplicant_network_get_identifier(struct supplicant_network *network);
+enum supplicant_mode supplicant_network_get_mode(struct supplicant_network *network);
+
+struct supplicant_callbacks {
+ void (*system_ready) (void);
+ void (*system_killed) (void);
+ void (*interface_added) (struct supplicant_interface *interface);
+ void (*interface_removed) (struct supplicant_interface *interface);
+ void (*scan_started) (struct supplicant_interface *interface);
+ void (*scan_finished) (struct supplicant_interface *interface);
+ void (*network_added) (struct supplicant_network *network);
+ void (*network_removed) (struct supplicant_network *network);
+};
+
+int supplicant_register(const struct supplicant_callbacks *callbacks);
+void supplicant_unregister(const struct supplicant_callbacks *callbacks);
+
+void supplicant_set_debug_level(unsigned int level);
diff --git a/tools/tap-test.c b/tools/tap-test.c
new file mode 100644
index 0000000..fdc098a
--- /dev/null
+++ b/tools/tap-test.c
@@ -0,0 +1,198 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/poll.h>
+#include <sys/ioctl.h>
+
+#include <netinet/in.h>
+#include <netinet/ip.h>
+#include <net/ethernet.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <linux/if_tun.h>
+
+static int inet_ifup(const char *ifname)
+{
+ struct ifreq ifr;
+ int sk, err;
+
+ sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
+ if (sk < 0)
+ return -errno;
+
+ memset(&ifr, 0, sizeof(ifr));
+ strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
+
+ if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ if (ifr.ifr_flags & IFF_UP) {
+ err = -EALREADY;
+ goto done;
+ }
+
+ ifr.ifr_flags |= IFF_UP;
+
+ if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
+ err = -errno;
+ goto done;
+ }
+
+ err = 0;
+
+done:
+ close(sk);
+
+ return err;
+}
+
+static int create_tap(const char *ifname)
+{
+ struct ifreq ifr;
+ int fd, val;
+
+ fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
+ if (fd < 0) {
+ perror("Failed to open TUN/TAP device");
+ return -1;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
+ strncpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name) - 1);
+
+ if (ioctl(fd, TUNSETIFF, (void *) &ifr) < 0) {
+ perror("Failed to set TUN/TAP interface");
+ close(fd);
+ return -1;
+ }
+
+ val = ARPHRD_ETHER;
+
+ if (ioctl(fd, TUNSETLINK, (unsigned long) val) < 0)
+ perror("Failed to set TUN/TAP link type");
+
+ return fd;
+}
+
+static void dump_packet(unsigned char *buf, int len)
+{
+ int i;
+
+ printf("[");
+ for (i = 0; i < len; i++) {
+ printf(" %02x", buf[i]);
+ if ((i + 1) % 16 == 0)
+ printf("\n ");
+ else if ((i + 1) % 8 == 0)
+ printf(" ");
+ }
+ printf(" ]\n");
+}
+
+static void decode_ip(unsigned char *buf, int len)
+{
+ struct iphdr *ip = (void *) buf;
+
+ printf(" IP proto %d saddr 0x%08x daddr 0x%08x\n",
+ ip->protocol, ip->saddr, ip->daddr);
+}
+
+static void decode_packet(unsigned char *buf, int len)
+{
+ struct ether_header *eh = (void *) buf;
+ char src[18], dst[18];
+ uint16_t type;
+
+ snprintf(dst, sizeof(dst), "%02x:%02x:%02x:%02x:%02x:%02x",
+ eh->ether_dhost[0], eh->ether_dhost[1],
+ eh->ether_dhost[2], eh->ether_dhost[3],
+ eh->ether_dhost[4], eh->ether_dhost[5]);
+
+ snprintf(src, sizeof(src), "%02x:%02x:%02x:%02x:%02x:%02x",
+ eh->ether_shost[0], eh->ether_shost[1],
+ eh->ether_shost[2], eh->ether_shost[3],
+ eh->ether_shost[4], eh->ether_shost[5]);
+
+ type = ntohs(eh->ether_type);
+
+ printf("> type 0x%04x src %s dst %s <\n", type, src, dst);
+
+ switch (type) {
+ case ETHERTYPE_IP:
+ decode_ip(buf + 14, len - 14);
+ break;
+ case ETHERTYPE_LOOPBACK:
+ dump_packet(buf, len);
+ break;
+ }
+}
+
+int main(int argc, char *argv[])
+{
+ const char *ifname = "xxx";
+ struct pollfd p;
+ int fd;
+
+ fd = create_tap(ifname);
+ if (fd < 0)
+ return 1;
+
+ if (inet_ifup(ifname) < 0) {
+ close(fd);
+ return 1;
+ }
+
+ memset(&p, 0, sizeof(p));
+ p.fd = fd;
+ p.events = POLLHUP | POLLIN;
+
+ while (1) {
+ unsigned char buf[2048];
+ int len;
+
+ len = poll(&p, 1, -1);
+ if (len < 0)
+ break;
+ if (len == 0)
+ continue;
+
+ len = read(fd, buf, sizeof(buf));
+ if (len < 0)
+ break;
+
+ decode_packet(buf, len);
+ }
+
+ return 0;
+}
diff --git a/tools/web-test.c b/tools/web-test.c
new file mode 100644
index 0000000..55c58af
--- /dev/null
+++ b/tools/web-test.c
@@ -0,0 +1,172 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <string.h>
+#include <signal.h>
+
+#include <gweb/gweb.h>
+
+static GTimer *timer;
+
+static GMainLoop *main_loop;
+
+static void web_debug(const char *str, void *data)
+{
+ g_print("%s: %s\n", (const char *) data, str);
+}
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static bool web_result(GWebResult *result, gpointer user_data)
+{
+ const guint8 *chunk;
+ gsize length;
+ guint16 status;
+ gdouble elapsed;
+
+ g_web_result_get_chunk(result, &chunk, &length);
+
+ if (length > 0) {
+ printf("%s\n", (char *) chunk);
+ return true;
+ }
+
+ status = g_web_result_get_status(result);
+
+ g_print("status: %03u\n", status);
+
+ elapsed = g_timer_elapsed(timer, NULL);
+
+ g_print("elapse: %f seconds\n", elapsed);
+
+ g_main_loop_quit(main_loop);
+
+ return false;
+}
+
+static bool option_debug = false;
+static gchar *option_proxy = NULL;
+static gchar *option_nameserver = NULL;
+static gchar *option_user_agent = NULL;
+static gchar *option_http_version = NULL;
+
+static GOptionEntry options[] = {
+ { "debug", 'd', 0, G_OPTION_ARG_NONE, &option_debug,
+ "Enable debug output" },
+ { "proxy", 'p', 0, G_OPTION_ARG_STRING, &option_proxy,
+ "Specify proxy", "ADDRESS" },
+ { "nameserver", 'n', 0, G_OPTION_ARG_STRING, &option_nameserver,
+ "Specify nameserver", "ADDRESS" },
+ { "user-agent", 'A', 0, G_OPTION_ARG_STRING, &option_user_agent,
+ "Specific user agent", "STRING" },
+ { "http-version", 'H', 0, G_OPTION_ARG_STRING, &option_http_version,
+ "Specific HTTP version", "STRING" },
+ { NULL },
+};
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ struct sigaction sa;
+ GWeb *web;
+ int index = 0;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ return 1;
+ }
+
+ g_option_context_free(context);
+
+ if (argc < 2) {
+ fprintf(stderr, "Missing argument\n");
+ return 1;
+ }
+
+ web = g_web_new(index);
+ if (!web) {
+ fprintf(stderr, "Failed to create web service\n");
+ return 1;
+ }
+
+ if (option_debug)
+ g_web_set_debug(web, web_debug, "WEB");
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ if (option_proxy) {
+ g_web_set_proxy(web, option_proxy);
+ g_free(option_proxy);
+ }
+
+ if (option_nameserver) {
+ g_web_add_nameserver(web, option_nameserver);
+ g_free(option_nameserver);
+ }
+
+ if (option_user_agent) {
+ g_web_set_user_agent(web, "%s", option_user_agent);
+ g_free(option_user_agent);
+ }
+
+ if (option_http_version) {
+ g_web_set_http_version(web, option_http_version);
+ g_free(option_http_version);
+ }
+
+ timer = g_timer_new();
+
+ if (g_web_request_get(web, argv[1], web_result, NULL, NULL) == 0) {
+ fprintf(stderr, "Failed to start request\n");
+ return 1;
+ }
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_timer_destroy(timer);
+
+ g_web_unref(web);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
diff --git a/tools/wispr.c b/tools/wispr.c
new file mode 100644
index 0000000..d5f9341
--- /dev/null
+++ b/tools/wispr.c
@@ -0,0 +1,727 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <termios.h>
+#include <netdb.h>
+
+#include <gweb/gweb.h>
+
+#define DEFAULT_URL "http://www.connman.net/online/status.html"
+
+static GTimer *timer;
+
+static GMainLoop *main_loop;
+
+static void web_debug(const char *str, void *data)
+{
+ g_print("%s: %s\n", (const char *) data, str);
+}
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static const char *message_type_to_string(int message_type)
+{
+ switch (message_type) {
+ case 100:
+ return "Initial redirect message";
+ case 110:
+ return "Proxy notification";
+ case 120:
+ return "Authentication notification";
+ case 130:
+ return "Logoff notification";
+ case 140:
+ return "Response to Authentication Poll";
+ case 150:
+ return "Response to Abort Login";
+ }
+
+ return NULL;
+}
+
+static const char *response_code_to_string(int response_code)
+{
+ switch (response_code) {
+ case 0:
+ return "No error";
+ case 50:
+ return "Login succeeded";
+ case 100:
+ return "Login failed";
+ case 102:
+ return "RADIUS server error/timeout";
+ case 105:
+ return "RADIUS server not enabled";
+ case 150:
+ return "Logoff succeeded";
+ case 151:
+ return "Login aborted";
+ case 200:
+ return "Proxy detection/repeat operation";
+ case 201:
+ return "Authentication pending";
+ case 255:
+ return "Access gateway internal error";
+ }
+
+ return NULL;
+}
+
+struct wispr_msg {
+ bool has_error;
+ const char *current_element;
+ int message_type;
+ int response_code;
+ char *login_url;
+ char *abort_login_url;
+ char *logoff_url;
+ char *access_procedure;
+ char *access_location;
+ char *location_name;
+};
+
+static inline void wispr_msg_init(struct wispr_msg *msg)
+{
+ msg->has_error = false;
+ msg->current_element = NULL;
+
+ msg->message_type = -1;
+ msg->response_code = -1;
+
+ g_free(msg->login_url);
+ msg->login_url = NULL;
+
+ g_free(msg->abort_login_url);
+ msg->abort_login_url = NULL;
+
+ g_free(msg->logoff_url);
+ msg->logoff_url = NULL;
+
+ g_free(msg->access_procedure);
+ msg->access_procedure = NULL;
+
+ g_free(msg->access_location);
+ msg->access_location = NULL;
+
+ g_free(msg->location_name);
+ msg->location_name = NULL;
+}
+
+struct wispr_session {
+ GWeb *web;
+ GWebParser *parser;
+ guint request;
+ struct wispr_msg msg;
+ char *username;
+ char *password;
+ char *originurl;
+ char *formdata;
+};
+
+static gboolean execute_login(gpointer user_data);
+
+static struct {
+ const char *str;
+ enum {
+ WISPR_ELEMENT_NONE,
+ WISPR_ELEMENT_ACCESS_PROCEDURE,
+ WISPR_ELEMENT_ACCESS_LOCATION,
+ WISPR_ELEMENT_LOCATION_NAME,
+ WISPR_ELEMENT_LOGIN_URL,
+ WISPR_ELEMENT_ABORT_LOGIN_URL,
+ WISPR_ELEMENT_MESSAGE_TYPE,
+ WISPR_ELEMENT_RESPONSE_CODE,
+ WISPR_ELEMENT_NEXT_URL,
+ WISPR_ELEMENT_DELAY,
+ WISPR_ELEMENT_REPLY_MESSAGE,
+ WISPR_ELEMENT_LOGIN_RESULTS_URL,
+ WISPR_ELEMENT_LOGOFF_URL,
+ } element;
+} wispr_element_map[] = {
+ { "AccessProcedure", WISPR_ELEMENT_ACCESS_PROCEDURE },
+ { "AccessLocation", WISPR_ELEMENT_ACCESS_LOCATION },
+ { "LocationName", WISPR_ELEMENT_LOCATION_NAME },
+ { "LoginURL", WISPR_ELEMENT_LOGIN_URL },
+ { "AbortLoginURL", WISPR_ELEMENT_ABORT_LOGIN_URL },
+ { "MessageType", WISPR_ELEMENT_MESSAGE_TYPE },
+ { "ResponseCode", WISPR_ELEMENT_RESPONSE_CODE },
+ { "NextURL", WISPR_ELEMENT_NEXT_URL },
+ { "Delay", WISPR_ELEMENT_DELAY },
+ { "ReplyMessage", WISPR_ELEMENT_REPLY_MESSAGE },
+ { "LoginResultsURL", WISPR_ELEMENT_LOGIN_RESULTS_URL },
+ { "LogoffURL", WISPR_ELEMENT_LOGOFF_URL },
+ { NULL, WISPR_ELEMENT_NONE },
+};
+
+static void start_element_handler(GMarkupParseContext *context,
+ const gchar *element_name,
+ const gchar **attribute_names,
+ const gchar **attribute_values,
+ gpointer user_data, GError **error)
+{
+ struct wispr_msg *msg = user_data;
+
+ msg->current_element = element_name;
+}
+
+static void end_element_handler(GMarkupParseContext *context,
+ const gchar *element_name,
+ gpointer user_data, GError **error)
+{
+ struct wispr_msg *msg = user_data;
+
+ msg->current_element = NULL;
+}
+
+static void text_handler(GMarkupParseContext *context,
+ const gchar *text, gsize text_len,
+ gpointer user_data, GError **error)
+{
+ struct wispr_msg *msg = user_data;
+ int i;
+
+ if (!msg->current_element)
+ return;
+
+ for (i = 0; wispr_element_map[i].str; i++) {
+ if (!g_str_equal(wispr_element_map[i].str, msg->current_element))
+ continue;
+
+ switch (wispr_element_map[i].element) {
+ case WISPR_ELEMENT_NONE:
+ case WISPR_ELEMENT_ACCESS_PROCEDURE:
+ g_free(msg->access_procedure);
+ msg->access_procedure = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_ACCESS_LOCATION:
+ g_free(msg->access_location);
+ msg->access_location = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_LOCATION_NAME:
+ g_free(msg->location_name);
+ msg->location_name = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_LOGIN_URL:
+ g_free(msg->login_url);
+ msg->login_url = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_ABORT_LOGIN_URL:
+ g_free(msg->abort_login_url);
+ msg->abort_login_url = g_strdup(text);
+ break;
+ case WISPR_ELEMENT_MESSAGE_TYPE:
+ msg->message_type = atoi(text);
+ break;
+ case WISPR_ELEMENT_RESPONSE_CODE:
+ msg->response_code = atoi(text);
+ break;
+ case WISPR_ELEMENT_NEXT_URL:
+ case WISPR_ELEMENT_DELAY:
+ case WISPR_ELEMENT_REPLY_MESSAGE:
+ case WISPR_ELEMENT_LOGIN_RESULTS_URL:
+ break;
+ case WISPR_ELEMENT_LOGOFF_URL:
+ g_free(msg->logoff_url);
+ msg->logoff_url = g_strdup(text);
+ break;
+ }
+ }
+}
+
+static void error_handler(GMarkupParseContext *context,
+ GError *error, gpointer user_data)
+{
+ struct wispr_msg *msg = user_data;
+
+ msg->has_error = true;
+}
+
+static const GMarkupParser wispr_parser = {
+ start_element_handler,
+ end_element_handler,
+ text_handler,
+ NULL,
+ error_handler,
+};
+
+static void parser_callback(const char *str, gpointer user_data)
+{
+ struct wispr_session *wispr = user_data;
+ GMarkupParseContext *context;
+ bool result;
+
+ //printf("%s\n", str);
+
+ context = g_markup_parse_context_new(&wispr_parser,
+ G_MARKUP_TREAT_CDATA_AS_TEXT, &wispr->msg, NULL);
+
+ result = g_markup_parse_context_parse(context, str, strlen(str), NULL);
+ if (result)
+ g_markup_parse_context_end_parse(context, NULL);
+
+ g_markup_parse_context_free(context);
+}
+
+typedef void (*user_input_cb)(const char *value, gpointer user_data);
+
+struct user_input_data {
+ GString *str;
+ user_input_cb cb;
+ gpointer user_data;
+ bool hidden;
+ int fd;
+ struct termios saved_termios;
+};
+
+static void user_callback(struct user_input_data *data)
+{
+ char *value;
+
+ if (data->hidden) {
+ ssize_t len;
+
+ len = write(data->fd, "\n", 1);
+ if (len < 0)
+ return;
+ }
+
+ tcsetattr(data->fd, TCSADRAIN, &data->saved_termios);
+
+ close(data->fd);
+
+ value = g_string_free(data->str, FALSE);
+
+ if (data->cb)
+ data->cb(value, data->user_data);
+
+ g_free(value);
+
+ g_free(data);
+}
+
+static gboolean keyboard_input(GIOChannel *channel, GIOCondition condition,
+ gpointer user_data)
+{
+ struct user_input_data *data = user_data;
+ char buf[1];
+ int len;
+
+ len = read(data->fd, buf, 1);
+
+ if (len != 1)
+ return TRUE;
+
+ if (buf[0] == '\n') {
+ user_callback(data);
+ return FALSE;
+ }
+
+ g_string_append_c(data->str, buf[0]);
+
+ if (data->hidden)
+ len = write(data->fd, "*", 1);
+
+ return TRUE;
+}
+
+static bool user_input(const char *label, bool hidden,
+ user_input_cb func, gpointer user_data)
+{
+ struct user_input_data *data;
+ struct termios new_termios;
+ GIOChannel *channel;
+ guint watch;
+ ssize_t len;
+
+ data = g_try_new0(struct user_input_data, 1);
+ if (!data)
+ return false;
+
+ data->str = g_string_sized_new(32);
+ data->cb = func;
+ data->user_data = user_data;
+ data->hidden = hidden;
+
+ data->fd = open("/dev/tty", O_RDWR | O_NOCTTY | O_CLOEXEC);
+ if (data->fd < 0)
+ goto error;
+
+ if (tcgetattr(data->fd, &data->saved_termios) < 0) {
+ close(data->fd);
+ goto error;
+ }
+
+ new_termios = data->saved_termios;
+ if (data->hidden)
+ new_termios.c_lflag &= ~(ICANON|ECHO);
+ else
+ new_termios.c_lflag &= ~ICANON;
+ new_termios.c_cc[VMIN] = 1;
+ new_termios.c_cc[VTIME] = 0;
+
+ tcsetattr(data->fd, TCSADRAIN, &new_termios);
+
+ channel = g_io_channel_unix_new(data->fd);
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+ watch = g_io_add_watch(channel, G_IO_IN, keyboard_input, data);
+ g_io_channel_unref(channel);
+
+ if (watch == 0)
+ goto error;
+
+ len = write(data->fd, label, strlen(label));
+ if (len < 0)
+ goto error;
+
+ len = write(data->fd, ": ", 2);
+ if (len < 0)
+ goto error;
+
+ return true;
+
+error:
+ g_string_free(data->str, TRUE);
+ g_free(data);
+
+ return false;
+}
+
+static void password_callback(const char *value, gpointer user_data)
+{
+ struct wispr_session *wispr = user_data;
+
+ g_free(wispr->password);
+ wispr->password = g_strdup(value);
+
+ printf("\n");
+
+ execute_login(wispr);
+}
+
+static void username_callback(const char *value, gpointer user_data)
+{
+ struct wispr_session *wispr = user_data;
+
+ g_free(wispr->username);
+ wispr->username = g_strdup(value);
+
+ if (!wispr->password) {
+ user_input("Password", true, password_callback, wispr);
+ return;
+ }
+
+ printf("\n");
+
+ execute_login(wispr);
+}
+
+static bool wispr_input(const guint8 **data, gsize *length,
+ gpointer user_data)
+{
+ struct wispr_session *wispr = user_data;
+ GString *buf;
+ gsize count;
+
+ buf = g_string_sized_new(100);
+
+ g_string_append(buf, "button=Login&UserName=");
+ g_string_append_uri_escaped(buf, wispr->username, NULL, FALSE);
+ g_string_append(buf, "&Password=");
+ g_string_append_uri_escaped(buf, wispr->password, NULL, FALSE);
+ g_string_append(buf, "&FNAME=0&OriginatingServer=");
+ g_string_append_uri_escaped(buf, wispr->originurl, NULL, FALSE);
+
+ count = buf->len;
+
+ g_free(wispr->formdata);
+ wispr->formdata = g_string_free(buf, FALSE);
+
+ *data = (guint8 *) wispr->formdata;
+ *length = count;
+
+ return false;
+}
+
+static bool wispr_route(const char *addr, int ai_family, int if_index,
+ gpointer user_data)
+{
+ char *family = "unknown";
+
+ if (ai_family == AF_INET)
+ family = "IPv4";
+ else if (ai_family == AF_INET6)
+ family = "IPv6";
+
+ printf("Route request: %s %s index %d\n", family, addr, if_index);
+
+ if (ai_family != AF_INET && ai_family != AF_INET6)
+ return false;
+
+ return true;
+}
+
+static bool wispr_result(GWebResult *result, gpointer user_data)
+{
+ struct wispr_session *wispr = user_data;
+ const guint8 *chunk;
+ gsize length;
+ guint16 status;
+ gdouble elapsed;
+
+ g_web_result_get_chunk(result, &chunk, &length);
+
+ if (length > 0) {
+ //printf("%s\n", (char *) chunk);
+ g_web_parser_feed_data(wispr->parser, chunk, length);
+ return true;
+ }
+
+ g_web_parser_end_data(wispr->parser);
+
+ status = g_web_result_get_status(result);
+
+ g_print("status: %03u\n", status);
+
+ elapsed = g_timer_elapsed(timer, NULL);
+
+ g_print("elapse: %f seconds\n", elapsed);
+
+ if (wispr->msg.message_type < 0) {
+ const char *redirect;
+
+ if (status != 302)
+ goto done;
+
+ if (!g_web_result_get_header(result, "Location", &redirect))
+ goto done;
+
+ printf("Redirect URL: %s\n", redirect);
+ printf("\n");
+
+ wispr->request = g_web_request_get(wispr->web, redirect,
+ wispr_result, wispr_route, wispr);
+
+ return false;
+ }
+
+ printf("Message type: %s (%d)\n",
+ message_type_to_string(wispr->msg.message_type),
+ wispr->msg.message_type);
+ printf("Response code: %s (%d)\n",
+ response_code_to_string(wispr->msg.response_code),
+ wispr->msg.response_code);
+ if (wispr->msg.access_procedure)
+ printf("Access procedure: %s\n", wispr->msg.access_procedure);
+ if (wispr->msg.access_location)
+ printf("Access location: %s\n", wispr->msg.access_location);
+ if (wispr->msg.location_name)
+ printf("Location name: %s\n", wispr->msg.location_name);
+ if (wispr->msg.login_url)
+ printf("Login URL: %s\n", wispr->msg.login_url);
+ if (wispr->msg.abort_login_url)
+ printf("Abort login URL: %s\n", wispr->msg.abort_login_url);
+ if (wispr->msg.logoff_url)
+ printf("Logoff URL: %s\n", wispr->msg.logoff_url);
+ printf("\n");
+
+ if (status != 200 && status != 302 && status != 404)
+ goto done;
+
+ if (wispr->msg.message_type == 100) {
+ if (!wispr->username) {
+ user_input("Username", false,
+ username_callback, wispr);
+ return false;
+ }
+
+ if (!wispr->password) {
+ user_input("Password", true, password_callback, wispr);
+ return false;
+ }
+
+ g_idle_add(execute_login, wispr);
+ return false;
+ } else if (wispr->msg.message_type == 120 ||
+ wispr->msg.message_type == 140) {
+ int code = wispr->msg.response_code;
+ printf("Login process: %s\n",
+ code == 50 ? "SUCCESS" : "FAILURE");
+ }
+
+ if (status == 302) {
+ const char *redirect;
+
+ if (!g_web_result_get_header(result, "Location", &redirect))
+ goto done;
+
+ printf("\n");
+ printf("Redirect URL: %s\n", redirect);
+ printf("\n");
+
+ wispr->request = g_web_request_get(wispr->web, redirect,
+ wispr_result, NULL, wispr);
+
+ return false;
+ }
+
+done:
+ g_main_loop_quit(main_loop);
+
+ return false;
+}
+
+static gboolean execute_login(gpointer user_data)
+{
+ struct wispr_session *wispr = user_data;
+
+ wispr->request = g_web_request_post(wispr->web, wispr->msg.login_url,
+ "application/x-www-form-urlencoded",
+ wispr_input, wispr_result, wispr);
+
+ wispr_msg_init(&wispr->msg);
+
+ return FALSE;
+}
+
+static bool option_debug = false;
+static gchar *option_nameserver = NULL;
+static gchar *option_username = NULL;
+static gchar *option_password = NULL;
+static gchar *option_url = NULL;
+
+static GOptionEntry options[] = {
+ { "debug", 'd', 0, G_OPTION_ARG_NONE, &option_debug,
+ "Enable debug output" },
+ { "nameserver", 'n', 0, G_OPTION_ARG_STRING, &option_nameserver,
+ "Specify nameserver", "ADDRESS" },
+ { "username", 'u', 0, G_OPTION_ARG_STRING, &option_username,
+ "Specify username", "USERNAME" },
+ { "password", 'p', 0, G_OPTION_ARG_STRING, &option_password,
+ "Specify password", "PASSWORD" },
+ { "url", 'U', 0, G_OPTION_ARG_STRING, &option_url,
+ "Specify arbitrary request", "URL" },
+ { NULL },
+};
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ struct sigaction sa;
+ struct wispr_session wispr;
+ int index = 0;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ return 1;
+ }
+
+ g_option_context_free(context);
+
+ memset(&wispr, 0, sizeof(wispr));
+ wispr_msg_init(&wispr.msg);
+
+ wispr.web = g_web_new(index);
+ if (!wispr.web) {
+ fprintf(stderr, "Failed to create web service\n");
+ return 1;
+ }
+
+ if (option_debug)
+ g_web_set_debug(wispr.web, web_debug, "WEB");
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ if (option_nameserver) {
+ g_web_add_nameserver(wispr.web, option_nameserver);
+ g_free(option_nameserver);
+ }
+
+ g_web_set_accept(wispr.web, NULL);
+ g_web_set_user_agent(wispr.web, "SmartClient/%s wispr", VERSION);
+ g_web_set_close_connection(wispr.web, TRUE);
+
+ if (!option_url)
+ option_url = g_strdup(DEFAULT_URL);
+
+ wispr.username = option_username;
+ wispr.password = option_password;
+ wispr.originurl = option_url;
+
+ timer = g_timer_new();
+
+ wispr.parser = g_web_parser_new("<WISPAccessGatewayParam",
+ "WISPAccessGatewayParam>",
+ parser_callback, &wispr);
+
+ wispr.request = g_web_request_get(wispr.web, option_url,
+ wispr_result, wispr_route, &wispr);
+
+ if (wispr.request == 0) {
+ fprintf(stderr, "Failed to start request\n");
+ return 1;
+ }
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_timer_destroy(timer);
+
+ if (wispr.request > 0)
+ g_web_cancel_request(wispr.web, wispr.request);
+
+ g_web_parser_unref(wispr.parser);
+ g_web_unref(wispr.web);
+
+ g_main_loop_unref(main_loop);
+
+ g_free(wispr.username);
+ g_free(wispr.password);
+ g_free(wispr.originurl);
+
+ return 0;
+}
diff --git a/tools/wpad-test.c b/tools/wpad-test.c
new file mode 100644
index 0000000..2ecbcda
--- /dev/null
+++ b/tools/wpad-test.c
@@ -0,0 +1,200 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+
+#include <gweb/gresolv.h>
+
+static GTimer *timer;
+
+static GMainLoop *main_loop;
+
+static GResolv *resolv;
+
+static void resolv_debug(const char *str, void *data)
+{
+ g_print("%s: %s\n", (const char *) data, str);
+}
+
+static void sig_term(int sig)
+{
+ g_main_loop_quit(main_loop);
+}
+
+static void resolv_result(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+ char *hostname = user_data;
+ char *str, *ptr;
+ gdouble elapsed;
+ int i;
+
+ if (status == G_RESOLV_RESULT_STATUS_SUCCESS) {
+ g_print("Found %s\n", hostname);
+ goto done;
+ }
+
+ g_print("No result for %s\n", hostname);
+
+ ptr = strchr(hostname + 5, '.');
+ if (!ptr || strlen(ptr) < 2) {
+ g_print("No more names\n");
+ goto done;
+ }
+
+ if (!strchr(ptr + 1, '.')) {
+ g_print("Not found\n");
+ goto done;
+ }
+
+ str = g_strdup_printf("wpad.%s", ptr + 1);
+
+ g_resolv_lookup_hostname(resolv, str, resolv_result, str);
+
+ g_free(hostname);
+
+ return;
+
+done:
+ elapsed = g_timer_elapsed(timer, NULL);
+
+ g_print("elapse: %f seconds\n", elapsed);
+
+ if (results) {
+ for (i = 0; results[i]; i++)
+ g_print("result: %s\n", results[i]);
+ }
+
+ g_free(hostname);
+
+ g_main_loop_quit(main_loop);
+}
+
+static void start_wpad(const char *search)
+{
+ char domainname[256];
+ char *hostname;
+
+ if (!search) {
+ if (getdomainname(domainname, sizeof(domainname)) < 0) {
+ g_printerr("Failed to get domain name\n");
+ goto quit;
+ }
+ } else
+ snprintf(domainname, sizeof(domainname), "%s", search);
+
+ if (strlen(domainname) == 0) {
+ g_printerr("Domain name is not set\n");
+ goto quit;
+ }
+
+ g_print("domainname: %s\n", domainname);
+
+ hostname = g_strdup_printf("wpad.%s", domainname);
+
+ g_resolv_lookup_hostname(resolv, hostname, resolv_result, hostname);
+
+ return;
+
+quit:
+ g_main_loop_quit(main_loop);
+}
+
+static bool option_debug = false;
+static gchar *option_search = NULL;
+
+static GOptionEntry options[] = {
+ { "debug", 'd', 0, G_OPTION_ARG_NONE, &option_debug,
+ "Enable debug output" },
+ { "search", 's', 0, G_OPTION_ARG_STRING, &option_search,
+ "Specify search domain name" },
+ { NULL },
+};
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ struct sigaction sa;
+ int index = 0;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ exit(1);
+ }
+
+ g_option_context_free(context);
+
+ resolv = g_resolv_new(index);
+ if (!resolv) {
+ g_printerr("Failed to create resolver\n");
+ return 1;
+ }
+
+ if (option_debug)
+ g_resolv_set_debug(resolv, resolv_debug, "RESOLV");
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ if (argc > 1) {
+ int i;
+
+ for (i = 1; i < argc; i++)
+ g_resolv_add_nameserver(resolv, argv[i], 53, 0);
+ } else
+ g_resolv_add_nameserver(resolv, "127.0.0.1", 53, 0);
+
+ timer = g_timer_new();
+
+ start_wpad(option_search);
+
+ g_free(option_search);
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = sig_term;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ g_main_loop_run(main_loop);
+
+ g_timer_destroy(timer);
+
+ g_resolv_unref(resolv);
+
+ g_main_loop_unref(main_loop);
+
+ return 0;
+}
diff --git a/unit/test-ippool.c b/unit/test-ippool.c
new file mode 100644
index 0000000..e8d077a
--- /dev/null
+++ b/unit/test-ippool.c
@@ -0,0 +1,448 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <glib.h>
+
+#include "../src/connman.h"
+
+/* #define DEBUG */
+#ifdef DEBUG
+#include <stdio.h>
+
+#define LOG(fmt, arg...) do { \
+ fprintf(stdout, "%s:%s() " fmt "\n", \
+ __FILE__, __func__ , ## arg); \
+} while (0)
+#else
+#define LOG(fmt, arg...)
+#endif
+
+static void test_case_1(void)
+{
+ struct connman_ippool *pool;
+ int i;
+
+ __connman_ippool_init();
+
+ pool = __connman_ippool_create(23, 1, 500, NULL, NULL);
+ g_assert(!pool);
+
+ for (i = 0; i < 100000; i++) {
+ pool = __connman_ippool_create(23, 1, 20, NULL, NULL);
+ g_assert(pool);
+
+ __connman_ippool_unref(pool);
+ }
+
+ __connman_ippool_cleanup();
+}
+
+static void test_case_2(void)
+{
+ struct connman_ippool *pool;
+ const char *gateway;
+ const char *broadcast;
+ const char *subnet_mask;
+ const char *start_ip;
+ const char *end_ip;
+ int i;
+
+ __connman_ippool_init();
+
+ /* Test the IP range */
+ for (i = 1; i < 254; i++) {
+ pool = __connman_ippool_create(23, 1, i, NULL, NULL);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ __connman_ippool_unref(pool);
+ }
+
+ __connman_ippool_cleanup();
+}
+
+static void test_case_3(void)
+{
+ struct connman_ippool *pool;
+ const char *gateway;
+ const char *broadcast;
+ const char *subnet_mask;
+ const char *start_ip;
+ const char *end_ip;
+ GSList *list = NULL, *it;
+ int i = 0;
+
+ __connman_ippool_init();
+
+ /*
+ * Number of addresses
+ * 24-bit block 10.0.0.0 – 10.255.255.255 16,777,216
+ * 20-bit block 172.16.0.0 – 172.31.255.255 1,048,576
+ * 16-bit block 192.168.0.0 – 192.168.255.255 65,536
+ *
+ * Total 17,891,328
+ *
+ * Total numbers of 256 blocks: 69,888
+ */
+
+ /*
+ * Completely exhaust the first two pools because they are a bit
+ * too large.
+ */
+ __connman_ippool_newaddr(45, "10.0.0.1", 8);
+ __connman_ippool_newaddr(46, "172.16.0.1", 11);
+
+ while (TRUE) {
+ pool = __connman_ippool_create(23, 1, 100, NULL, NULL);
+ if (!pool)
+ break;
+ i += 1;
+
+ list = g_slist_prepend(list, pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+ }
+
+ g_assert(i == 255);
+
+ LOG("Number of blocks %d", i);
+
+ for (it = list; it; it = it->next) {
+ pool = it->data;
+
+ __connman_ippool_unref(pool);
+ }
+
+ g_slist_free(list);
+
+ __connman_ippool_cleanup();
+}
+
+static void collision_cb(struct connman_ippool *pool, void *user_data)
+{
+ int *flag = user_data;
+
+ LOG("collision detected");
+
+ g_assert(*flag == 0);
+ g_assert(pool);
+
+ *flag = 1;
+}
+
+static void test_case_4(void)
+{
+ struct connman_ippool *pool;
+ const char *gateway;
+ const char *broadcast;
+ const char *subnet_mask;
+ const char *start_ip;
+ const char *end_ip;
+ int flag;
+
+ __connman_ippool_init();
+
+ /* Test the IP range collision */
+
+ flag = 0;
+ pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ __connman_ippool_newaddr(23, start_ip, 24);
+
+ g_assert(flag == 0);
+
+ __connman_ippool_newaddr(42, start_ip, 16);
+
+ g_assert(flag == 1);
+
+ __connman_ippool_unref(pool);
+
+ flag = 0;
+
+ pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ __connman_ippool_newaddr(45, start_ip, 22);
+
+ g_assert(flag == 1);
+
+ __connman_ippool_unref(pool);
+
+ __connman_ippool_cleanup();
+}
+
+static void test_case_5(void)
+{
+ struct connman_ippool *pool;
+ const char *gateway;
+ const char *broadcast;
+ const char *subnet_mask;
+ const char *start_ip;
+ const char *end_ip;
+ int flag;
+
+ __connman_ippool_init();
+
+ /* Test the IP range collision */
+
+ flag = 0;
+ start_ip = "192.168.1.2";
+ __connman_ippool_newaddr(25, start_ip, 24);
+ g_assert(flag == 0);
+
+ /* pool should return 192.168.0.1 now */
+ pool = __connman_ippool_create(26, 1, 100, collision_cb, &flag);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ g_assert_cmpstr(gateway, ==, "192.168.0.1");
+ g_assert_cmpstr(broadcast, ==, "192.168.0.255");
+ g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
+ g_assert_cmpstr(start_ip, ==, "192.168.0.1");
+ g_assert_cmpstr(end_ip, ==, "192.168.0.101");
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ __connman_ippool_unref(pool);
+
+ /*
+ * Now create the pool again, we should not get collision
+ * with existing allocated address.
+ */
+
+ /* pool should return 192.168.2.1 now */
+ flag = 0;
+ pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ g_assert_cmpstr(gateway, ==, "192.168.2.1");
+ g_assert_cmpstr(broadcast, ==, "192.168.2.255");
+ g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
+ g_assert_cmpstr(start_ip, ==, "192.168.2.1");
+ g_assert_cmpstr(end_ip, ==, "192.168.2.101");
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ g_assert(flag == 0);
+
+ __connman_ippool_unref(pool);
+
+ __connman_ippool_cleanup();
+}
+
+static void test_case_6(void)
+{
+ struct connman_ippool *pool;
+ const char *gateway;
+ const char *broadcast;
+ const char *subnet_mask;
+ const char *start_ip;
+ const char *end_ip;
+ int flag;
+
+ __connman_ippool_init();
+
+ /* Test the IP range collision */
+
+ flag = 0;
+ start_ip = "192.168.1.2";
+ __connman_ippool_newaddr(25, start_ip, 24);
+ g_assert(flag == 0);
+
+ flag = 0;
+ start_ip = "192.168.0.2";
+ __connman_ippool_newaddr(25, start_ip, 24);
+ g_assert(flag == 0);
+
+ /* pool should return 192.168.2.1 now */
+ pool = __connman_ippool_create(26, 1, 100, collision_cb, &flag);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ g_assert_cmpstr(gateway, ==, "192.168.2.1");
+ g_assert_cmpstr(broadcast, ==, "192.168.2.255");
+ g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
+ g_assert_cmpstr(start_ip, ==, "192.168.2.1");
+ g_assert_cmpstr(end_ip, ==, "192.168.2.101");
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ __connman_ippool_unref(pool);
+
+ /*
+ * Now create the pool again, we should not get collision
+ * with existing allocated address.
+ */
+
+ /* pool should return 192.168.3.1 now */
+ flag = 0;
+ pool = __connman_ippool_create(23, 1, 100, collision_cb, &flag);
+ g_assert(pool);
+
+ gateway = __connman_ippool_get_gateway(pool);
+ broadcast = __connman_ippool_get_broadcast(pool);
+ subnet_mask = __connman_ippool_get_subnet_mask(pool);
+ start_ip = __connman_ippool_get_start_ip(pool);
+ end_ip = __connman_ippool_get_end_ip(pool);
+
+ g_assert(gateway);
+ g_assert(broadcast);
+ g_assert(subnet_mask);
+ g_assert(start_ip);
+ g_assert(end_ip);
+
+ g_assert_cmpstr(gateway, ==, "192.168.3.1");
+ g_assert_cmpstr(broadcast, ==, "192.168.3.255");
+ g_assert_cmpstr(subnet_mask, ==, "255.255.255.0");
+ g_assert_cmpstr(start_ip, ==, "192.168.3.1");
+ g_assert_cmpstr(end_ip, ==, "192.168.3.101");
+
+ LOG("\n\tIP range %s --> %s\n"
+ "\tgateway %s broadcast %s mask %s", start_ip, end_ip,
+ gateway, broadcast, subnet_mask);
+
+ g_assert(flag == 0);
+
+ flag = 0;
+ start_ip = "192.168.3.2";
+ __connman_ippool_newaddr(25, start_ip, 24);
+ g_assert(flag == 1);
+
+ __connman_ippool_unref(pool);
+
+ __connman_ippool_cleanup();
+}
+
+int main(int argc, char *argv[])
+{
+ g_test_init(&argc, &argv, NULL);
+
+ g_test_add_func("/ippool/Test case 1", test_case_1);
+ g_test_add_func("/ippool/Test case 2", test_case_2);
+ g_test_add_func("/ippool/Test case 3", test_case_3);
+ g_test_add_func("/ippool/Test case 4", test_case_4);
+ g_test_add_func("/ippool/Test case 5", test_case_5);
+ g_test_add_func("/ippool/Test case 6", test_case_6);
+
+ return g_test_run();
+}
diff --git a/vpn/connman-task.te b/vpn/connman-task.te
new file mode 100644
index 0000000..dd77710
--- /dev/null
+++ b/vpn/connman-task.te
@@ -0,0 +1,16 @@
+# SElinux policy file for allowing various vpn clients
+# to access net.connman.Task dbus interface
+
+module connman-task 1.0;
+
+require {
+ type openvpn_t;
+ type openconnect_t;
+ type vpnc_t;
+ type initrc_t;
+ class dbus send_msg;
+}
+
+allow openvpn_t initrc_t:dbus send_msg;
+allow openconnect_t initrc_t:dbus send_msg;
+allow vpnc_t initrc_t:dbus send_msg;
diff --git a/vpn/connman-vpn.conf b/vpn/connman-vpn.conf
new file mode 100644
index 0000000..99a96ce
--- /dev/null
+++ b/vpn/connman-vpn.conf
@@ -0,0 +1,8 @@
+[General]
+
+# Set input request timeout. Default is 300 seconds
+# The request for inputs like passphrase will timeout
+# after certain amount of time. Use this setting to
+# increase the value in case of different user
+# interface designs.
+# InputRequestTimeout = 300
diff --git a/vpn/connman-vpn.service.in b/vpn/connman-vpn.service.in
new file mode 100644
index 0000000..de65a70
--- /dev/null
+++ b/vpn/connman-vpn.service.in
@@ -0,0 +1,13 @@
+[Unit]
+Description=ConnMan VPN service
+Requires=dbus.socket
+After=dbus.socket
+
+[Service]
+Type=dbus
+BusName=net.connman.vpn
+ExecStart=@sbindir@/connman-vpnd -n
+StandardOutput=null
+
+[Install]
+WantedBy=multi-user.target
diff --git a/vpn/main.c b/vpn/main.c
new file mode 100644
index 0000000..ee88aac
--- /dev/null
+++ b/vpn/main.c
@@ -0,0 +1,359 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <signal.h>
+#include <sys/signalfd.h>
+#include <getopt.h>
+#include <sys/stat.h>
+#include <net/if.h>
+#include <netdb.h>
+
+#include <gdbus.h>
+
+#include "../src/connman.h"
+#include "vpn.h"
+
+#include "connman/vpn-dbus.h"
+
+#define CONFIGMAINFILE CONFIGDIR "/connman-vpn.conf"
+
+#define DEFAULT_INPUT_REQUEST_TIMEOUT 300 * 1000
+
+static GMainLoop *main_loop = NULL;
+
+static unsigned int __terminated = 0;
+
+static struct {
+ unsigned int timeout_inputreq;
+} connman_vpn_settings = {
+ .timeout_inputreq = DEFAULT_INPUT_REQUEST_TIMEOUT,
+};
+
+static GKeyFile *load_config(const char *file)
+{
+ GError *err = NULL;
+ GKeyFile *keyfile;
+
+ keyfile = g_key_file_new();
+
+ g_key_file_set_list_separator(keyfile, ',');
+
+ if (!g_key_file_load_from_file(keyfile, file, 0, &err)) {
+ if (err->code != G_FILE_ERROR_NOENT) {
+ connman_error("Parsing %s failed: %s", file,
+ err->message);
+ }
+
+ g_error_free(err);
+ g_key_file_free(keyfile);
+ return NULL;
+ }
+
+ return keyfile;
+}
+
+static void parse_config(GKeyFile *config, const char *file)
+{
+ GError *error = NULL;
+ int timeout;
+
+ if (!config)
+ return;
+
+ DBG("parsing %s", file);
+
+ timeout = g_key_file_get_integer(config, "General",
+ "InputRequestTimeout", &error);
+ if (!error && timeout >= 0)
+ connman_vpn_settings.timeout_inputreq = timeout * 1000;
+
+ g_clear_error(&error);
+}
+
+static int config_init(const char *file)
+{
+ GKeyFile *config;
+
+ config = load_config(file);
+ parse_config(config, file);
+ if (config)
+ g_key_file_free(config);
+
+ return 0;
+}
+
+static gboolean signal_handler(GIOChannel *channel, GIOCondition cond,
+ gpointer user_data)
+{
+ struct signalfd_siginfo si;
+ ssize_t result;
+ int fd;
+
+ if (cond & (G_IO_NVAL | G_IO_ERR | G_IO_HUP))
+ return FALSE;
+
+ fd = g_io_channel_unix_get_fd(channel);
+
+ result = read(fd, &si, sizeof(si));
+ if (result != sizeof(si))
+ return FALSE;
+
+ switch (si.ssi_signo) {
+ case SIGINT:
+ case SIGTERM:
+ if (__terminated == 0) {
+ connman_info("Terminating");
+ g_main_loop_quit(main_loop);
+ }
+
+ __terminated = 1;
+ break;
+ }
+
+ return TRUE;
+}
+
+static guint setup_signalfd(void)
+{
+ GIOChannel *channel;
+ guint source;
+ sigset_t mask;
+ int fd;
+
+ sigemptyset(&mask);
+ sigaddset(&mask, SIGINT);
+ sigaddset(&mask, SIGTERM);
+
+ if (sigprocmask(SIG_BLOCK, &mask, NULL) < 0) {
+ perror("Failed to set signal mask");
+ return 0;
+ }
+
+ fd = signalfd(-1, &mask, 0);
+ if (fd < 0) {
+ perror("Failed to create signal descriptor");
+ return 0;
+ }
+
+ channel = g_io_channel_unix_new(fd);
+
+ g_io_channel_set_close_on_unref(channel, TRUE);
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ source = g_io_add_watch(channel,
+ G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
+ signal_handler, NULL);
+
+ g_io_channel_unref(channel);
+
+ return source;
+}
+
+static void disconnect_callback(DBusConnection *conn, void *user_data)
+{
+ connman_error("D-Bus disconnect");
+
+ g_main_loop_quit(main_loop);
+}
+
+static gchar *option_config = NULL;
+static gchar *option_debug = NULL;
+static gchar *option_plugin = NULL;
+static gchar *option_noplugin = NULL;
+static bool option_detach = true;
+static bool option_version = false;
+static bool option_routes = false;
+
+static bool parse_debug(const char *key, const char *value,
+ gpointer user_data, GError **error)
+{
+ if (value)
+ option_debug = g_strdup(value);
+ else
+ option_debug = g_strdup("*");
+
+ return true;
+}
+
+static GOptionEntry options[] = {
+ { "config", 'c', 0, G_OPTION_ARG_STRING, &option_config,
+ "Load the specified configuration file "
+ "instead of " CONFIGMAINFILE, "FILE" },
+ { "debug", 'd', G_OPTION_FLAG_OPTIONAL_ARG,
+ G_OPTION_ARG_CALLBACK, parse_debug,
+ "Specify debug options to enable", "DEBUG" },
+ { "plugin", 'p', 0, G_OPTION_ARG_STRING, &option_plugin,
+ "Specify plugins to load", "NAME,..." },
+ { "noplugin", 'P', 0, G_OPTION_ARG_STRING, &option_noplugin,
+ "Specify plugins not to load", "NAME,..." },
+ { "nodaemon", 'n', G_OPTION_FLAG_REVERSE,
+ G_OPTION_ARG_NONE, &option_detach,
+ "Don't fork daemon to background" },
+ { "routes", 'r', 0, G_OPTION_ARG_NONE, &option_routes,
+ "Create/delete VPN routes" },
+ { "version", 'v', 0, G_OPTION_ARG_NONE, &option_version,
+ "Show version information and exit" },
+ { NULL },
+};
+
+/*
+ * This function will be called from generic src/agent.c code so we have
+ * to use connman_ prefix instead of vpn_ one.
+ */
+unsigned int connman_timeout_input_request(void)
+{
+ return connman_vpn_settings.timeout_inputreq;
+}
+
+int main(int argc, char *argv[])
+{
+ GOptionContext *context;
+ GError *error = NULL;
+ DBusConnection *conn;
+ DBusError err;
+ guint signal;
+
+ context = g_option_context_new(NULL);
+ g_option_context_add_main_entries(context, options, NULL);
+
+ if (!g_option_context_parse(context, &argc, &argv, &error)) {
+ if (error) {
+ g_printerr("%s\n", error->message);
+ g_error_free(error);
+ } else
+ g_printerr("An unknown error occurred\n");
+ exit(1);
+ }
+
+ g_option_context_free(context);
+
+ if (option_version) {
+ printf("%s\n", VERSION);
+ exit(0);
+ }
+
+ if (option_detach) {
+ if (daemon(0, 0)) {
+ perror("Can't start daemon");
+ exit(1);
+ }
+ }
+
+ if (mkdir(VPN_STATEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
+ S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
+ if (errno != EEXIST)
+ perror("Failed to create state directory");
+ }
+
+ /*
+ * At some point the VPN stuff is migrated into VPN_STORAGEDIR
+ * and this mkdir() call can be removed.
+ */
+ if (mkdir(STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
+ S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
+ if (errno != EEXIST)
+ perror("Failed to create storage directory");
+ }
+
+ if (mkdir(VPN_STORAGEDIR, S_IRUSR | S_IWUSR | S_IXUSR |
+ S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH) < 0) {
+ if (errno != EEXIST)
+ perror("Failed to create VPN storage directory");
+ }
+
+ umask(0077);
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ signal = setup_signalfd();
+
+ dbus_error_init(&err);
+
+ conn = g_dbus_setup_bus(DBUS_BUS_SYSTEM, VPN_SERVICE, &err);
+ if (!conn) {
+ if (dbus_error_is_set(&err)) {
+ fprintf(stderr, "%s\n", err.message);
+ dbus_error_free(&err);
+ } else
+ fprintf(stderr, "Can't register with system bus\n");
+ exit(1);
+ }
+
+ g_dbus_set_disconnect_function(conn, disconnect_callback, NULL, NULL);
+
+ __connman_log_init(argv[0], option_debug, option_detach, false,
+ "Connection Manager VPN daemon", VERSION);
+ __connman_dbus_init(conn);
+
+ if (!option_config)
+ config_init(CONFIGMAINFILE);
+ else
+ config_init(option_config);
+
+ __connman_inotify_init();
+ __connman_agent_init();
+ __vpn_provider_init(option_routes);
+ __vpn_manager_init();
+ __vpn_ipconfig_init();
+ __vpn_rtnl_init();
+ __connman_task_init();
+ __connman_plugin_init(option_plugin, option_noplugin);
+ __vpn_config_init();
+
+ __vpn_rtnl_start();
+
+ g_free(option_plugin);
+ g_free(option_noplugin);
+
+ g_main_loop_run(main_loop);
+
+ g_source_remove(signal);
+
+ __vpn_config_cleanup();
+ __connman_plugin_cleanup();
+ __connman_task_cleanup();
+ __vpn_rtnl_cleanup();
+ __vpn_ipconfig_cleanup();
+ __vpn_manager_cleanup();
+ __vpn_provider_cleanup();
+ __connman_agent_cleanup();
+ __connman_inotify_cleanup();
+ __connman_dbus_cleanup();
+ __connman_log_cleanup(false);
+
+ dbus_connection_unref(conn);
+
+ g_main_loop_unref(main_loop);
+
+ g_free(option_debug);
+
+ return 0;
+}
diff --git a/vpn/net.connman.vpn.service.in b/vpn/net.connman.vpn.service.in
new file mode 100644
index 0000000..e473ea9
--- /dev/null
+++ b/vpn/net.connman.vpn.service.in
@@ -0,0 +1,5 @@
+[D-BUS Service]
+Name=net.connman.vpn
+Exec=@sbindir@/connman-vpnd -n
+User=root
+SystemdService=connman-vpn.service
diff --git a/vpn/plugins/l2tp.c b/vpn/plugins/l2tp.c
new file mode 100644
index 0000000..22f9dcf
--- /dev/null
+++ b/vpn/plugins/l2tp.c
@@ -0,0 +1,811 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2010,2013 BMW Car IT GmbH.
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#include <stdio.h>
+#include <net/if.h>
+
+#include <dbus/dbus.h>
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/provider.h>
+#include <connman/log.h>
+#include <connman/task.h>
+#include <connman/dbus.h>
+#include <connman/inet.h>
+#include <connman/agent.h>
+#include <connman/setting.h>
+#include <connman/vpn-dbus.h>
+
+#include "../vpn-provider.h"
+#include "../vpn-agent.h"
+
+#include "vpn.h"
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
+
+enum {
+ OPT_STRING = 1,
+ OPT_BOOL = 2,
+};
+
+enum {
+ OPT_ALL = 1,
+ OPT_L2G = 2,
+ OPT_L2 = 3,
+ OPT_PPPD = 4,
+};
+
+struct {
+ const char *cm_opt;
+ const char *pppd_opt;
+ int sub;
+ const char *vpn_default;
+ int type;
+} pppd_options[] = {
+ { "L2TP.User", "name", OPT_ALL, NULL, OPT_STRING },
+ { "L2TP.BPS", "bps", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.TXBPS", "tx bps", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.RXBPS", "rx bps", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.LengthBit", "length bit", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.Challenge", "challenge", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.DefaultRoute", "defaultroute", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.FlowBit", "flow bit", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.TunnelRWS", "tunnel rws", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.Exclusive", "exclusive", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.Autodial", "autodial", OPT_L2, "yes", OPT_STRING },
+ { "L2TP.Redial", "redial", OPT_L2, "yes", OPT_STRING },
+ { "L2TP.RedialTimeout", "redial timeout", OPT_L2, "10", OPT_STRING },
+ { "L2TP.MaxRedials", "max redials", OPT_L2, NULL, OPT_STRING },
+ { "L2TP.RequirePAP", "require pap", OPT_L2, "no", OPT_STRING },
+ { "L2TP.RequireCHAP", "require chap", OPT_L2, "yes", OPT_STRING },
+ { "L2TP.ReqAuth", "require authentication", OPT_L2, "no", OPT_STRING },
+ { "L2TP.AccessControl", "access control", OPT_L2G, "yes", OPT_STRING },
+ { "L2TP.AuthFile", "auth file", OPT_L2G, NULL, OPT_STRING },
+ { "L2TP.ForceUserSpace", "force userspace", OPT_L2G, NULL, OPT_STRING },
+ { "L2TP.ListenAddr", "listen-addr", OPT_L2G, NULL, OPT_STRING },
+ { "L2TP.Rand Source", "rand source", OPT_L2G, NULL, OPT_STRING },
+ { "L2TP.IPsecSaref", "ipsec saref", OPT_L2G, NULL, OPT_STRING },
+ { "L2TP.Port", "port", OPT_L2G, NULL, OPT_STRING },
+ { "PPPD.EchoFailure", "lcp-echo-failure", OPT_PPPD, "0", OPT_STRING },
+ { "PPPD.EchoInterval", "lcp-echo-interval", OPT_PPPD, "0", OPT_STRING },
+ { "PPPD.Debug", "debug", OPT_PPPD, NULL, OPT_STRING },
+ { "PPPD.RefuseEAP", "refuse-eap", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.RefusePAP", "refuse-pap", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.RefuseCHAP", "refuse-chap", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.RefuseMSCHAP", "refuse-mschap", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.RefuseMSCHAP2", "refuse-mschapv2", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.NoBSDComp", "nobsdcomp", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.NoPcomp", "nopcomp", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.UseAccomp", "accomp", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.NoDeflate", "nodeflate", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.ReqMPPE", "require-mppe", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.ReqMPPE40", "require-mppe-40", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.ReqMPPE128", "require-mppe-128", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.ReqMPPEStateful", "mppe-stateful", OPT_PPPD, NULL, OPT_BOOL },
+ { "PPPD.NoVJ", "no-vj-comp", OPT_PPPD, NULL, OPT_BOOL },
+};
+
+static DBusConnection *connection;
+
+struct l2tp_private_data {
+ struct connman_task *task;
+ char *if_name;
+ vpn_provider_connect_cb_t cb;
+ void *user_data;
+};
+
+static DBusMessage *l2tp_get_sec(struct connman_task *task,
+ DBusMessage *msg, void *user_data)
+{
+ const char *user, *passwd;
+ struct vpn_provider *provider = user_data;
+
+ if (!dbus_message_get_no_reply(msg)) {
+ DBusMessage *reply;
+
+ user = vpn_provider_get_string(provider, "L2TP.User");
+ passwd = vpn_provider_get_string(provider, "L2TP.Password");
+
+ if (!user || strlen(user) == 0 ||
+ !passwd || strlen(passwd) == 0)
+ return NULL;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &user,
+ DBUS_TYPE_STRING, &passwd,
+ DBUS_TYPE_INVALID);
+
+ return reply;
+ }
+
+ return NULL;
+}
+
+static int l2tp_notify(DBusMessage *msg, struct vpn_provider *provider)
+{
+ DBusMessageIter iter, dict;
+ const char *reason, *key, *value;
+ char *addressv4 = NULL, *netmask = NULL, *gateway = NULL;
+ char *ifname = NULL, *nameservers = NULL;
+ struct connman_ipaddress *ipaddress = NULL;
+
+ dbus_message_iter_init(msg, &iter);
+
+ dbus_message_iter_get_basic(&iter, &reason);
+ dbus_message_iter_next(&iter);
+
+ if (!provider) {
+ connman_error("No provider found");
+ return VPN_STATE_FAILURE;
+ }
+
+ if (strcmp(reason, "auth failed") == 0) {
+ DBG("authentication failure");
+
+ vpn_provider_set_string(provider, "L2TP.User", NULL);
+ vpn_provider_set_string(provider, "L2TP.Password", NULL);
+
+ return VPN_STATE_AUTH_FAILURE;
+ }
+
+ if (strcmp(reason, "connect"))
+ return VPN_STATE_DISCONNECT;
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_get_basic(&entry, &value);
+
+ DBG("%s = %s", key, value);
+
+ if (!strcmp(key, "INTERNAL_IP4_ADDRESS"))
+ addressv4 = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_NETMASK"))
+ netmask = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_DNS"))
+ nameservers = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IFNAME"))
+ ifname = g_strdup(value);
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (vpn_set_ifname(provider, ifname) < 0) {
+ g_free(ifname);
+ g_free(addressv4);
+ g_free(netmask);
+ g_free(nameservers);
+ return VPN_STATE_FAILURE;
+ }
+
+ if (addressv4)
+ ipaddress = connman_ipaddress_alloc(AF_INET);
+
+ g_free(ifname);
+
+ if (!ipaddress) {
+ connman_error("No IP address for provider");
+ g_free(addressv4);
+ g_free(netmask);
+ g_free(nameservers);
+ return VPN_STATE_FAILURE;
+ }
+
+ value = vpn_provider_get_string(provider, "HostIP");
+ if (value) {
+ vpn_provider_set_string(provider, "Gateway", value);
+ gateway = g_strdup(value);
+ }
+
+ if (addressv4)
+ connman_ipaddress_set_ipv4(ipaddress, addressv4, netmask,
+ gateway);
+
+ vpn_provider_set_ipaddress(provider, ipaddress);
+ vpn_provider_set_nameservers(provider, nameservers);
+
+ g_free(addressv4);
+ g_free(netmask);
+ g_free(gateway);
+ g_free(nameservers);
+ connman_ipaddress_free(ipaddress);
+
+ return VPN_STATE_CONNECT;
+}
+
+static int l2tp_save(struct vpn_provider *provider, GKeyFile *keyfile)
+{
+ const char *option;
+ bool l2tp_option, pppd_option;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(pppd_options); i++) {
+ l2tp_option = pppd_option = false;
+
+ if (strncmp(pppd_options[i].cm_opt, "L2TP.", 5) == 0)
+ l2tp_option = true;
+
+ if (strncmp(pppd_options[i].cm_opt, "PPPD.", 5) == 0)
+ pppd_option = true;
+
+ if (l2tp_option || pppd_option) {
+ option = vpn_provider_get_string(provider,
+ pppd_options[i].cm_opt);
+ if (!option) {
+ /*
+ * Check if the option prefix is L2TP as the
+ * PPPD options were using L2TP prefix earlier.
+ */
+ char *l2tp_str;
+
+ if (!pppd_option)
+ continue;
+
+ l2tp_str = g_strdup_printf("L2TP.%s",
+ &pppd_options[i].cm_opt[5]);
+ option = vpn_provider_get_string(provider,
+ l2tp_str);
+ g_free(l2tp_str);
+
+ if (!option)
+ continue;
+ }
+
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ pppd_options[i].cm_opt, option);
+ }
+ }
+
+ return 0;
+}
+
+static ssize_t full_write(int fd, const void *buf, size_t len)
+{
+ ssize_t byte_write;
+
+ while (len) {
+ byte_write = write(fd, buf, len);
+ if (byte_write < 0) {
+ connman_error("failed to write config to l2tp: %s\n",
+ strerror(errno));
+ return byte_write;
+ }
+ len -= byte_write;
+ buf += byte_write;
+ }
+
+ return 0;
+}
+
+static ssize_t l2tp_write_bool_option(int fd,
+ const char *key, const char *value)
+{
+ gchar *buf;
+ ssize_t ret = 0;
+
+ if (key && value) {
+ if (strcasecmp(value, "yes") == 0 ||
+ strcasecmp(value, "true") == 0 ||
+ strcmp(value, "1") == 0) {
+ buf = g_strdup_printf("%s\n", key);
+ ret = full_write(fd, buf, strlen(buf));
+
+ g_free(buf);
+ }
+ }
+
+ return ret;
+}
+
+static int l2tp_write_option(int fd, const char *key, const char *value)
+{
+ gchar *buf;
+ ssize_t ret = 0;
+
+ if (key) {
+ if (value)
+ buf = g_strdup_printf("%s %s\n", key, value);
+ else
+ buf = g_strdup_printf("%s\n", key);
+
+ ret = full_write(fd, buf, strlen(buf));
+
+ g_free(buf);
+ }
+
+ return ret;
+}
+
+static int l2tp_write_section(int fd, const char *key, const char *value)
+{
+ gchar *buf;
+ ssize_t ret = 0;
+
+ if (key && value) {
+ buf = g_strdup_printf("%s = %s\n", key, value);
+ ret = full_write(fd, buf, strlen(buf));
+
+ g_free(buf);
+ }
+
+ return ret;
+}
+
+static int write_pppd_option(struct vpn_provider *provider, int fd)
+{
+ int i;
+ const char *opt_s;
+
+ l2tp_write_option(fd, "nodetach", NULL);
+ l2tp_write_option(fd, "lock", NULL);
+ l2tp_write_option(fd, "usepeerdns", NULL);
+ l2tp_write_option(fd, "noipdefault", NULL);
+ l2tp_write_option(fd, "noauth", NULL);
+ l2tp_write_option(fd, "nodefaultroute", NULL);
+ l2tp_write_option(fd, "ipparam", "l2tp_plugin");
+
+ for (i = 0; i < (int)ARRAY_SIZE(pppd_options); i++) {
+ if (pppd_options[i].sub != OPT_ALL &&
+ pppd_options[i].sub != OPT_PPPD)
+ continue;
+
+ opt_s = vpn_provider_get_string(provider,
+ pppd_options[i].cm_opt);
+ if (!opt_s)
+ opt_s = pppd_options[i].vpn_default;
+
+ if (!opt_s)
+ continue;
+
+ if (pppd_options[i].type == OPT_STRING)
+ l2tp_write_option(fd,
+ pppd_options[i].pppd_opt, opt_s);
+ else if (pppd_options[i].type == OPT_BOOL)
+ l2tp_write_bool_option(fd,
+ pppd_options[i].pppd_opt, opt_s);
+ }
+
+ l2tp_write_option(fd, "plugin",
+ SCRIPTDIR "/libppp-plugin.so");
+
+ return 0;
+}
+
+
+static int l2tp_write_fields(struct vpn_provider *provider,
+ int fd, int sub)
+{
+ int i;
+ const char *opt_s;
+
+ for (i = 0; i < (int)ARRAY_SIZE(pppd_options); i++) {
+ if (pppd_options[i].sub != sub)
+ continue;
+
+ opt_s = vpn_provider_get_string(provider,
+ pppd_options[i].cm_opt);
+ if (!opt_s)
+ opt_s = pppd_options[i].vpn_default;
+
+ if (!opt_s)
+ continue;
+
+ if (pppd_options[i].type == OPT_STRING)
+ l2tp_write_section(fd,
+ pppd_options[i].pppd_opt, opt_s);
+ else if (pppd_options[i].type == OPT_BOOL)
+ l2tp_write_bool_option(fd,
+ pppd_options[i].pppd_opt, opt_s);
+ }
+
+ return 0;
+}
+
+static int l2tp_write_config(struct vpn_provider *provider,
+ const char *pppd_name, int fd)
+{
+ const char *option;
+
+ l2tp_write_option(fd, "[global]", NULL);
+ l2tp_write_fields(provider, fd, OPT_L2G);
+
+ l2tp_write_option(fd, "[lac l2tp]", NULL);
+
+ option = vpn_provider_get_string(provider, "Host");
+ l2tp_write_option(fd, "lns =", option);
+
+ l2tp_write_fields(provider, fd, OPT_ALL);
+ l2tp_write_fields(provider, fd, OPT_L2);
+
+ l2tp_write_option(fd, "pppoptfile =", pppd_name);
+
+ return 0;
+}
+
+static void l2tp_died(struct connman_task *task, int exit_code, void *user_data)
+{
+ char *conf_file;
+
+ vpn_died(task, exit_code, user_data);
+
+ conf_file = g_strdup_printf(VPN_STATEDIR "/connman-xl2tpd.conf");
+ unlink(conf_file);
+ g_free(conf_file);
+
+ conf_file = g_strdup_printf(VPN_STATEDIR "/connman-ppp-option.conf");
+ unlink(conf_file);
+ g_free(conf_file);
+}
+
+struct request_input_reply {
+ struct vpn_provider *provider;
+ vpn_provider_password_cb_t callback;
+ void *user_data;
+};
+
+static void request_input_reply(DBusMessage *reply, void *user_data)
+{
+ struct request_input_reply *l2tp_reply = user_data;
+ const char *error = NULL;
+ char *username = NULL, *password = NULL;
+ char *key;
+ DBusMessageIter iter, dict;
+
+ DBG("provider %p", l2tp_reply->provider);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ error = dbus_message_get_error_name(reply);
+ goto done;
+ }
+
+ if (!vpn_agent_check_reply_has_dict(reply))
+ goto done;
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *str;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ if (g_str_equal(key, "Username")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &str);
+ username = g_strdup(str);
+ }
+
+ if (g_str_equal(key, "Password")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &str);
+ password = g_strdup(str);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ l2tp_reply->callback(l2tp_reply->provider, username, password, error,
+ l2tp_reply->user_data);
+
+ g_free(username);
+ g_free(password);
+
+ g_free(l2tp_reply);
+}
+
+typedef void (* request_cb_t)(struct vpn_provider *provider,
+ const char *username, const char *password,
+ const char *error, void *user_data);
+
+static int request_input(struct vpn_provider *provider,
+ request_cb_t callback, const char *dbus_sender,
+ void *user_data)
+{
+ DBusMessage *message;
+ const char *path, *agent_sender, *agent_path;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ struct request_input_reply *l2tp_reply;
+ int err;
+ void *agent;
+
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ if (!provider || !agent || !agent_path || !callback)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ VPN_AGENT_INTERFACE,
+ "RequestInput");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = vpn_provider_get_path(provider);
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_OBJECT_PATH, &path);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ vpn_agent_append_user_info(&dict, provider, "L2TP.User");
+
+ vpn_agent_append_host_and_name(&dict, provider);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ l2tp_reply = g_try_new0(struct request_input_reply, 1);
+ if (!l2tp_reply) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ l2tp_reply->provider = provider;
+ l2tp_reply->callback = callback;
+ l2tp_reply->user_data = user_data;
+
+ err = connman_agent_queue_message(provider, message,
+ connman_timeout_input_request(),
+ request_input_reply, l2tp_reply, agent);
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending agent request", err);
+ dbus_message_unref(message);
+ g_free(l2tp_reply);
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static int run_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, void *user_data,
+ const char *username, const char *password)
+{
+ char *l2tp_name, *pppd_name;
+ int l2tp_fd, pppd_fd;
+ int err;
+
+ if (!username || !password) {
+ DBG("Cannot connect username %s password %p",
+ username, password);
+ err = -EINVAL;
+ goto done;
+ }
+
+ DBG("username %s password %p", username, password);
+
+ l2tp_name = g_strdup_printf(VPN_STATEDIR "/connman-xl2tpd.conf");
+
+ l2tp_fd = open(l2tp_name, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
+ if (l2tp_fd < 0) {
+ g_free(l2tp_name);
+ connman_error("Error writing l2tp config");
+ err = -EIO;
+ goto done;
+ }
+
+ pppd_name = g_strdup_printf(VPN_STATEDIR "/connman-ppp-option.conf");
+
+ pppd_fd = open(pppd_name, O_RDWR|O_CREAT|O_TRUNC, S_IRUSR|S_IWUSR);
+ if (pppd_fd < 0) {
+ connman_error("Error writing pppd config");
+ g_free(l2tp_name);
+ g_free(pppd_name);
+ close(l2tp_fd);
+ err = -EIO;
+ goto done;
+ }
+
+ l2tp_write_config(provider, pppd_name, l2tp_fd);
+
+ write_pppd_option(provider, pppd_fd);
+
+ connman_task_add_argument(task, "-D", NULL);
+ connman_task_add_argument(task, "-c", l2tp_name);
+
+ g_free(l2tp_name);
+ g_free(pppd_name);
+ close(l2tp_fd);
+ close(pppd_fd);
+
+ err = connman_task_run(task, l2tp_died, provider,
+ NULL, NULL, NULL);
+ if (err < 0) {
+ connman_error("l2tp failed to start");
+ err = -EIO;
+ goto done;
+ }
+
+done:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static void free_private_data(struct l2tp_private_data *data)
+{
+ g_free(data->if_name);
+ g_free(data);
+}
+
+static void request_input_cb(struct vpn_provider *provider,
+ const char *username,
+ const char *password,
+ const char *error, void *user_data)
+{
+ struct l2tp_private_data *data = user_data;
+
+ if (!username || !password)
+ DBG("Requesting username %s or password failed, error %s",
+ username, error);
+ else if (error)
+ DBG("error %s", error);
+
+ vpn_provider_set_string(provider, "L2TP.User", username);
+ vpn_provider_set_string_hide_value(provider, "L2TP.Password",
+ password);
+
+ run_connect(provider, data->task, data->if_name, data->cb,
+ data->user_data, username, password);
+
+ free_private_data(data);
+}
+
+static int l2tp_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
+{
+ const char *username, *password;
+ int err;
+
+ if (connman_task_set_notify(task, "getsec",
+ l2tp_get_sec, provider) != 0) {
+ err = -ENOMEM;
+ goto error;
+ }
+
+ username = vpn_provider_get_string(provider, "L2TP.User");
+ password = vpn_provider_get_string(provider, "L2TP.Password");
+
+ DBG("user %s password %p", username, password);
+
+ if (!username || !password) {
+ struct l2tp_private_data *data;
+
+ data = g_try_new0(struct l2tp_private_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ data->task = task;
+ data->if_name = g_strdup(if_name);
+ data->cb = cb;
+ data->user_data = user_data;
+
+ err = request_input(provider, request_input_cb, dbus_sender,
+ data);
+ if (err != -EINPROGRESS) {
+ free_private_data(data);
+ goto done;
+ }
+ return err;
+ }
+
+done:
+ return run_connect(provider, task, if_name, cb, user_data,
+ username, password);
+
+error:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static int l2tp_error_code(struct vpn_provider *provider, int exit_code)
+{
+ switch (exit_code) {
+ case 1:
+ return CONNMAN_PROVIDER_ERROR_CONNECT_FAILED;
+ default:
+ return CONNMAN_PROVIDER_ERROR_UNKNOWN;
+ }
+}
+
+static void l2tp_disconnect(struct vpn_provider *provider)
+{
+ vpn_provider_set_string(provider, "L2TP.Password", NULL);
+}
+
+static struct vpn_driver vpn_driver = {
+ .flags = VPN_FLAG_NO_TUN,
+ .notify = l2tp_notify,
+ .connect = l2tp_connect,
+ .error_code = l2tp_error_code,
+ .save = l2tp_save,
+ .disconnect = l2tp_disconnect,
+};
+
+static int l2tp_init(void)
+{
+ connection = connman_dbus_get_connection();
+
+ return vpn_register("l2tp", &vpn_driver, L2TP);
+}
+
+static void l2tp_exit(void)
+{
+ vpn_unregister("l2tp");
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(l2tp, "l2tp plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, l2tp_init, l2tp_exit)
diff --git a/vpn/plugins/openconnect.c b/vpn/plugins/openconnect.c
new file mode 100644
index 0000000..5feaed9
--- /dev/null
+++ b/vpn/plugins/openconnect.c
@@ -0,0 +1,582 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <net/if.h>
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/log.h>
+#include <connman/task.h>
+#include <connman/ipconfig.h>
+#include <connman/dbus.h>
+#include <connman/agent.h>
+#include <connman/setting.h>
+#include <connman/vpn-dbus.h>
+
+#include "../vpn-provider.h"
+#include "../vpn-agent.h"
+
+#include "vpn.h"
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
+
+struct {
+ const char *cm_opt;
+ const char *oc_opt;
+ char has_value;
+} oc_options[] = {
+ { "OpenConnect.NoCertCheck", "--no-cert-check", 0 },
+};
+
+struct oc_private_data {
+ struct vpn_provider *provider;
+ struct connman_task *task;
+ char *if_name;
+ vpn_provider_connect_cb_t cb;
+ void *user_data;
+};
+
+static void free_private_data(struct oc_private_data *data)
+{
+ g_free(data->if_name);
+ g_free(data);
+}
+
+static int task_append_config_data(struct vpn_provider *provider,
+ struct connman_task *task)
+{
+ const char *option;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(oc_options); i++) {
+ if (!oc_options[i].oc_opt)
+ continue;
+
+ option = vpn_provider_get_string(provider,
+ oc_options[i].cm_opt);
+ if (!option)
+ continue;
+
+ if (connman_task_add_argument(task,
+ oc_options[i].oc_opt,
+ oc_options[i].has_value ? option : NULL) < 0)
+ return -EIO;
+ }
+
+ return 0;
+}
+
+static int oc_notify(DBusMessage *msg, struct vpn_provider *provider)
+{
+ DBusMessageIter iter, dict;
+ const char *reason, *key, *value;
+ char *domain = NULL;
+ char *addressv4 = NULL, *addressv6 = NULL;
+ char *netmask = NULL, *gateway = NULL;
+ unsigned char prefix_len = 0;
+ struct connman_ipaddress *ipaddress;
+
+ dbus_message_iter_init(msg, &iter);
+
+ dbus_message_iter_get_basic(&iter, &reason);
+ dbus_message_iter_next(&iter);
+
+ if (!provider) {
+ connman_error("No provider found");
+ return VPN_STATE_FAILURE;
+ }
+
+ if (strcmp(reason, "connect"))
+ return VPN_STATE_DISCONNECT;
+
+ domain = g_strdup(vpn_provider_get_string(provider, "VPN.Domain"));
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_get_basic(&entry, &value);
+
+ if (strcmp(key, "CISCO_CSTP_OPTIONS"))
+ DBG("%s = %s", key, value);
+
+ if (!strcmp(key, "VPNGATEWAY"))
+ gateway = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_ADDRESS"))
+ addressv4 = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP6_ADDRESS")) {
+ addressv6 = g_strdup(value);
+ prefix_len = 128;
+ }
+
+ if (!strcmp(key, "INTERNAL_IP4_NETMASK"))
+ netmask = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP6_NETMASK")) {
+ char *sep;
+
+ /* The netmask contains the address and the prefix */
+ sep = strchr(value, '/');
+ if (sep) {
+ unsigned char ip_len = sep - value;
+
+ addressv6 = g_strndup(value, ip_len);
+ prefix_len = (unsigned char)
+ strtol(sep + 1, NULL, 10);
+ }
+ }
+
+ if (!strcmp(key, "INTERNAL_IP4_DNS") ||
+ !strcmp(key, "INTERNAL_IP6_DNS"))
+ vpn_provider_set_nameservers(provider, value);
+
+ if (!strcmp(key, "CISCO_PROXY_PAC"))
+ vpn_provider_set_pac(provider, value);
+
+ if (!domain && !strcmp(key, "CISCO_DEF_DOMAIN")) {
+ g_free(domain);
+ domain = g_strdup(value);
+ }
+
+ if (g_str_has_prefix(key, "CISCO_SPLIT_INC") ||
+ g_str_has_prefix(key, "CISCO_IPV6_SPLIT_INC"))
+ vpn_provider_append_route(provider, key, value);
+
+ dbus_message_iter_next(&dict);
+ }
+
+ DBG("%p %p", addressv4, addressv6);
+
+ if (addressv4)
+ ipaddress = connman_ipaddress_alloc(AF_INET);
+ else if (addressv6)
+ ipaddress = connman_ipaddress_alloc(AF_INET6);
+ else
+ ipaddress = NULL;
+
+ if (!ipaddress) {
+ g_free(addressv4);
+ g_free(addressv6);
+ g_free(netmask);
+ g_free(gateway);
+ g_free(domain);
+
+ return VPN_STATE_FAILURE;
+ }
+
+ if (addressv4)
+ connman_ipaddress_set_ipv4(ipaddress, addressv4,
+ netmask, gateway);
+ else
+ connman_ipaddress_set_ipv6(ipaddress, addressv6,
+ prefix_len, gateway);
+ vpn_provider_set_ipaddress(provider, ipaddress);
+ vpn_provider_set_domain(provider, domain);
+
+ g_free(addressv4);
+ g_free(addressv6);
+ g_free(netmask);
+ g_free(gateway);
+ g_free(domain);
+ connman_ipaddress_free(ipaddress);
+
+ return VPN_STATE_CONNECT;
+}
+
+static int run_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, void *user_data)
+{
+ const char *vpnhost, *vpncookie, *servercert, *mtu;
+ int fd, err = 0, len;
+
+ vpnhost = vpn_provider_get_string(provider, "OpenConnect.VPNHost");
+ if (!vpnhost)
+ vpnhost = vpn_provider_get_string(provider, "Host");
+ vpncookie = vpn_provider_get_string(provider, "OpenConnect.Cookie");
+ servercert = vpn_provider_get_string(provider,
+ "OpenConnect.ServerCert");
+
+ if (!vpncookie || !servercert) {
+ err = -EINVAL;
+ goto done;
+ }
+
+ task_append_config_data(provider, task);
+
+ connman_task_add_argument(task, "--servercert", servercert);
+
+ mtu = vpn_provider_get_string(provider, "VPN.MTU");
+
+ if (mtu)
+ connman_task_add_argument(task, "--mtu", (char *)mtu);
+
+ connman_task_add_argument(task, "--syslog", NULL);
+ connman_task_add_argument(task, "--cookie-on-stdin", NULL);
+
+ connman_task_add_argument(task, "--script",
+ SCRIPTDIR "/openconnect-script");
+
+ connman_task_add_argument(task, "--interface", if_name);
+
+ connman_task_add_argument(task, (char *)vpnhost, NULL);
+
+ err = connman_task_run(task, vpn_died, provider,
+ &fd, NULL, NULL);
+ if (err < 0) {
+ connman_error("openconnect failed to start");
+ err = -EIO;
+ goto done;
+ }
+
+ len = strlen(vpncookie);
+ if (write(fd, vpncookie, len) != (ssize_t)len ||
+ write(fd, "\n", 1) != 1) {
+ connman_error("openconnect failed to take cookie on stdin");
+ err = -EIO;
+ goto done;
+ }
+
+done:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static void request_input_append_informational(DBusMessageIter *iter,
+ void *user_data)
+{
+ const char *str;
+
+ str = "string";
+ connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING, &str);
+
+ str = "informational";
+ connman_dbus_dict_append_basic(iter, "Requirement", DBUS_TYPE_STRING,
+ &str);
+
+ str = user_data;
+ connman_dbus_dict_append_basic(iter, "Value", DBUS_TYPE_STRING, &str);
+}
+
+static void request_input_append_mandatory(DBusMessageIter *iter,
+ void *user_data)
+{
+ char *str = "string";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "mandatory";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void request_input_cookie_reply(DBusMessage *reply, void *user_data)
+{
+ struct oc_private_data *data = user_data;
+ char *cookie = NULL, *servercert = NULL, *vpnhost = NULL;
+ char *key;
+ DBusMessageIter iter, dict;
+
+ DBG("provider %p", data->provider);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR)
+ goto err;
+
+ if (!vpn_agent_check_reply_has_dict(reply))
+ goto err;
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ if (g_str_equal(key, "OpenConnect.Cookie")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &cookie);
+ vpn_provider_set_string_hide_value(data->provider,
+ key, cookie);
+
+ } else if (g_str_equal(key, "OpenConnect.ServerCert")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &servercert);
+ vpn_provider_set_string(data->provider, key,
+ servercert);
+
+ } else if (g_str_equal(key, "OpenConnect.VPNHost")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &vpnhost);
+ vpn_provider_set_string(data->provider, key, vpnhost);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (!cookie || !servercert || !vpnhost)
+ goto err;
+
+ run_connect(data->provider, data->task, data->if_name, data->cb,
+ data->user_data);
+
+ free_private_data(data);
+
+ return;
+
+err:
+ vpn_provider_indicate_error(data->provider,
+ VPN_PROVIDER_ERROR_AUTH_FAILED);
+
+ free_private_data(data);
+}
+
+static int request_cookie_input(struct vpn_provider *provider,
+ struct oc_private_data *data,
+ const char *dbus_sender)
+{
+ DBusMessage *message;
+ const char *path, *agent_sender, *agent_path;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ const char *str;
+ int err;
+ void *agent;
+
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ if (!provider || !agent || !agent_path)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ VPN_AGENT_INTERFACE,
+ "RequestInput");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = vpn_provider_get_path(provider);
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_OBJECT_PATH, &path);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ str = vpn_provider_get_string(provider, "OpenConnect.CACert");
+ if (str)
+ connman_dbus_dict_append_dict(&dict, "OpenConnect.CACert",
+ request_input_append_informational,
+ (void *)str);
+
+ str = vpn_provider_get_string(provider, "OpenConnect.ClientCert");
+ if (str)
+ connman_dbus_dict_append_dict(&dict, "OpenConnect.ClientCert",
+ request_input_append_informational,
+ (void *)str);
+
+ connman_dbus_dict_append_dict(&dict, "OpenConnect.ServerCert",
+ request_input_append_mandatory, NULL);
+
+ connman_dbus_dict_append_dict(&dict, "OpenConnect.VPNHost",
+ request_input_append_mandatory, NULL);
+
+ connman_dbus_dict_append_dict(&dict, "OpenConnect.Cookie",
+ request_input_append_mandatory, NULL);
+
+ vpn_agent_append_host_and_name(&dict, provider);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ err = connman_agent_queue_message(provider, message,
+ connman_timeout_input_request(),
+ request_input_cookie_reply, data, agent);
+
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending agent request", err);
+ dbus_message_unref(message);
+
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static int oc_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb,
+ const char *dbus_sender, void *user_data)
+{
+ const char *vpnhost, *vpncookie, *servercert;
+ int err;
+
+ vpnhost = vpn_provider_get_string(provider, "Host");
+ if (!vpnhost) {
+ connman_error("Host not set; cannot enable VPN");
+ return -EINVAL;
+ }
+
+ vpncookie = vpn_provider_get_string(provider, "OpenConnect.Cookie");
+ servercert = vpn_provider_get_string(provider,
+ "OpenConnect.ServerCert");
+ if (!vpncookie || !servercert) {
+ struct oc_private_data *data;
+
+ data = g_try_new0(struct oc_private_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ data->provider = provider;
+ data->task = task;
+ data->if_name = g_strdup(if_name);
+ data->cb = cb;
+ data->user_data = user_data;
+
+ err = request_cookie_input(provider, data, dbus_sender);
+ if (err != -EINPROGRESS) {
+ vpn_provider_indicate_error(data->provider,
+ VPN_PROVIDER_ERROR_LOGIN_FAILED);
+ free_private_data(data);
+ }
+ return err;
+ }
+
+ return run_connect(provider, task, if_name, cb, user_data);
+}
+
+static int oc_save(struct vpn_provider *provider, GKeyFile *keyfile)
+{
+ const char *setting, *option;
+ int i;
+
+ setting = vpn_provider_get_string(provider,
+ "OpenConnect.ServerCert");
+ if (setting)
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ "OpenConnect.ServerCert", setting);
+
+ setting = vpn_provider_get_string(provider,
+ "OpenConnect.CACert");
+ if (setting)
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ "OpenConnect.CACert", setting);
+
+ setting = vpn_provider_get_string(provider,
+ "VPN.MTU");
+ if (setting)
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ "VPN.MTU", setting);
+
+ for (i = 0; i < (int)ARRAY_SIZE(oc_options); i++) {
+ if (strncmp(oc_options[i].cm_opt, "OpenConnect.", 12) == 0) {
+ option = vpn_provider_get_string(provider,
+ oc_options[i].cm_opt);
+ if (!option)
+ continue;
+
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ oc_options[i].cm_opt, option);
+ }
+ }
+
+ return 0;
+}
+
+static int oc_error_code(struct vpn_provider *provider, int exit_code)
+{
+
+ switch (exit_code) {
+ case 1:
+ case 2:
+ vpn_provider_set_string_hide_value(provider,
+ "OpenConnect.Cookie", NULL);
+ return VPN_PROVIDER_ERROR_LOGIN_FAILED;
+ default:
+ return VPN_PROVIDER_ERROR_UNKNOWN;
+ }
+}
+
+static struct vpn_driver vpn_driver = {
+ .notify = oc_notify,
+ .connect = oc_connect,
+ .error_code = oc_error_code,
+ .save = oc_save,
+};
+
+static int openconnect_init(void)
+{
+ return vpn_register("openconnect", &vpn_driver, OPENCONNECT);
+}
+
+static void openconnect_exit(void)
+{
+ vpn_unregister("openconnect");
+}
+
+CONNMAN_PLUGIN_DEFINE(openconnect, "OpenConnect VPN plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, openconnect_init, openconnect_exit)
diff --git a/vpn/plugins/openvpn.c b/vpn/plugins/openvpn.c
new file mode 100644
index 0000000..9ee5795
--- /dev/null
+++ b/vpn/plugins/openvpn.c
@@ -0,0 +1,419 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2010-2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <net/if.h>
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/log.h>
+#include <connman/task.h>
+#include <connman/dbus.h>
+#include <connman/ipconfig.h>
+
+#include "../vpn-provider.h"
+
+#include "vpn.h"
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
+
+static DBusConnection *connection;
+
+struct {
+ const char *cm_opt;
+ const char *ov_opt;
+ char has_value;
+} ov_options[] = {
+ { "Host", "--remote", 1 },
+ { "OpenVPN.CACert", "--ca", 1 },
+ { "OpenVPN.Cert", "--cert", 1 },
+ { "OpenVPN.Key", "--key", 1 },
+ { "OpenVPN.MTU", "--mtu", 1 },
+ { "OpenVPN.NSCertType", "--ns-cert-type", 1 },
+ { "OpenVPN.Proto", "--proto", 1 },
+ { "OpenVPN.Port", "--port", 1 },
+ { "OpenVPN.AuthUserPass", "--auth-user-pass", 1 },
+ { "OpenVPN.AskPass", "--askpass", 1 },
+ { "OpenVPN.AuthNoCache", "--auth-nocache", 0 },
+ { "OpenVPN.TLSRemote", "--tls-remote", 1 },
+ { "OpenVPN.TLSAuth", NULL, 1 },
+ { "OpenVPN.TLSAuthDir", NULL, 1 },
+ { "OpenVPN.Cipher", "--cipher", 1 },
+ { "OpenVPN.Auth", "--auth", 1 },
+ { "OpenVPN.CompLZO", "--comp-lzo", 0 },
+ { "OpenVPN.RemoteCertTls", "--remote-cert-tls", 1 },
+ { "OpenVPN.ConfigFile", "--config", 1 },
+};
+
+struct nameserver_entry {
+ int id;
+ char *nameserver;
+};
+
+static struct nameserver_entry *ov_append_dns_entries(const char *key,
+ const char *value)
+{
+ struct nameserver_entry *entry = NULL;
+ gchar **options;
+
+ if (!g_str_has_prefix(key, "foreign_option_"))
+ return NULL;
+
+ options = g_strsplit(value, " ", 3);
+ if (options[0] &&
+ !strcmp(options[0], "dhcp-option") &&
+ options[1] &&
+ !strcmp(options[1], "DNS") &&
+ options[2]) {
+
+ entry = g_try_new(struct nameserver_entry, 1);
+ if (!entry)
+ return NULL;
+
+ entry->nameserver = g_strdup(options[2]);
+ entry->id = atoi(key + 15); /* foreign_option_XXX */
+ }
+
+ g_strfreev(options);
+
+ return entry;
+}
+
+static char *ov_get_domain_name(const char *key, const char *value)
+{
+ gchar **options;
+ char *domain = NULL;
+
+ if (!g_str_has_prefix(key, "foreign_option_"))
+ return NULL;
+
+ options = g_strsplit(value, " ", 3);
+ if (options[0] &&
+ !strcmp(options[0], "dhcp-option") &&
+ options[1] &&
+ !strcmp(options[1], "DOMAIN") &&
+ options[2]) {
+
+ domain = g_strdup(options[2]);
+ }
+
+ g_strfreev(options);
+
+ return domain;
+}
+
+static gint cmp_ns(gconstpointer a, gconstpointer b)
+{
+ struct nameserver_entry *entry_a = (struct nameserver_entry *)a;
+ struct nameserver_entry *entry_b = (struct nameserver_entry *)b;
+
+ if (entry_a->id < entry_b->id)
+ return -1;
+
+ if (entry_a->id > entry_b->id)
+ return 1;
+
+ return 0;
+}
+
+static void free_ns_entry(gpointer data)
+{
+ struct nameserver_entry *entry = data;
+
+ g_free(entry->nameserver);
+ g_free(entry);
+}
+
+static int ov_notify(DBusMessage *msg, struct vpn_provider *provider)
+{
+ DBusMessageIter iter, dict;
+ const char *reason, *key, *value;
+ char *address = NULL, *gateway = NULL, *peer = NULL;
+ struct connman_ipaddress *ipaddress;
+ GSList *nameserver_list = NULL;
+
+ dbus_message_iter_init(msg, &iter);
+
+ dbus_message_iter_get_basic(&iter, &reason);
+ dbus_message_iter_next(&iter);
+
+ if (!provider) {
+ connman_error("No provider found");
+ return VPN_STATE_FAILURE;
+ }
+
+ if (strcmp(reason, "up"))
+ return VPN_STATE_DISCONNECT;
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ struct nameserver_entry *ns_entry = NULL;
+ DBusMessageIter entry;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_get_basic(&entry, &value);
+
+ DBG("%s = %s", key, value);
+
+ if (!strcmp(key, "trusted_ip"))
+ gateway = g_strdup(value);
+
+ if (!strcmp(key, "ifconfig_local"))
+ address = g_strdup(value);
+
+ if (!strcmp(key, "ifconfig_remote"))
+ peer = g_strdup(value);
+
+ if (g_str_has_prefix(key, "route_"))
+ vpn_provider_append_route(provider, key, value);
+
+ if ((ns_entry = ov_append_dns_entries(key, value)))
+ nameserver_list = g_slist_prepend(nameserver_list,
+ ns_entry);
+ else {
+ char *domain = ov_get_domain_name(key, value);
+ if (domain) {
+ vpn_provider_set_domain(provider, domain);
+ g_free(domain);
+ }
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+ ipaddress = connman_ipaddress_alloc(AF_INET);
+ if (!ipaddress) {
+ g_slist_free_full(nameserver_list, free_ns_entry);
+ g_free(address);
+ g_free(gateway);
+ g_free(peer);
+
+ return VPN_STATE_FAILURE;
+ }
+
+ connman_ipaddress_set_ipv4(ipaddress, address, NULL, gateway);
+ connman_ipaddress_set_peer(ipaddress, peer);
+ vpn_provider_set_ipaddress(provider, ipaddress);
+
+ if (nameserver_list) {
+ char *nameservers = NULL;
+ GSList *tmp;
+
+ nameserver_list = g_slist_sort(nameserver_list, cmp_ns);
+ for (tmp = nameserver_list; tmp;
+ tmp = g_slist_next(tmp)) {
+ struct nameserver_entry *ns = tmp->data;
+
+ if (!nameservers) {
+ nameservers = g_strdup(ns->nameserver);
+ } else {
+ char *str;
+ str = g_strjoin(" ", nameservers,
+ ns->nameserver, NULL);
+ g_free(nameservers);
+ nameservers = str;
+ }
+ }
+
+ g_slist_free_full(nameserver_list, free_ns_entry);
+
+ vpn_provider_set_nameservers(provider, nameservers);
+
+ g_free(nameservers);
+ }
+
+ g_free(address);
+ g_free(gateway);
+ g_free(peer);
+ connman_ipaddress_free(ipaddress);
+
+ return VPN_STATE_CONNECT;
+}
+
+static int ov_save(struct vpn_provider *provider, GKeyFile *keyfile)
+{
+ const char *option;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(ov_options); i++) {
+ if (strncmp(ov_options[i].cm_opt, "OpenVPN.", 8) == 0) {
+ option = vpn_provider_get_string(provider,
+ ov_options[i].cm_opt);
+ if (!option)
+ continue;
+
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ ov_options[i].cm_opt, option);
+ }
+ }
+ return 0;
+}
+
+static int task_append_config_data(struct vpn_provider *provider,
+ struct connman_task *task)
+{
+ const char *option;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(ov_options); i++) {
+ if (!ov_options[i].ov_opt)
+ continue;
+
+ option = vpn_provider_get_string(provider,
+ ov_options[i].cm_opt);
+ if (!option)
+ continue;
+
+ if (connman_task_add_argument(task,
+ ov_options[i].ov_opt,
+ ov_options[i].has_value ? option : NULL) < 0) {
+ return -EIO;
+ }
+ }
+
+ return 0;
+}
+
+static int ov_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
+{
+ const char *option;
+ int err = 0, fd;
+
+ option = vpn_provider_get_string(provider, "Host");
+ if (!option) {
+ connman_error("Host not set; cannot enable VPN");
+ return -EINVAL;
+ }
+
+ task_append_config_data(provider, task);
+
+ option = vpn_provider_get_string(provider, "OpenVPN.ConfigFile");
+ if (!option) {
+ /*
+ * Set some default options if user has no config file.
+ */
+ option = vpn_provider_get_string(provider, "OpenVPN.TLSAuth");
+ if (option) {
+ connman_task_add_argument(task, "--tls-auth", option);
+ option = vpn_provider_get_string(provider,
+ "OpenVPN.TLSAuthDir");
+ if (option)
+ connman_task_add_argument(task, option, NULL);
+ }
+
+ connman_task_add_argument(task, "--nobind", NULL);
+ connman_task_add_argument(task, "--persist-key", NULL);
+ connman_task_add_argument(task, "--client", NULL);
+ }
+
+ connman_task_add_argument(task, "--syslog", NULL);
+
+ connman_task_add_argument(task, "--script-security", "2");
+
+ connman_task_add_argument(task, "--up",
+ SCRIPTDIR "/openvpn-script");
+ connman_task_add_argument(task, "--up-restart", NULL);
+
+ connman_task_add_argument(task, "--setenv", NULL);
+ connman_task_add_argument(task, "CONNMAN_BUSNAME",
+ dbus_bus_get_unique_name(connection));
+
+ connman_task_add_argument(task, "--setenv", NULL);
+ connman_task_add_argument(task, "CONNMAN_INTERFACE",
+ CONNMAN_TASK_INTERFACE);
+
+ connman_task_add_argument(task, "--setenv", NULL);
+ connman_task_add_argument(task, "CONNMAN_PATH",
+ connman_task_get_path(task));
+
+ connman_task_add_argument(task, "--dev", if_name);
+ connman_task_add_argument(task, "--dev-type", "tun");
+
+ connman_task_add_argument(task, "--persist-tun", NULL);
+
+ connman_task_add_argument(task, "--route-noexec", NULL);
+ connman_task_add_argument(task, "--ifconfig-noexec", NULL);
+
+ /*
+ * Disable client restarts because we can't handle this at the
+ * moment. The problem is that when OpenVPN decides to switch
+ * from CONNECTED state to RECONNECTING and then to RESOLVE,
+ * it is not possible to do a DNS lookup. The DNS server is
+ * not accessable through the tunnel anymore and so we end up
+ * trying to resolve the OpenVPN servers address.
+ */
+ connman_task_add_argument(task, "--ping-restart", "0");
+
+ fd = fileno(stderr);
+ err = connman_task_run(task, vpn_died, provider,
+ NULL, &fd, &fd);
+ if (err < 0) {
+ connman_error("openvpn failed to start");
+ err = -EIO;
+ goto done;
+ }
+
+done:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static struct vpn_driver vpn_driver = {
+ .notify = ov_notify,
+ .connect = ov_connect,
+ .save = ov_save,
+};
+
+static int openvpn_init(void)
+{
+ connection = connman_dbus_get_connection();
+
+ return vpn_register("openvpn", &vpn_driver, OPENVPN);
+}
+
+static void openvpn_exit(void)
+{
+ vpn_unregister("openvpn");
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(openvpn, "OpenVPN plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, openvpn_init, openvpn_exit)
diff --git a/vpn/plugins/pptp.c b/vpn/plugins/pptp.c
new file mode 100644
index 0000000..9f2a214
--- /dev/null
+++ b/vpn/plugins/pptp.c
@@ -0,0 +1,622 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2010,2013-2014 BMW Car IT GmbH.
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <net/if.h>
+
+#include <dbus/dbus.h>
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/provider.h>
+#include <connman/log.h>
+#include <connman/task.h>
+#include <connman/dbus.h>
+#include <connman/inet.h>
+#include <connman/agent.h>
+#include <connman/setting.h>
+#include <connman/vpn-dbus.h>
+
+#include "../vpn-provider.h"
+#include "../vpn-agent.h"
+
+#include "vpn.h"
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
+
+enum {
+ OPT_STRING = 1,
+ OPT_BOOL = 2,
+};
+
+struct {
+ const char *cm_opt;
+ const char *pptp_opt;
+ const char *vpnc_default;
+ int type;
+} pptp_options[] = {
+ { "PPTP.User", "user", NULL, OPT_STRING },
+ { "PPPD.EchoFailure", "lcp-echo-failure", "0", OPT_STRING },
+ { "PPPD.EchoInterval", "lcp-echo-interval", "0", OPT_STRING },
+ { "PPPD.Debug", "debug", NULL, OPT_STRING },
+ { "PPPD.RefuseEAP", "refuse-eap", NULL, OPT_BOOL },
+ { "PPPD.RefusePAP", "refuse-pap", NULL, OPT_BOOL },
+ { "PPPD.RefuseCHAP", "refuse-chap", NULL, OPT_BOOL },
+ { "PPPD.RefuseMSCHAP", "refuse-mschap", NULL, OPT_BOOL },
+ { "PPPD.RefuseMSCHAP2", "refuse-mschapv2", NULL, OPT_BOOL },
+ { "PPPD.NoBSDComp", "nobsdcomp", NULL, OPT_BOOL },
+ { "PPPD.NoDeflate", "nodeflate", NULL, OPT_BOOL },
+ { "PPPD.RequirMPPE", "require-mppe", NULL, OPT_BOOL },
+ { "PPPD.RequirMPPE40", "require-mppe-40", NULL, OPT_BOOL },
+ { "PPPD.RequirMPPE128", "require-mppe-128", NULL, OPT_BOOL },
+ { "PPPD.RequirMPPEStateful", "mppe-stateful", NULL, OPT_BOOL },
+ { "PPPD.NoVJ", "no-vj-comp", NULL, OPT_BOOL },
+};
+
+static DBusConnection *connection;
+
+struct pptp_private_data {
+ struct connman_task *task;
+ char *if_name;
+ vpn_provider_connect_cb_t cb;
+ void *user_data;
+};
+
+static DBusMessage *pptp_get_sec(struct connman_task *task,
+ DBusMessage *msg, void *user_data)
+{
+ const char *user, *passwd;
+ struct vpn_provider *provider = user_data;
+ DBusMessage *reply;
+
+ if (dbus_message_get_no_reply(msg))
+ return NULL;
+
+ user = vpn_provider_get_string(provider, "PPTP.User");
+ passwd = vpn_provider_get_string(provider, "PPTP.Password");
+ if (!user || strlen(user) == 0 ||
+ !passwd || strlen(passwd) == 0)
+ return NULL;
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_append_args(reply, DBUS_TYPE_STRING, &user,
+ DBUS_TYPE_STRING, &passwd,
+ DBUS_TYPE_INVALID);
+ return reply;
+}
+
+static int pptp_notify(DBusMessage *msg, struct vpn_provider *provider)
+{
+ DBusMessageIter iter, dict;
+ const char *reason, *key, *value;
+ char *addressv4 = NULL, *netmask = NULL, *gateway = NULL;
+ char *ifname = NULL, *nameservers = NULL;
+ struct connman_ipaddress *ipaddress = NULL;
+
+ dbus_message_iter_init(msg, &iter);
+
+ dbus_message_iter_get_basic(&iter, &reason);
+ dbus_message_iter_next(&iter);
+
+ if (!provider) {
+ connman_error("No provider found");
+ return VPN_STATE_FAILURE;
+ }
+
+ if (strcmp(reason, "auth failed") == 0) {
+ DBG("authentication failure");
+
+ vpn_provider_set_string(provider, "PPTP.User", NULL);
+ vpn_provider_set_string(provider, "PPTP.Password", NULL);
+
+ return VPN_STATE_AUTH_FAILURE;
+ }
+
+ if (strcmp(reason, "connect"))
+ return VPN_STATE_DISCONNECT;
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_get_basic(&entry, &value);
+
+ DBG("%s = %s", key, value);
+
+ if (!strcmp(key, "INTERNAL_IP4_ADDRESS"))
+ addressv4 = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_NETMASK"))
+ netmask = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_DNS"))
+ nameservers = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IFNAME"))
+ ifname = g_strdup(value);
+
+ dbus_message_iter_next(&dict);
+ }
+
+ if (vpn_set_ifname(provider, ifname) < 0) {
+ g_free(ifname);
+ g_free(addressv4);
+ g_free(netmask);
+ g_free(nameservers);
+ return VPN_STATE_FAILURE;
+ }
+
+ if (addressv4)
+ ipaddress = connman_ipaddress_alloc(AF_INET);
+
+ g_free(ifname);
+
+ if (!ipaddress) {
+ connman_error("No IP address for provider");
+ g_free(addressv4);
+ g_free(netmask);
+ g_free(nameservers);
+ return VPN_STATE_FAILURE;
+ }
+
+ value = vpn_provider_get_string(provider, "HostIP");
+ if (value) {
+ vpn_provider_set_string(provider, "Gateway", value);
+ gateway = g_strdup(value);
+ }
+
+ if (addressv4)
+ connman_ipaddress_set_ipv4(ipaddress, addressv4, netmask,
+ gateway);
+
+ vpn_provider_set_ipaddress(provider, ipaddress);
+ vpn_provider_set_nameservers(provider, nameservers);
+
+ g_free(addressv4);
+ g_free(netmask);
+ g_free(gateway);
+ g_free(nameservers);
+ connman_ipaddress_free(ipaddress);
+
+ return VPN_STATE_CONNECT;
+}
+
+static int pptp_save(struct vpn_provider *provider, GKeyFile *keyfile)
+{
+ const char *option;
+ bool pptp_option, pppd_option;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(pptp_options); i++) {
+ pptp_option = pppd_option = false;
+
+ if (strncmp(pptp_options[i].cm_opt, "PPTP.", 5) == 0)
+ pptp_option = true;
+
+ if (strncmp(pptp_options[i].cm_opt, "PPPD.", 5) == 0)
+ pppd_option = true;
+
+ if (pptp_option || pppd_option) {
+ option = vpn_provider_get_string(provider,
+ pptp_options[i].cm_opt);
+ if (!option) {
+ /*
+ * Check if the option prefix is PPTP as the
+ * PPPD options were using PPTP prefix earlier.
+ */
+ char *pptp_str;
+
+ if (!pppd_option)
+ continue;
+
+ pptp_str = g_strdup_printf("PPTP.%s",
+ &pptp_options[i].cm_opt[5]);
+ option = vpn_provider_get_string(provider,
+ pptp_str);
+ g_free(pptp_str);
+
+ if (!option)
+ continue;
+ }
+
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ pptp_options[i].cm_opt, option);
+ }
+ }
+
+ return 0;
+}
+
+static void pptp_write_bool_option(struct connman_task *task,
+ const char *key, const char *value)
+{
+ if (key && value) {
+ if (strcasecmp(value, "yes") == 0 ||
+ strcasecmp(value, "true") == 0 ||
+ strcmp(value, "1") == 0)
+ connman_task_add_argument(task, key, NULL);
+ }
+}
+
+struct request_input_reply {
+ struct vpn_provider *provider;
+ vpn_provider_password_cb_t callback;
+ void *user_data;
+};
+
+static void request_input_reply(DBusMessage *reply, void *user_data)
+{
+ struct request_input_reply *pptp_reply = user_data;
+ const char *error = NULL;
+ char *username = NULL, *password = NULL;
+ char *key;
+ DBusMessageIter iter, dict;
+
+ DBG("provider %p", pptp_reply->provider);
+
+ if (dbus_message_get_type(reply) == DBUS_MESSAGE_TYPE_ERROR) {
+ error = dbus_message_get_error_name(reply);
+ goto done;
+ }
+
+ if (!vpn_agent_check_reply_has_dict(reply))
+ goto done;
+
+ dbus_message_iter_init(reply, &iter);
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *str;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ break;
+
+ dbus_message_iter_get_basic(&entry, &key);
+
+ if (g_str_equal(key, "Username")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &str);
+ username = g_strdup(str);
+ }
+
+ if (g_str_equal(key, "Password")) {
+ dbus_message_iter_next(&entry);
+ if (dbus_message_iter_get_arg_type(&entry)
+ != DBUS_TYPE_VARIANT)
+ break;
+ dbus_message_iter_recurse(&entry, &value);
+ if (dbus_message_iter_get_arg_type(&value)
+ != DBUS_TYPE_STRING)
+ break;
+ dbus_message_iter_get_basic(&value, &str);
+ password = g_strdup(str);
+ }
+
+ dbus_message_iter_next(&dict);
+ }
+
+done:
+ pptp_reply->callback(pptp_reply->provider, username, password, error,
+ pptp_reply->user_data);
+
+ g_free(username);
+ g_free(password);
+
+ g_free(pptp_reply);
+}
+
+typedef void (* request_cb_t)(struct vpn_provider *provider,
+ const char *username, const char *password,
+ const char *error, void *user_data);
+
+static int request_input(struct vpn_provider *provider,
+ request_cb_t callback, const char *dbus_sender,
+ void *user_data)
+{
+ DBusMessage *message;
+ const char *path, *agent_sender, *agent_path;
+ DBusMessageIter iter;
+ DBusMessageIter dict;
+ struct request_input_reply *pptp_reply;
+ int err;
+ void *agent;
+
+ agent = connman_agent_get_info(dbus_sender, &agent_sender,
+ &agent_path);
+ if (!provider || !agent || !agent_path || !callback)
+ return -ESRCH;
+
+ message = dbus_message_new_method_call(agent_sender, agent_path,
+ VPN_AGENT_INTERFACE,
+ "RequestInput");
+ if (!message)
+ return -ENOMEM;
+
+ dbus_message_iter_init_append(message, &iter);
+
+ path = vpn_provider_get_path(provider);
+ dbus_message_iter_append_basic(&iter,
+ DBUS_TYPE_OBJECT_PATH, &path);
+
+ connman_dbus_dict_open(&iter, &dict);
+
+ vpn_agent_append_user_info(&dict, provider, "PPTP.User");
+
+ vpn_agent_append_host_and_name(&dict, provider);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ pptp_reply = g_try_new0(struct request_input_reply, 1);
+ if (!pptp_reply) {
+ dbus_message_unref(message);
+ return -ENOMEM;
+ }
+
+ pptp_reply->provider = provider;
+ pptp_reply->callback = callback;
+ pptp_reply->user_data = user_data;
+
+ err = connman_agent_queue_message(provider, message,
+ connman_timeout_input_request(),
+ request_input_reply, pptp_reply, agent);
+ if (err < 0 && err != -EBUSY) {
+ DBG("error %d sending agent request", err);
+ dbus_message_unref(message);
+ g_free(pptp_reply);
+ return err;
+ }
+
+ dbus_message_unref(message);
+
+ return -EINPROGRESS;
+}
+
+static int run_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, void *user_data,
+ const char *username, const char *password)
+{
+ const char *opt_s, *host;
+ char *str;
+ int err, i;
+
+ host = vpn_provider_get_string(provider, "Host");
+ if (!host) {
+ connman_error("Host not set; cannot enable VPN");
+ err = -EINVAL;
+ goto done;
+ }
+
+ if (!username || !password) {
+ DBG("Cannot connect username %s password %p",
+ username, password);
+ err = -EINVAL;
+ goto done;
+ }
+
+ DBG("username %s password %p", username, password);
+
+ str = g_strdup_printf("%s %s --nolaunchpppd --loglevel 2",
+ PPTP, host);
+ if (!str) {
+ connman_error("can not allocate memory");
+ err = -ENOMEM;
+ goto done;
+ }
+
+ connman_task_add_argument(task, "pty", str);
+ g_free(str);
+
+ connman_task_add_argument(task, "nodetach", NULL);
+ connman_task_add_argument(task, "lock", NULL);
+ connman_task_add_argument(task, "usepeerdns", NULL);
+ connman_task_add_argument(task, "noipdefault", NULL);
+ connman_task_add_argument(task, "noauth", NULL);
+ connman_task_add_argument(task, "nodefaultroute", NULL);
+ connman_task_add_argument(task, "ipparam", "pptp_plugin");
+
+ for (i = 0; i < (int)ARRAY_SIZE(pptp_options); i++) {
+ opt_s = vpn_provider_get_string(provider,
+ pptp_options[i].cm_opt);
+ if (!opt_s)
+ opt_s = pptp_options[i].vpnc_default;
+
+ if (!opt_s)
+ continue;
+
+ if (pptp_options[i].type == OPT_STRING)
+ connman_task_add_argument(task,
+ pptp_options[i].pptp_opt, opt_s);
+ else if (pptp_options[i].type == OPT_BOOL)
+ pptp_write_bool_option(task,
+ pptp_options[i].pptp_opt, opt_s);
+ }
+
+ connman_task_add_argument(task, "plugin",
+ SCRIPTDIR "/libppp-plugin.so");
+
+ err = connman_task_run(task, vpn_died, provider,
+ NULL, NULL, NULL);
+ if (err < 0) {
+ connman_error("pptp failed to start");
+ err = -EIO;
+ goto done;
+ }
+
+done:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static void free_private_data(struct pptp_private_data *data)
+{
+ g_free(data->if_name);
+ g_free(data);
+}
+
+static void request_input_cb(struct vpn_provider *provider,
+ const char *username,
+ const char *password,
+ const char *error, void *user_data)
+{
+ struct pptp_private_data *data = user_data;
+
+ if (!username || !password)
+ DBG("Requesting username %s or password failed, error %s",
+ username, error);
+ else if (error)
+ DBG("error %s", error);
+
+ vpn_provider_set_string(provider, "PPTP.User", username);
+ vpn_provider_set_string_hide_value(provider, "PPTP.Password",
+ password);
+
+ run_connect(provider, data->task, data->if_name, data->cb,
+ data->user_data, username, password);
+
+ free_private_data(data);
+}
+
+static int pptp_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
+{
+ const char *username, *password;
+ int err;
+
+ DBG("iface %s provider %p user %p", if_name, provider, user_data);
+
+ if (connman_task_set_notify(task, "getsec",
+ pptp_get_sec, provider)) {
+ err = -ENOMEM;
+ goto error;
+ }
+
+ username = vpn_provider_get_string(provider, "PPTP.User");
+ password = vpn_provider_get_string(provider, "PPTP.Password");
+
+ DBG("user %s password %p", username, password);
+
+ if (!username || !password) {
+ struct pptp_private_data *data;
+
+ data = g_try_new0(struct pptp_private_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ data->task = task;
+ data->if_name = g_strdup(if_name);
+ data->cb = cb;
+ data->user_data = user_data;
+
+ err = request_input(provider, request_input_cb, dbus_sender,
+ data);
+ if (err != -EINPROGRESS) {
+ free_private_data(data);
+ goto done;
+ }
+ return err;
+ }
+
+done:
+ return run_connect(provider, task, if_name, cb, user_data,
+ username, password);
+
+error:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static int pptp_error_code(struct vpn_provider *provider, int exit_code)
+{
+
+ switch (exit_code) {
+ case 1:
+ return CONNMAN_PROVIDER_ERROR_CONNECT_FAILED;
+ case 2:
+ return CONNMAN_PROVIDER_ERROR_LOGIN_FAILED;
+ case 16:
+ return CONNMAN_PROVIDER_ERROR_AUTH_FAILED;
+ default:
+ return CONNMAN_PROVIDER_ERROR_UNKNOWN;
+ }
+}
+
+static void pptp_disconnect(struct vpn_provider *provider)
+{
+ vpn_provider_set_string(provider, "PPTP.Password", NULL);
+}
+
+static struct vpn_driver vpn_driver = {
+ .flags = VPN_FLAG_NO_TUN,
+ .notify = pptp_notify,
+ .connect = pptp_connect,
+ .error_code = pptp_error_code,
+ .save = pptp_save,
+ .disconnect = pptp_disconnect,
+};
+
+static int pptp_init(void)
+{
+ connection = connman_dbus_get_connection();
+
+ return vpn_register("pptp", &vpn_driver, PPPD);
+}
+
+static void pptp_exit(void)
+{
+ vpn_unregister("pptp");
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(pptp, "pptp plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, pptp_init, pptp_exit)
diff --git a/vpn/plugins/vpn.c b/vpn/plugins/vpn.c
new file mode 100644
index 0000000..b438d06
--- /dev/null
+++ b/vpn/plugins/vpn.c
@@ -0,0 +1,608 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <linux/if_tun.h>
+#include <net/if.h>
+
+#include <dbus/dbus.h>
+
+#include <glib/gprintf.h>
+
+#include <connman/log.h>
+#include <connman/rtnl.h>
+#include <connman/task.h>
+#include <connman/inet.h>
+
+#include "../vpn-rtnl.h"
+#include "../vpn-provider.h"
+
+#include "vpn.h"
+
+struct vpn_data {
+ struct vpn_provider *provider;
+ char *if_name;
+ unsigned flags;
+ unsigned int watch;
+ enum vpn_state state;
+ struct connman_task *task;
+};
+
+struct vpn_driver_data {
+ const char *name;
+ const char *program;
+ struct vpn_driver *vpn_driver;
+ struct vpn_provider_driver provider_driver;
+};
+
+GHashTable *driver_hash = NULL;
+
+static int stop_vpn(struct vpn_provider *provider)
+{
+ struct vpn_data *data = vpn_provider_get_data(provider);
+ struct vpn_driver_data *vpn_driver_data;
+ const char *name;
+ struct ifreq ifr;
+ int fd, err;
+
+ if (!data)
+ return -EINVAL;
+
+ name = vpn_provider_get_driver_name(provider);
+ if (!name)
+ return -EINVAL;
+
+ vpn_driver_data = g_hash_table_lookup(driver_hash, name);
+
+ if (vpn_driver_data && vpn_driver_data->vpn_driver &&
+ vpn_driver_data->vpn_driver->flags == VPN_FLAG_NO_TUN)
+ return 0;
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
+ sprintf(ifr.ifr_name, "%s", data->if_name);
+
+ fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
+ if (fd < 0) {
+ err = -errno;
+ connman_error("Failed to open /dev/net/tun to device %s: %s",
+ data->if_name, strerror(errno));
+ return err;
+ }
+
+ if (ioctl(fd, TUNSETIFF, (void *)&ifr)) {
+ err = -errno;
+ connman_error("Failed to TUNSETIFF for device %s to it: %s",
+ data->if_name, strerror(errno));
+ close(fd);
+ return err;
+ }
+
+ if (ioctl(fd, TUNSETPERSIST, 0)) {
+ err = -errno;
+ connman_error("Failed to set tun device %s nonpersistent: %s",
+ data->if_name, strerror(errno));
+ close(fd);
+ return err;
+ }
+ close(fd);
+ DBG("Killed tun device %s", data->if_name);
+ return 0;
+}
+
+void vpn_died(struct connman_task *task, int exit_code, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ struct vpn_data *data = vpn_provider_get_data(provider);
+ int state = VPN_STATE_FAILURE;
+ enum vpn_provider_error ret;
+
+ DBG("provider %p data %p", provider, data);
+
+ if (!data)
+ goto vpn_exit;
+
+ state = data->state;
+
+ stop_vpn(provider);
+ vpn_provider_set_data(provider, NULL);
+
+ if (data->watch != 0) {
+ vpn_rtnl_remove_watch(data->watch);
+ data->watch = 0;
+ vpn_provider_unref(provider);
+ }
+
+vpn_exit:
+ if (state != VPN_STATE_READY && state != VPN_STATE_DISCONNECT) {
+ const char *name;
+ struct vpn_driver_data *vpn_data = NULL;
+
+ name = vpn_provider_get_driver_name(provider);
+ if (name)
+ vpn_data = g_hash_table_lookup(driver_hash, name);
+
+ if (vpn_data &&
+ vpn_data->vpn_driver->error_code)
+ ret = vpn_data->vpn_driver->error_code(provider,
+ exit_code);
+ else
+ ret = VPN_PROVIDER_ERROR_UNKNOWN;
+
+ vpn_provider_indicate_error(provider, ret);
+ } else
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_IDLE);
+
+ vpn_provider_set_index(provider, -1);
+
+ if (data) {
+ vpn_provider_unref(data->provider);
+ g_free(data->if_name);
+ g_free(data);
+ }
+
+ connman_task_destroy(task);
+}
+
+int vpn_set_ifname(struct vpn_provider *provider, const char *ifname)
+{
+ struct vpn_data *data = vpn_provider_get_data(provider);
+ int index;
+
+ if (!ifname || !data)
+ return -EIO;
+
+ index = connman_inet_ifindex(ifname);
+ if (index < 0)
+ return -EIO;
+
+ if (data->if_name)
+ g_free(data->if_name);
+
+ data->if_name = (char *)g_strdup(ifname);
+ vpn_provider_set_index(provider, index);
+
+ return 0;
+}
+
+static void vpn_newlink(unsigned flags, unsigned change, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ struct vpn_data *data = vpn_provider_get_data(provider);
+
+ if ((data->flags & IFF_UP) != (flags & IFF_UP)) {
+ if (flags & IFF_UP) {
+ data->state = VPN_STATE_READY;
+ vpn_provider_set_state(provider,
+ VPN_PROVIDER_STATE_READY);
+ }
+ }
+ data->flags = flags;
+}
+
+static DBusMessage *vpn_notify(struct connman_task *task,
+ DBusMessage *msg, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ struct vpn_data *data;
+ struct vpn_driver_data *vpn_driver_data;
+ const char *name;
+ int state, index, err;
+
+ data = vpn_provider_get_data(provider);
+
+ name = vpn_provider_get_driver_name(provider);
+
+ if (!name) {
+ DBG("Cannot find VPN driver for provider %p", provider);
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
+ return NULL;
+ }
+
+ vpn_driver_data = g_hash_table_lookup(driver_hash, name);
+ if (!vpn_driver_data) {
+ DBG("Cannot find VPN driver data for name %s", name);
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
+ return NULL;
+ }
+
+ state = vpn_driver_data->vpn_driver->notify(msg, provider);
+
+ DBG("provider %p driver %s state %d", provider, name, state);
+
+ switch (state) {
+ case VPN_STATE_CONNECT:
+ case VPN_STATE_READY:
+ if (data->state == VPN_STATE_READY) {
+ /*
+ * This is the restart case, in which case we must
+ * just set the IP address.
+ *
+ * We need to remove first the old address, just
+ * replacing the old address will not work as expected
+ * because the old address will linger in the interface
+ * and not disapper so the clearing is needed here.
+ *
+ * Also the state must change, otherwise the routes
+ * will not be set properly.
+ */
+ vpn_provider_set_state(provider,
+ VPN_PROVIDER_STATE_CONNECT);
+
+ vpn_provider_clear_address(provider, AF_INET);
+ vpn_provider_clear_address(provider, AF_INET6);
+
+ vpn_provider_change_address(provider);
+ vpn_provider_set_state(provider,
+ VPN_PROVIDER_STATE_READY);
+ break;
+ }
+
+ index = vpn_provider_get_index(provider);
+ vpn_provider_ref(provider);
+ data->watch = vpn_rtnl_add_newlink_watch(index,
+ vpn_newlink, provider);
+ err = connman_inet_ifup(index);
+ if (err < 0) {
+ if (err == -EALREADY)
+ /*
+ * So the interface is up already, that is just
+ * great. Unfortunately in this case the
+ * newlink watch might not have been called at
+ * all. We must manually call it here so that
+ * the provider can go to ready state and the
+ * routes are setup properly.
+ */
+ vpn_newlink(IFF_UP, 0, provider);
+ else
+ DBG("Cannot take interface %d up err %d/%s",
+ index, -err, strerror(-err));
+ }
+ break;
+
+ case VPN_STATE_UNKNOWN:
+ case VPN_STATE_IDLE:
+ case VPN_STATE_DISCONNECT:
+ case VPN_STATE_FAILURE:
+ vpn_provider_set_state(provider,
+ VPN_PROVIDER_STATE_DISCONNECT);
+ break;
+
+ case VPN_STATE_AUTH_FAILURE:
+ vpn_provider_indicate_error(provider,
+ VPN_PROVIDER_ERROR_AUTH_FAILED);
+ break;
+ }
+
+ return NULL;
+}
+
+static int vpn_create_tun(struct vpn_provider *provider)
+{
+ struct vpn_data *data = vpn_provider_get_data(provider);
+ struct ifreq ifr;
+ int i, fd, index;
+ int ret = 0;
+
+ if (!data)
+ return -EISCONN;
+
+ fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
+ if (fd < 0) {
+ i = -errno;
+ connman_error("Failed to open /dev/net/tun: %s",
+ strerror(errno));
+ ret = i;
+ goto exist_err;
+ }
+
+ memset(&ifr, 0, sizeof(ifr));
+ ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
+
+ for (i = 0; i < 256; i++) {
+ sprintf(ifr.ifr_name, "vpn%d", i);
+
+ if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
+ break;
+ }
+
+ if (i == 256) {
+ connman_error("Failed to find available tun device");
+ close(fd);
+ ret = -ENODEV;
+ goto exist_err;
+ }
+
+ data->if_name = (char *)g_strdup(ifr.ifr_name);
+ if (!data->if_name) {
+ connman_error("Failed to allocate memory");
+ close(fd);
+ ret = -ENOMEM;
+ goto exist_err;
+ }
+
+ if (ioctl(fd, TUNSETPERSIST, 1)) {
+ i = -errno;
+ connman_error("Failed to set tun persistent: %s",
+ strerror(errno));
+ close(fd);
+ ret = i;
+ goto exist_err;
+ }
+
+ close(fd);
+
+ index = connman_inet_ifindex(data->if_name);
+ if (index < 0) {
+ connman_error("Failed to get tun ifindex");
+ stop_vpn(provider);
+ ret = -EIO;
+ goto exist_err;
+ }
+ vpn_provider_set_index(provider, index);
+
+ return 0;
+
+exist_err:
+ return ret;
+}
+
+static int vpn_connect(struct vpn_provider *provider,
+ vpn_provider_connect_cb_t cb,
+ const char *dbus_sender, void *user_data)
+{
+ struct vpn_data *data = vpn_provider_get_data(provider);
+ struct vpn_driver_data *vpn_driver_data;
+ const char *name;
+ int ret = 0;
+ enum vpn_state state = VPN_STATE_UNKNOWN;
+
+ if (data)
+ state = data->state;
+
+ DBG("data %p state %d", data, state);
+
+ switch (state) {
+ case VPN_STATE_UNKNOWN:
+ data = g_try_new0(struct vpn_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ data->provider = vpn_provider_ref(provider);
+ data->watch = 0;
+ data->flags = 0;
+ data->task = NULL;
+
+ vpn_provider_set_data(provider, data);
+ /* fall through */
+
+ case VPN_STATE_DISCONNECT:
+ case VPN_STATE_IDLE:
+ case VPN_STATE_FAILURE:
+ case VPN_STATE_AUTH_FAILURE:
+ data->state = VPN_STATE_IDLE;
+ break;
+
+ case VPN_STATE_CONNECT:
+ return -EINPROGRESS;
+
+ case VPN_STATE_READY:
+ return -EISCONN;
+ }
+
+ name = vpn_provider_get_driver_name(provider);
+ if (!name)
+ return -EINVAL;
+
+ vpn_driver_data = g_hash_table_lookup(driver_hash, name);
+
+ if (!vpn_driver_data || !vpn_driver_data->vpn_driver) {
+ ret = -EINVAL;
+ goto exist_err;
+ }
+
+ if (vpn_driver_data->vpn_driver->flags != VPN_FLAG_NO_TUN) {
+ ret = vpn_create_tun(provider);
+ if (ret < 0)
+ goto exist_err;
+ }
+
+ data->task = connman_task_create(vpn_driver_data->program);
+
+ if (!data->task) {
+ ret = -ENOMEM;
+ stop_vpn(provider);
+ goto exist_err;
+ }
+
+ if (connman_task_set_notify(data->task, "notify",
+ vpn_notify, provider)) {
+ ret = -ENOMEM;
+ stop_vpn(provider);
+ connman_task_destroy(data->task);
+ data->task = NULL;
+ goto exist_err;
+ }
+
+ ret = vpn_driver_data->vpn_driver->connect(provider, data->task,
+ data->if_name, cb, dbus_sender,
+ user_data);
+ if (ret < 0 && ret != -EINPROGRESS) {
+ stop_vpn(provider);
+ connman_task_destroy(data->task);
+ data->task = NULL;
+ goto exist_err;
+ }
+
+ DBG("%s started with dev %s",
+ vpn_driver_data->provider_driver.name, data->if_name);
+
+ data->state = VPN_STATE_CONNECT;
+
+ return -EINPROGRESS;
+
+exist_err:
+ vpn_provider_set_index(provider, -1);
+ vpn_provider_set_data(provider, NULL);
+ vpn_provider_unref(data->provider);
+ g_free(data->if_name);
+ g_free(data);
+
+ return ret;
+}
+
+static int vpn_probe(struct vpn_provider *provider)
+{
+ return 0;
+}
+
+static int vpn_disconnect(struct vpn_provider *provider)
+{
+ struct vpn_data *data = vpn_provider_get_data(provider);
+ struct vpn_driver_data *vpn_driver_data;
+ const char *name;
+
+ DBG("disconnect provider %p:", provider);
+
+ if (!data)
+ return 0;
+
+ name = vpn_provider_get_driver_name(provider);
+ if (!name)
+ return 0;
+
+ vpn_driver_data = g_hash_table_lookup(driver_hash, name);
+ if (vpn_driver_data->vpn_driver->disconnect)
+ vpn_driver_data->vpn_driver->disconnect(provider);
+
+ if (data->watch != 0) {
+ vpn_provider_unref(provider);
+ vpn_rtnl_remove_watch(data->watch);
+ data->watch = 0;
+ }
+
+ data->state = VPN_STATE_DISCONNECT;
+ connman_task_stop(data->task);
+
+ return 0;
+}
+
+static int vpn_remove(struct vpn_provider *provider)
+{
+ struct vpn_data *data;
+
+ data = vpn_provider_get_data(provider);
+ if (!data)
+ return 0;
+
+ if (data->watch != 0) {
+ vpn_provider_unref(provider);
+ vpn_rtnl_remove_watch(data->watch);
+ data->watch = 0;
+ }
+
+ connman_task_stop(data->task);
+
+ g_usleep(G_USEC_PER_SEC);
+ stop_vpn(provider);
+ return 0;
+}
+
+static int vpn_save(struct vpn_provider *provider, GKeyFile *keyfile)
+{
+ struct vpn_driver_data *vpn_driver_data;
+ const char *name;
+
+ name = vpn_provider_get_driver_name(provider);
+ vpn_driver_data = g_hash_table_lookup(driver_hash, name);
+ if (vpn_driver_data &&
+ vpn_driver_data->vpn_driver->save)
+ return vpn_driver_data->vpn_driver->save(provider, keyfile);
+
+ return 0;
+}
+
+int vpn_register(const char *name, struct vpn_driver *vpn_driver,
+ const char *program)
+{
+ struct vpn_driver_data *data;
+
+ data = g_try_new0(struct vpn_driver_data, 1);
+ if (!data)
+ return -ENOMEM;
+
+ data->name = name;
+ data->program = program;
+
+ data->vpn_driver = vpn_driver;
+
+ data->provider_driver.name = name;
+ data->provider_driver.disconnect = vpn_disconnect;
+ data->provider_driver.connect = vpn_connect;
+ data->provider_driver.probe = vpn_probe;
+ data->provider_driver.remove = vpn_remove;
+ data->provider_driver.save = vpn_save;
+
+ if (!driver_hash)
+ driver_hash = g_hash_table_new_full(g_str_hash,
+ g_str_equal,
+ NULL, g_free);
+
+ if (!driver_hash) {
+ connman_error("driver_hash not initialized for %s", name);
+ g_free(data);
+ return -ENOMEM;
+ }
+
+ g_hash_table_replace(driver_hash, (char *)name, data);
+
+ vpn_provider_driver_register(&data->provider_driver);
+
+ return 0;
+}
+
+void vpn_unregister(const char *name)
+{
+ struct vpn_driver_data *data;
+
+ data = g_hash_table_lookup(driver_hash, name);
+ if (!data)
+ return;
+
+ vpn_provider_driver_unregister(&data->provider_driver);
+
+ g_hash_table_remove(driver_hash, name);
+
+ if (g_hash_table_size(driver_hash) == 0)
+ g_hash_table_destroy(driver_hash);
+}
diff --git a/vpn/plugins/vpn.h b/vpn/plugins/vpn.h
new file mode 100644
index 0000000..bf56728
--- /dev/null
+++ b/vpn/plugins/vpn.h
@@ -0,0 +1,65 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2010,2014 BMW Car IT GmbH.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __CONNMAN_VPND_VPN_H
+#define __CONNMAN_VPND_VPN_H
+
+#include "../vpn-provider.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define VPN_FLAG_NO_TUN 1
+
+enum vpn_state {
+ VPN_STATE_UNKNOWN = 0,
+ VPN_STATE_IDLE = 1,
+ VPN_STATE_CONNECT = 2,
+ VPN_STATE_READY = 3,
+ VPN_STATE_DISCONNECT = 4,
+ VPN_STATE_FAILURE = 5,
+ VPN_STATE_AUTH_FAILURE = 6,
+};
+
+struct vpn_driver {
+ int flags;
+ int (*notify) (DBusMessage *msg, struct vpn_provider *provider);
+ int (*connect) (struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data);
+ void (*disconnect) (struct vpn_provider *provider);
+ int (*error_code) (struct vpn_provider *provider, int exit_code);
+ int (*save) (struct vpn_provider *provider, GKeyFile *keyfile);
+};
+
+int vpn_register(const char *name, struct vpn_driver *driver,
+ const char *program);
+void vpn_unregister(const char *provider_name);
+void vpn_died(struct connman_task *task, int exit_code, void *user_data);
+int vpn_set_ifname(struct vpn_provider *provider, const char *ifname);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __CONNMAN_VPND_VPN_H */
diff --git a/vpn/plugins/vpnc.c b/vpn/plugins/vpnc.c
new file mode 100644
index 0000000..09674bd
--- /dev/null
+++ b/vpn/plugins/vpnc.c
@@ -0,0 +1,354 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2010,2013 BMW Car IT GmbH.
+ * Copyright (C) 2010,2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <net/if.h>
+
+#include <glib.h>
+
+#define CONNMAN_API_SUBJECT_TO_CHANGE
+#include <connman/plugin.h>
+#include <connman/log.h>
+#include <connman/task.h>
+#include <connman/ipconfig.h>
+#include <connman/dbus.h>
+
+#include "../vpn-provider.h"
+
+#include "vpn.h"
+
+#define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
+
+static DBusConnection *connection;
+
+enum {
+ OPT_STRING = 1,
+ OPT_BOOLEAN = 2,
+};
+
+struct {
+ const char *cm_opt;
+ const char *vpnc_opt;
+ const char *vpnc_default;
+ int type;
+ bool cm_save;
+} vpnc_options[] = {
+ { "Host", "IPSec gateway", NULL, OPT_STRING, true },
+ { "VPNC.IPSec.ID", "IPSec ID", NULL, OPT_STRING, true },
+ { "VPNC.IPSec.Secret", "IPSec secret", NULL, OPT_STRING, false },
+ { "VPNC.Xauth.Username", "Xauth username", NULL, OPT_STRING, false },
+ { "VPNC.Xauth.Password", "Xauth password", NULL, OPT_STRING, false },
+ { "VPNC.IKE.Authmode", "IKE Authmode", NULL, OPT_STRING, true },
+ { "VPNC.IKE.DHGroup", "IKE DH Group", NULL, OPT_STRING, true },
+ { "VPNC.PFS", "Perfect Forward Secrecy", NULL, OPT_STRING, true },
+ { "VPNC.Domain", "Domain", NULL, OPT_STRING, true },
+ { "VPNC.Vendor", "Vendor", NULL, OPT_STRING, true },
+ { "VPNC.LocalPort", "Local Port", "0", OPT_STRING, true, },
+ { "VPNC.CiscoPort", "Cisco UDP Encapsulation Port", "0", OPT_STRING,
+ true },
+ { "VPNC.AppVersion", "Application Version", NULL, OPT_STRING, true },
+ { "VPNC.NATTMode", "NAT Traversal Mode", "cisco-udp", OPT_STRING,
+ true },
+ { "VPNC.DPDTimeout", "DPD idle timeout (our side)", NULL, OPT_STRING,
+ true },
+ { "VPNC.SingleDES", "Enable Single DES", NULL, OPT_BOOLEAN, true },
+ { "VPNC.NoEncryption", "Enable no encryption", NULL, OPT_BOOLEAN,
+ true },
+};
+
+static int vc_notify(DBusMessage *msg, struct vpn_provider *provider)
+{
+ DBusMessageIter iter, dict;
+ char *address = NULL, *netmask = NULL, *gateway = NULL;
+ struct connman_ipaddress *ipaddress;
+ const char *reason, *key, *value;
+
+ dbus_message_iter_init(msg, &iter);
+
+ dbus_message_iter_get_basic(&iter, &reason);
+ dbus_message_iter_next(&iter);
+
+ if (!provider) {
+ connman_error("No provider found");
+ return VPN_STATE_FAILURE;
+ }
+
+ if (strcmp(reason, "connect"))
+ return VPN_STATE_DISCONNECT;
+
+ dbus_message_iter_recurse(&iter, &dict);
+
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_get_basic(&entry, &value);
+
+ DBG("%s = %s", key, value);
+
+ if (!strcmp(key, "VPNGATEWAY"))
+ gateway = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_ADDRESS"))
+ address = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_NETMASK"))
+ netmask = g_strdup(value);
+
+ if (!strcmp(key, "INTERNAL_IP4_DNS"))
+ vpn_provider_set_nameservers(provider, value);
+
+ if (!strcmp(key, "CISCO_DEF_DOMAIN"))
+ vpn_provider_set_domain(provider, value);
+
+ if (g_str_has_prefix(key, "CISCO_SPLIT_INC") ||
+ g_str_has_prefix(key, "CISCO_IPV6_SPLIT_INC"))
+ vpn_provider_append_route(provider, key, value);
+
+ dbus_message_iter_next(&dict);
+ }
+
+
+ ipaddress = connman_ipaddress_alloc(AF_INET);
+ if (!ipaddress) {
+ g_free(address);
+ g_free(netmask);
+ g_free(gateway);
+
+ return VPN_STATE_FAILURE;
+ }
+
+ connman_ipaddress_set_ipv4(ipaddress, address, netmask, gateway);
+ vpn_provider_set_ipaddress(provider, ipaddress);
+
+ g_free(address);
+ g_free(netmask);
+ g_free(gateway);
+ connman_ipaddress_free(ipaddress);
+
+ return VPN_STATE_CONNECT;
+}
+
+static ssize_t full_write(int fd, const void *buf, size_t len)
+{
+ ssize_t byte_write;
+
+ while (len) {
+ byte_write = write(fd, buf, len);
+ if (byte_write < 0) {
+ connman_error("failed to write config to vpnc: %s\n",
+ strerror(errno));
+ return byte_write;
+ }
+ len -= byte_write;
+ buf += byte_write;
+ }
+
+ return 0;
+}
+
+static ssize_t write_option(int fd, const char *key, const char *value)
+{
+ gchar *buf;
+ ssize_t ret = 0;
+
+ if (key && value) {
+ buf = g_strdup_printf("%s %s\n", key, value);
+ ret = full_write(fd, buf, strlen(buf));
+
+ g_free(buf);
+ }
+
+ return ret;
+}
+
+static ssize_t write_bool_option(int fd, const char *key, const char *value)
+{
+ gchar *buf;
+ ssize_t ret = 0;
+
+ if (key && value) {
+ if (strcasecmp(value, "yes") == 0 ||
+ strcasecmp(value, "true") == 0 ||
+ strcmp(value, "1") == 0) {
+ buf = g_strdup_printf("%s\n", key);
+ ret = full_write(fd, buf, strlen(buf));
+
+ g_free(buf);
+ }
+ }
+
+ return ret;
+}
+
+static int vc_write_config_data(struct vpn_provider *provider, int fd)
+{
+ const char *opt_s;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(vpnc_options); i++) {
+ opt_s = vpn_provider_get_string(provider,
+ vpnc_options[i].cm_opt);
+ if (!opt_s)
+ opt_s = vpnc_options[i].vpnc_default;
+
+ if (!opt_s)
+ continue;
+
+ if (vpnc_options[i].type == OPT_STRING) {
+ if (write_option(fd,
+ vpnc_options[i].vpnc_opt, opt_s) < 0)
+ return -EIO;
+ } else if (vpnc_options[i].type == OPT_BOOLEAN) {
+ if (write_bool_option(fd,
+ vpnc_options[i].vpnc_opt, opt_s) < 0)
+ return -EIO;
+ }
+
+ }
+
+ return 0;
+}
+
+static int vc_save(struct vpn_provider *provider, GKeyFile *keyfile)
+{
+ const char *option;
+ int i;
+
+ for (i = 0; i < (int)ARRAY_SIZE(vpnc_options); i++) {
+ if (strncmp(vpnc_options[i].cm_opt, "VPNC.", 5) == 0) {
+
+ if (!vpnc_options[i].cm_save)
+ continue;
+
+ option = vpn_provider_get_string(provider,
+ vpnc_options[i].cm_opt);
+ if (!option)
+ continue;
+
+ g_key_file_set_string(keyfile,
+ vpn_provider_get_save_group(provider),
+ vpnc_options[i].cm_opt, option);
+ }
+ }
+ return 0;
+}
+
+static int vc_connect(struct vpn_provider *provider,
+ struct connman_task *task, const char *if_name,
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data)
+{
+ const char *option;
+ int err = 0, fd;
+
+ option = vpn_provider_get_string(provider, "Host");
+ if (!option) {
+ connman_error("Host not set; cannot enable VPN");
+ err = -EINVAL;
+ goto done;
+ }
+ option = vpn_provider_get_string(provider, "VPNC.IPSec.ID");
+ if (!option) {
+ connman_error("Group not set; cannot enable VPN");
+ err = -EINVAL;
+ goto done;
+ }
+
+ connman_task_add_argument(task, "--non-inter", NULL);
+ connman_task_add_argument(task, "--no-detach", NULL);
+
+ connman_task_add_argument(task, "--ifname", if_name);
+ connman_task_add_argument(task, "--ifmode", "tun");
+
+ connman_task_add_argument(task, "--script",
+ SCRIPTDIR "/openconnect-script");
+
+ option = vpn_provider_get_string(provider, "VPNC.Debug");
+ if (option)
+ connman_task_add_argument(task, "--debug", option);
+
+ connman_task_add_argument(task, "-", NULL);
+
+ err = connman_task_run(task, vpn_died, provider,
+ &fd, NULL, NULL);
+ if (err < 0) {
+ connman_error("vpnc failed to start");
+ err = -EIO;
+ goto done;
+ }
+
+ err = vc_write_config_data(provider, fd);
+
+ close(fd);
+
+done:
+ if (cb)
+ cb(provider, user_data, err);
+
+ return err;
+}
+
+static int vc_error_code(struct vpn_provider *provider, int exit_code)
+{
+ switch (exit_code) {
+ case 1:
+ return VPN_PROVIDER_ERROR_CONNECT_FAILED;
+ case 2:
+ return VPN_PROVIDER_ERROR_LOGIN_FAILED;
+ default:
+ return VPN_PROVIDER_ERROR_UNKNOWN;
+ }
+}
+
+static struct vpn_driver vpn_driver = {
+ .notify = vc_notify,
+ .connect = vc_connect,
+ .error_code = vc_error_code,
+ .save = vc_save,
+};
+
+static int vpnc_init(void)
+{
+ connection = connman_dbus_get_connection();
+
+ return vpn_register("vpnc", &vpn_driver, VPNC);
+}
+
+static void vpnc_exit(void)
+{
+ vpn_unregister("vpnc");
+
+ dbus_connection_unref(connection);
+}
+
+CONNMAN_PLUGIN_DEFINE(vpnc, "vpnc plugin", VERSION,
+ CONNMAN_PLUGIN_PRIORITY_DEFAULT, vpnc_init, vpnc_exit)
diff --git a/vpn/vpn-agent.c b/vpn/vpn-agent.c
new file mode 100644
index 0000000..b0b582b
--- /dev/null
+++ b/vpn/vpn-agent.c
@@ -0,0 +1,145 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gdbus.h>
+#include <connman/log.h>
+#include <connman/agent.h>
+#include <vpn/vpn-provider.h>
+
+#include "vpn-agent.h"
+#include "vpn.h"
+
+bool vpn_agent_check_reply_has_dict(DBusMessage *reply)
+{
+ const char *signature = DBUS_TYPE_ARRAY_AS_STRING
+ DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
+ DBUS_TYPE_STRING_AS_STRING
+ DBUS_TYPE_VARIANT_AS_STRING
+ DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
+
+ if (dbus_message_has_signature(reply, signature))
+ return true;
+
+ connman_warn("Reply %s to %s from %s has wrong signature %s",
+ signature,
+ dbus_message_get_interface(reply),
+ dbus_message_get_sender(reply),
+ dbus_message_get_signature(reply));
+
+ return false;
+}
+
+static void request_input_append_name(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ const char *str = "string";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "informational";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+
+ str = vpn_provider_get_name(provider);
+ connman_dbus_dict_append_basic(iter, "Value",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void request_input_append_host(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ const char *str = "string";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "informational";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+
+ str = vpn_provider_get_host(provider);
+ connman_dbus_dict_append_basic(iter, "Value",
+ DBUS_TYPE_STRING, &str);
+}
+
+void vpn_agent_append_host_and_name(DBusMessageIter *iter,
+ struct vpn_provider *provider)
+{
+ connman_dbus_dict_append_dict(iter, "Host",
+ request_input_append_host,
+ provider);
+
+ connman_dbus_dict_append_dict(iter, "Name",
+ request_input_append_name,
+ provider);
+}
+
+struct user_info_data {
+ struct vpn_provider *provider;
+ const char *username_str;
+};
+
+static void request_input_append_user_info(DBusMessageIter *iter,
+ void *user_data)
+{
+ struct user_info_data *data = user_data;
+ struct vpn_provider *provider = data->provider;
+ const char *str = "string";
+
+ connman_dbus_dict_append_basic(iter, "Type",
+ DBUS_TYPE_STRING, &str);
+ str = "mandatory";
+ connman_dbus_dict_append_basic(iter, "Requirement",
+ DBUS_TYPE_STRING, &str);
+
+ if (data->username_str) {
+ str = vpn_provider_get_string(provider, data->username_str);
+ if (str)
+ connman_dbus_dict_append_basic(iter, "Value",
+ DBUS_TYPE_STRING, &str);
+ }
+}
+
+void vpn_agent_append_user_info(DBusMessageIter *iter,
+ struct vpn_provider *provider,
+ const char *username_str)
+{
+ struct user_info_data data = {
+ .provider = provider,
+ .username_str = username_str
+ };
+
+ connman_dbus_dict_append_dict(iter, "Username",
+ request_input_append_user_info,
+ &data);
+
+ data.username_str = NULL;
+ connman_dbus_dict_append_dict(iter, "Password",
+ request_input_append_user_info,
+ &data);
+}
diff --git a/vpn/vpn-agent.h b/vpn/vpn-agent.h
new file mode 100644
index 0000000..c7328d7
--- /dev/null
+++ b/vpn/vpn-agent.h
@@ -0,0 +1,46 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __VPN_AGENT_H
+#define __VPN_AGENT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:agent
+ * @title: Agent premitives
+ * @short_description: Functions for interaction with agent
+ */
+
+void vpn_agent_append_host_and_name(DBusMessageIter *iter,
+ struct vpn_provider *provider);
+bool vpn_agent_check_reply_has_dict(DBusMessage *reply);
+void vpn_agent_append_user_info(DBusMessageIter *iter,
+ struct vpn_provider *provider,
+ const char *username_str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __VPN_AGENT_H */
diff --git a/vpn/vpn-config.c b/vpn/vpn-config.c
new file mode 100644
index 0000000..293c64e
--- /dev/null
+++ b/vpn/vpn-config.c
@@ -0,0 +1,581 @@
+/*
+ *
+ * Connection Manager
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/vfs.h>
+#include <sys/inotify.h>
+#include <glib.h>
+
+#include <connman/log.h>
+#include "../src/connman.h"
+
+#include "vpn.h"
+
+enum what {
+ REMOVE = 1,
+ ADD = 2,
+};
+
+struct vpn_config_provider {
+ char *provider_identifier;
+ char *ident;
+ char *name;
+ char *type;
+ char *host;
+ char *domain;
+ char *networks;
+ GHashTable *setting_strings;
+
+ char *config_ident; /* file prefix */
+ char *config_entry; /* entry name */
+};
+
+struct vpn_config {
+ char *ident;
+ char *name;
+ char *description;
+ GHashTable *provider_table;
+};
+
+static GHashTable *config_table = NULL;
+
+static bool cleanup = false;
+
+/* Definition of possible strings in the .config files */
+#define CONFIG_KEY_NAME "Name"
+#define CONFIG_KEY_DESC "Description"
+
+static const char *config_possible_keys[] = {
+ CONFIG_KEY_NAME,
+ CONFIG_KEY_DESC,
+ NULL,
+};
+
+static void unregister_config(gpointer data)
+{
+ struct vpn_config *config = data;
+
+ connman_info("Removing configuration %s", config->ident);
+
+ g_hash_table_destroy(config->provider_table);
+
+ g_free(config->description);
+ g_free(config->name);
+ g_free(config->ident);
+ g_free(config);
+}
+
+static void unregister_provider(gpointer data)
+{
+ struct vpn_config_provider *config_provider = data;
+ struct vpn_provider *provider;
+ char *provider_id;
+
+ if (cleanup)
+ goto free_only;
+
+ provider_id = config_provider->provider_identifier;
+
+ connman_info("Removing provider configuration %s provider %s",
+ config_provider->ident, provider_id);
+
+ provider = __vpn_provider_lookup(provider_id);
+ if (provider)
+ __vpn_provider_delete(provider);
+ else {
+ if (!__connman_storage_remove_provider(provider_id))
+ DBG("Could not remove all files for provider %s",
+ provider_id);
+ }
+
+free_only:
+ g_free(config_provider->ident);
+ g_free(config_provider->type);
+ g_free(config_provider->name);
+ g_free(config_provider->host);
+ g_free(config_provider->domain);
+ g_free(config_provider->networks);
+ g_hash_table_destroy(config_provider->setting_strings);
+ g_free(config_provider->provider_identifier);
+ g_free(config_provider->config_ident);
+ g_free(config_provider->config_entry);
+ g_free(config_provider);
+}
+
+static int set_string(struct vpn_config_provider *config_provider,
+ const char *key, const char *value)
+{
+ DBG("provider %p key %s value %s", config_provider, key, value);
+
+ if (g_str_equal(key, "Type")) {
+ g_free(config_provider->type);
+ config_provider->type = g_strdup(value);
+ } else if (g_str_equal(key, "Name")) {
+ g_free(config_provider->name);
+ config_provider->name = g_strdup(value);
+ } else if (g_str_equal(key, "Host")) {
+ g_free(config_provider->host);
+ config_provider->host = g_strdup(value);
+ } else if (g_str_equal(key, "Domain")) {
+ g_free(config_provider->domain);
+ config_provider->domain = g_strdup(value);
+ } else if (g_str_equal(key, "Networks")) {
+ g_free(config_provider->networks);
+ config_provider->networks = g_strdup(value);
+ }
+
+ g_hash_table_replace(config_provider->setting_strings,
+ g_strdup(key), g_strdup(value));
+ return 0;
+}
+
+static const char *get_string(struct vpn_config_provider *config_provider,
+ const char *key)
+{
+ DBG("provider %p key %s", config_provider, key);
+
+ if (g_str_equal(key, "Type"))
+ return config_provider->type;
+ else if (g_str_equal(key, "Name"))
+ return config_provider->name;
+ else if (g_str_equal(key, "Host"))
+ return config_provider->host;
+ else if (g_str_equal(key, "Domain"))
+ return config_provider->domain;
+ else if (g_str_equal(key, "Networks"))
+ return config_provider->networks;
+
+ return g_hash_table_lookup(config_provider->setting_strings, key);
+}
+
+static void add_keys(struct vpn_config_provider *config_provider,
+ GKeyFile *keyfile, const char *group)
+{
+ char **avail_keys;
+ gsize nb_avail_keys, i;
+
+ avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
+ if (!avail_keys)
+ return;
+
+ for (i = 0 ; i < nb_avail_keys; i++) {
+ char *value = g_key_file_get_value(keyfile, group,
+ avail_keys[i], NULL);
+ if (!value) {
+ connman_warn("Cannot find value for %s",
+ avail_keys[i]);
+ continue;
+ }
+
+ set_string(config_provider, avail_keys[i], value);
+ g_free(value);
+ }
+
+ g_strfreev(avail_keys);
+}
+
+static int load_provider(GKeyFile *keyfile, const char *group,
+ struct vpn_config *config, enum what action)
+{
+ struct vpn_config_provider *config_provider;
+ const char *ident, *host, *domain;
+ int err;
+
+ /* Strip off "provider_" prefix */
+ ident = group + 9;
+
+ if (strlen(ident) < 1)
+ return -EINVAL;
+
+ config_provider = g_hash_table_lookup(config->provider_table, ident);
+ if (config_provider)
+ return -EALREADY;
+
+ config_provider = g_try_new0(struct vpn_config_provider, 1);
+ if (!config_provider)
+ return -ENOMEM;
+
+ config_provider->ident = g_strdup(ident);
+
+ config_provider->setting_strings = g_hash_table_new_full(g_str_hash,
+ g_str_equal, g_free, g_free);
+
+ add_keys(config_provider, keyfile, group);
+
+ host = get_string(config_provider, "Host");
+ domain = get_string(config_provider, "Domain");
+ if (host && domain) {
+ char *id = __vpn_provider_create_identifier(host, domain);
+
+ struct vpn_provider *provider;
+ provider = __vpn_provider_lookup(id);
+ if (provider) {
+ if (action == REMOVE) {
+ __vpn_provider_delete(provider);
+ err = 0;
+ } else {
+ connman_warn("Provider configuration %s "
+ "already exist", id);
+ err = -EALREADY;
+ }
+
+ g_free(id);
+ goto err;
+ }
+
+ config_provider->provider_identifier = id;
+
+ DBG("provider identifier %s", id);
+ } else {
+ DBG("invalid values host %s domain %s", host, domain);
+ err = -EINVAL;
+ goto err;
+ }
+
+ config_provider->config_ident = g_strdup(config->ident);
+ config_provider->config_entry = g_strdup_printf("provider_%s",
+ config_provider->ident);
+
+ g_hash_table_insert(config->provider_table,
+ config_provider->ident, config_provider);
+
+ err = __vpn_provider_create_from_config(
+ config_provider->setting_strings,
+ config_provider->config_ident,
+ config_provider->config_entry);
+ if (err != 0) {
+ DBG("Cannot create provider from config file (%d/%s)",
+ -err, strerror(-err));
+ goto err;
+ }
+
+ connman_info("Added provider configuration %s",
+ config_provider->ident);
+ return 0;
+
+err:
+ g_free(config_provider->ident);
+ g_free(config_provider->type);
+ g_free(config_provider->name);
+ g_free(config_provider->host);
+ g_free(config_provider->domain);
+ g_free(config_provider->networks);
+ g_hash_table_destroy(config_provider->setting_strings);
+ g_free(config_provider);
+
+ return err;
+}
+
+static void check_keys(GKeyFile *keyfile, const char *group,
+ const char **possible_keys)
+{
+ char **avail_keys;
+ gsize nb_avail_keys, i, j;
+
+ avail_keys = g_key_file_get_keys(keyfile, group, &nb_avail_keys, NULL);
+ if (!avail_keys)
+ return;
+
+ for (i = 0 ; i < nb_avail_keys; i++) {
+ for (j = 0; possible_keys[j] ; j++)
+ if (g_strcmp0(avail_keys[i], possible_keys[j]) == 0)
+ break;
+
+ if (!possible_keys[j])
+ connman_warn("Unknown configuration key %s in [%s]",
+ avail_keys[i], group);
+ }
+
+ g_strfreev(avail_keys);
+}
+
+static int load_config(struct vpn_config *config, char *path, enum what action)
+{
+ GKeyFile *keyfile;
+ gsize length;
+ char **groups;
+ char *str;
+ bool found = false;
+ int i;
+
+ DBG("config %p", config);
+
+ keyfile = __connman_storage_load_provider_config(config->ident);
+ if (!keyfile)
+ return -EIO;
+
+ /* Verify keys validity of the global section */
+ check_keys(keyfile, "global", config_possible_keys);
+
+ str = __vpn_config_get_string(keyfile, "global", CONFIG_KEY_NAME, NULL);
+ if (str) {
+ g_free(config->name);
+ config->name = str;
+ }
+
+ str = __vpn_config_get_string(keyfile, "global", CONFIG_KEY_DESC, NULL);
+ if (str) {
+ g_free(config->description);
+ config->description = str;
+ }
+
+ groups = g_key_file_get_groups(keyfile, &length);
+
+ for (i = 0; groups[i]; i++) {
+ if (g_str_has_prefix(groups[i], "provider_")) {
+ int ret = load_provider(keyfile, groups[i], config,
+ action);
+ if (ret == 0 || ret == -EALREADY)
+ found = true;
+ }
+ }
+
+ if (!found)
+ connman_warn("Config file %s/%s.config does not contain any "
+ "configuration that can be provisioned!",
+ path, config->ident);
+
+ g_strfreev(groups);
+
+ g_key_file_free(keyfile);
+
+ return 0;
+}
+
+static struct vpn_config *create_config(const char *ident)
+{
+ struct vpn_config *config;
+
+ DBG("ident %s", ident);
+
+ if (g_hash_table_lookup(config_table, ident))
+ return NULL;
+
+ config = g_try_new0(struct vpn_config, 1);
+ if (!config)
+ return NULL;
+
+ config->ident = g_strdup(ident);
+
+ config->provider_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, unregister_provider);
+
+ g_hash_table_insert(config_table, config->ident, config);
+
+ connman_info("Adding configuration %s", config->ident);
+
+ return config;
+}
+
+static bool validate_ident(const char *ident)
+{
+ unsigned int i;
+
+ if (!ident)
+ return false;
+
+ for (i = 0; i < strlen(ident); i++)
+ if (!g_ascii_isprint(ident[i]))
+ return false;
+
+ return true;
+}
+
+static char *get_dir(void)
+{
+ return g_strdup_printf("%s", VPN_STORAGEDIR);
+}
+
+static int read_configs(void)
+{
+ GDir *dir;
+ char *path = get_dir();
+
+ DBG("path %s", path);
+
+ dir = g_dir_open(path, 0, NULL);
+ if (dir) {
+ const gchar *file;
+
+ while ((file = g_dir_read_name(dir))) {
+ GString *str;
+ gchar *ident;
+
+ if (!g_str_has_suffix(file, ".config"))
+ continue;
+
+ ident = g_strrstr(file, ".config");
+ if (!ident)
+ continue;
+
+ str = g_string_new_len(file, ident - file);
+ if (!str)
+ continue;
+
+ ident = g_string_free(str, FALSE);
+
+ if (validate_ident(ident)) {
+ struct vpn_config *config;
+
+ config = create_config(ident);
+ if (config)
+ load_config(config, path, ADD);
+ } else {
+ connman_error("Invalid config ident %s", ident);
+ }
+ g_free(ident);
+ }
+
+ g_dir_close(dir);
+ }
+
+ g_free(path);
+
+ return 0;
+}
+
+static void config_notify_handler(struct inotify_event *event,
+ const char *ident)
+{
+ char *ext;
+
+ if (!ident)
+ return;
+
+ if (!g_str_has_suffix(ident, ".config"))
+ return;
+
+ ext = g_strrstr(ident, ".config");
+ if (!ext)
+ return;
+
+ *ext = '\0';
+
+ if (!validate_ident(ident)) {
+ connman_error("Invalid config ident %s", ident);
+ return;
+ }
+
+ if (event->mask & IN_CREATE)
+ return;
+
+ if (event->mask & IN_DELETE) {
+ g_hash_table_remove(config_table, ident);
+ return;
+ }
+
+ if (event->mask & IN_MODIFY) {
+ struct vpn_config *config;
+ char *path = get_dir();
+
+ config = g_hash_table_lookup(config_table, ident);
+ if (config) {
+ g_hash_table_remove_all(config->provider_table);
+ load_config(config, path, REMOVE);
+
+ /* Re-scan the config file for any changes */
+ g_hash_table_remove_all(config->provider_table);
+ load_config(config, path, ADD);
+ } else {
+ /*
+ * Inotify will send create event followed by modify
+ * event for any config file that is copied to
+ * monitored directory. So in practice we should just
+ * ignore the create event and trust only the modify
+ * one in order to avoid create/remove/create loop
+ */
+ config = create_config(ident);
+ if (config)
+ load_config(config, path, ADD);
+ }
+
+ g_free(path);
+ }
+}
+
+int __vpn_config_init(void)
+{
+ char *dir = get_dir();
+
+ DBG("");
+
+ config_table = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, unregister_config);
+
+ connman_inotify_register(dir, config_notify_handler);
+
+ g_free(dir);
+
+ return read_configs();
+}
+
+void __vpn_config_cleanup(void)
+{
+ char *dir = get_dir();
+
+ DBG("");
+
+ cleanup = true;
+
+ connman_inotify_unregister(dir, config_notify_handler);
+
+ g_free(dir);
+
+ g_hash_table_destroy(config_table);
+ config_table = NULL;
+
+ cleanup = false;
+}
+
+char *__vpn_config_get_string(GKeyFile *key_file,
+ const char *group_name, const char *key, GError **error)
+{
+ char *str = g_key_file_get_string(key_file, group_name, key, error);
+ if (!str)
+ return NULL;
+
+ return g_strchomp(str);
+}
+
+char **__vpn_config_get_string_list(GKeyFile *key_file,
+ const char *group_name, const char *key, gsize *length, GError **error)
+{
+ char **p;
+ char **strlist = g_key_file_get_string_list(key_file, group_name, key,
+ length, error);
+ if (!strlist)
+ return NULL;
+
+ p = strlist;
+ while (*p) {
+ *p = g_strstrip(*p);
+ p++;
+ }
+
+ return strlist;
+}
diff --git a/vpn/vpn-dbus.conf b/vpn/vpn-dbus.conf
new file mode 100644
index 0000000..0f0c8da
--- /dev/null
+++ b/vpn/vpn-dbus.conf
@@ -0,0 +1,15 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <policy user="root">
+ <allow own="net.connman.vpn"/>
+ <allow send_destination="net.connman.vpn"/>
+ <allow send_interface="net.connman.vpn.Agent"/>
+ </policy>
+ <policy at_console="true">
+ <allow send_destination="net.connman.vpn"/>
+ </policy>
+ <policy context="default">
+ <deny send_destination="net.connman.vpn"/>
+ </policy>
+</busconfig>
diff --git a/vpn/vpn-ipconfig.c b/vpn/vpn-ipconfig.c
new file mode 100644
index 0000000..c096fa3
--- /dev/null
+++ b/vpn/vpn-ipconfig.c
@@ -0,0 +1,453 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <net/if.h>
+#include <net/if_arp.h>
+#include <linux/if_link.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <arpa/inet.h>
+
+#ifndef IFF_LOWER_UP
+#define IFF_LOWER_UP 0x10000
+#endif
+
+#include <gdbus.h>
+
+#include "../src/connman.h"
+
+#include "vpn.h"
+
+struct vpn_ipconfig {
+ int refcount;
+ int index;
+ int family;
+ bool enabled;
+ struct connman_ipaddress *address;
+ struct connman_ipaddress *system;
+};
+
+struct vpn_ipdevice {
+ int index;
+ char *ifname;
+ unsigned short type;
+ unsigned int flags;
+ char *address;
+ uint16_t mtu;
+
+ GSList *address_list;
+ char *ipv4_gateway;
+ char *ipv6_gateway;
+
+ char *pac;
+};
+
+static GHashTable *ipdevice_hash = NULL;
+
+struct connman_ipaddress *
+__vpn_ipconfig_get_address(struct vpn_ipconfig *ipconfig)
+{
+ if (!ipconfig)
+ return NULL;
+
+ return ipconfig->address;
+}
+
+const char *__vpn_ipconfig_get_peer(struct vpn_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->peer;
+}
+
+unsigned short __vpn_ipconfig_get_type_from_index(int index)
+{
+ struct vpn_ipdevice *ipdevice;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return ARPHRD_VOID;
+
+ return ipdevice->type;
+}
+
+unsigned int __vpn_ipconfig_get_flags_from_index(int index)
+{
+ struct vpn_ipdevice *ipdevice;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return 0;
+
+ return ipdevice->flags;
+}
+
+void __vpn_ipconfig_foreach(void (*function) (int index,
+ void *user_data), void *user_data)
+{
+ GList *list, *keys;
+
+ keys = g_hash_table_get_keys(ipdevice_hash);
+ if (!keys)
+ return;
+
+ for (list = g_list_first(keys); list; list = g_list_next(list)) {
+ int index = GPOINTER_TO_INT(list->data);
+
+ function(index, user_data);
+ }
+
+ g_list_free(keys);
+}
+
+void __vpn_ipconfig_set_local(struct vpn_ipconfig *ipconfig,
+ const char *address)
+{
+ if (!ipconfig->address)
+ return;
+
+ g_free(ipconfig->address->local);
+ ipconfig->address->local = g_strdup(address);
+}
+
+const char *__vpn_ipconfig_get_local(struct vpn_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->local;
+}
+
+void __vpn_ipconfig_set_peer(struct vpn_ipconfig *ipconfig,
+ const char *address)
+{
+ if (!ipconfig->address)
+ return;
+
+ g_free(ipconfig->address->peer);
+ ipconfig->address->peer = g_strdup(address);
+}
+
+void __vpn_ipconfig_set_broadcast(struct vpn_ipconfig *ipconfig,
+ const char *broadcast)
+{
+ if (!ipconfig->address)
+ return;
+
+ g_free(ipconfig->address->broadcast);
+ ipconfig->address->broadcast = g_strdup(broadcast);
+}
+
+void __vpn_ipconfig_set_gateway(struct vpn_ipconfig *ipconfig,
+ const char *gateway)
+{
+ DBG("");
+
+ if (!ipconfig->address)
+ return;
+ g_free(ipconfig->address->gateway);
+ ipconfig->address->gateway = g_strdup(gateway);
+}
+
+const char *
+__vpn_ipconfig_get_gateway(struct vpn_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return NULL;
+
+ return ipconfig->address->gateway;
+}
+
+void __vpn_ipconfig_set_prefixlen(struct vpn_ipconfig *ipconfig,
+ unsigned char prefixlen)
+{
+ if (!ipconfig->address)
+ return;
+
+ ipconfig->address->prefixlen = prefixlen;
+}
+
+unsigned char
+__vpn_ipconfig_get_prefixlen(struct vpn_ipconfig *ipconfig)
+{
+ if (!ipconfig->address)
+ return 0;
+
+ return ipconfig->address->prefixlen;
+}
+
+int __vpn_ipconfig_address_add(struct vpn_ipconfig *ipconfig, int family)
+{
+ DBG("ipconfig %p family %d", ipconfig, family);
+
+ if (!ipconfig)
+ return -EINVAL;
+
+ if (family == AF_INET)
+ return connman_inet_set_address(ipconfig->index,
+ ipconfig->address);
+ else if (family == AF_INET6)
+ return connman_inet_set_ipv6_address(ipconfig->index,
+ ipconfig->address);
+
+ return 0;
+}
+
+int __vpn_ipconfig_gateway_add(struct vpn_ipconfig *ipconfig, int family)
+{
+ DBG("ipconfig %p family %d", ipconfig, family);
+
+ if (!ipconfig || !ipconfig->address)
+ return -EINVAL;
+
+ DBG("family %d gw %s peer %s", family,
+ ipconfig->address->gateway, ipconfig->address->peer);
+
+ if (family == AF_INET)
+ connman_inet_add_host_route(ipconfig->index,
+ ipconfig->address->gateway,
+ ipconfig->address->peer);
+ else if (family == AF_INET6)
+ connman_inet_add_ipv6_host_route(ipconfig->index,
+ ipconfig->address->gateway,
+ ipconfig->address->peer);
+ else
+ return -EINVAL;
+
+ return 0;
+}
+
+void __vpn_ipconfig_unref_debug(struct vpn_ipconfig *ipconfig,
+ const char *file, int line, const char *caller)
+{
+ if (!ipconfig)
+ return;
+
+ DBG("%p ref %d by %s:%d:%s()", ipconfig, ipconfig->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&ipconfig->refcount, 1) != 1)
+ return;
+
+ connman_ipaddress_free(ipconfig->system);
+ connman_ipaddress_free(ipconfig->address);
+ g_free(ipconfig);
+}
+
+static struct vpn_ipconfig *create_ipv6config(int index)
+{
+ struct vpn_ipconfig *ipv6config;
+
+ DBG("index %d", index);
+
+ ipv6config = g_try_new0(struct vpn_ipconfig, 1);
+ if (!ipv6config)
+ return NULL;
+
+ ipv6config->refcount = 1;
+
+ ipv6config->index = index;
+ ipv6config->enabled = false;
+ ipv6config->family = AF_INET6;
+
+ ipv6config->address = connman_ipaddress_alloc(AF_INET6);
+ if (!ipv6config->address) {
+ g_free(ipv6config);
+ return NULL;
+ }
+
+ ipv6config->system = connman_ipaddress_alloc(AF_INET6);
+
+ DBG("ipconfig %p", ipv6config);
+
+ return ipv6config;
+}
+
+struct vpn_ipconfig *__vpn_ipconfig_create(int index, int family)
+{
+ struct vpn_ipconfig *ipconfig;
+
+ if (family == AF_INET6)
+ return create_ipv6config(index);
+
+ DBG("index %d", index);
+
+ ipconfig = g_try_new0(struct vpn_ipconfig, 1);
+ if (!ipconfig)
+ return NULL;
+
+ ipconfig->refcount = 1;
+
+ ipconfig->index = index;
+ ipconfig->enabled = false;
+ ipconfig->family = family;
+
+ ipconfig->address = connman_ipaddress_alloc(AF_INET);
+ if (!ipconfig->address) {
+ g_free(ipconfig);
+ return NULL;
+ }
+
+ ipconfig->system = connman_ipaddress_alloc(AF_INET);
+
+ DBG("ipconfig %p", ipconfig);
+
+ return ipconfig;
+}
+
+void __vpn_ipconfig_set_index(struct vpn_ipconfig *ipconfig, int index)
+{
+ ipconfig->index = index;
+}
+
+static const char *type2str(unsigned short type)
+{
+ switch (type) {
+ case ARPHRD_ETHER:
+ return "ETHER";
+ case ARPHRD_LOOPBACK:
+ return "LOOPBACK";
+ case ARPHRD_PPP:
+ return "PPP";
+ case ARPHRD_NONE:
+ return "NONE";
+ case ARPHRD_VOID:
+ return "VOID";
+ }
+
+ return "";
+}
+
+void __vpn_ipconfig_newlink(int index, unsigned short type,
+ unsigned int flags,
+ const char *address,
+ unsigned short mtu,
+ struct rtnl_link_stats *stats)
+{
+ struct vpn_ipdevice *ipdevice;
+ GString *str;
+
+ if (type == ARPHRD_LOOPBACK)
+ return;
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (ipdevice)
+ goto update;
+
+ ipdevice = g_try_new0(struct vpn_ipdevice, 1);
+ if (!ipdevice)
+ return;
+
+ ipdevice->index = index;
+ ipdevice->ifname = connman_inet_ifname(index);
+ ipdevice->type = type;
+
+ ipdevice->address = g_strdup(address);
+
+ g_hash_table_insert(ipdevice_hash, GINT_TO_POINTER(index), ipdevice);
+
+ connman_info("%s {create} index %d type %d <%s>", ipdevice->ifname,
+ index, type, type2str(type));
+
+update:
+ ipdevice->mtu = mtu;
+
+ if (flags == ipdevice->flags)
+ return;
+
+ ipdevice->flags = flags;
+
+ str = g_string_new(NULL);
+ if (!str)
+ return;
+
+ if (flags & IFF_UP)
+ g_string_append(str, "UP");
+ else
+ g_string_append(str, "DOWN");
+
+ if (flags & IFF_RUNNING)
+ g_string_append(str, ",RUNNING");
+
+ if (flags & IFF_LOWER_UP)
+ g_string_append(str, ",LOWER_UP");
+
+ connman_info("%s {update} flags %u <%s>", ipdevice->ifname,
+ flags, str->str);
+
+ g_string_free(str, TRUE);
+}
+
+void __vpn_ipconfig_dellink(int index, struct rtnl_link_stats *stats)
+{
+ struct vpn_ipdevice *ipdevice;
+
+ DBG("index %d", index);
+
+ ipdevice = g_hash_table_lookup(ipdevice_hash, GINT_TO_POINTER(index));
+ if (!ipdevice)
+ return;
+
+ g_hash_table_remove(ipdevice_hash, GINT_TO_POINTER(index));
+}
+
+static void free_ipdevice(gpointer data)
+{
+ struct vpn_ipdevice *ipdevice = data;
+
+ connman_info("%s {remove} index %d", ipdevice->ifname,
+ ipdevice->index);
+
+ g_free(ipdevice->ipv4_gateway);
+ g_free(ipdevice->ipv6_gateway);
+ g_free(ipdevice->pac);
+
+ g_free(ipdevice->address);
+
+ g_free(ipdevice->ifname);
+ g_free(ipdevice);
+}
+
+int __vpn_ipconfig_init(void)
+{
+ DBG("");
+
+ ipdevice_hash = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_ipdevice);
+
+ return 0;
+}
+
+void __vpn_ipconfig_cleanup(void)
+{
+ DBG("");
+
+ g_hash_table_destroy(ipdevice_hash);
+ ipdevice_hash = NULL;
+}
diff --git a/vpn/vpn-manager.c b/vpn/vpn-manager.c
new file mode 100644
index 0000000..021d625
--- /dev/null
+++ b/vpn/vpn-manager.c
@@ -0,0 +1,189 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+
+#include <gdbus.h>
+#include <connman/log.h>
+#include <connman/agent.h>
+
+#include "../src/connman.h"
+
+#include "vpn.h"
+#include "connman/vpn-dbus.h"
+
+static int vpn_connect_count;
+static DBusConnection *connection;
+
+static DBusMessage *create(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ int err;
+
+ DBG("conn %p", conn);
+
+ err = __vpn_provider_create(msg);
+ if (err < 0) {
+ if (err == -EINPROGRESS) {
+ connman_error("Invalid return code (%d) "
+ "from connect", err);
+ err = -EINVAL;
+ }
+
+ return __connman_error_failed(msg, -err);
+ }
+
+ return NULL;
+}
+
+static DBusMessage *remove(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ const char *path;
+ int err;
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ DBG("conn %p path %s", conn, path);
+
+ err = __vpn_provider_remove(path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *get_connections(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ DBusMessage *reply;
+
+ DBG("conn %p", conn);
+
+ reply = __vpn_provider_get_connections(msg);
+ if (!reply)
+ return __connman_error_failed(msg, EINVAL);
+
+ return reply;
+}
+
+static DBusMessage *register_agent(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender, *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = connman_agent_register(sender, path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *unregister_agent(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ const char *sender, *path;
+ int err;
+
+ DBG("conn %p", conn);
+
+ sender = dbus_message_get_sender(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_OBJECT_PATH, &path,
+ DBUS_TYPE_INVALID);
+
+ err = connman_agent_unregister(sender, path);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable manager_methods[] = {
+ { GDBUS_ASYNC_METHOD("Create",
+ GDBUS_ARGS({ "properties", "a{sv}" }),
+ GDBUS_ARGS({ "path", "o" }),
+ create) },
+ { GDBUS_ASYNC_METHOD("Remove",
+ GDBUS_ARGS({ "identifier", "o" }), NULL,
+ remove) },
+ { GDBUS_METHOD("GetConnections", NULL,
+ GDBUS_ARGS({ "connections", "a(oa{sv})" }),
+ get_connections) },
+ { GDBUS_METHOD("RegisterAgent",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ register_agent) },
+ { GDBUS_METHOD("UnregisterAgent",
+ GDBUS_ARGS({ "path", "o" }), NULL,
+ unregister_agent) },
+ { },
+};
+
+static const GDBusSignalTable manager_signals[] = {
+ { GDBUS_SIGNAL("ConnectionAdded",
+ GDBUS_ARGS({ "identifier", "o" },
+ { "properties", "a{sv}" })) },
+ { GDBUS_SIGNAL("ConnectionRemoved",
+ GDBUS_ARGS({ "identifier", "o" })) },
+ { },
+};
+
+int __vpn_manager_init(void)
+{
+ DBG("");
+
+ connection = connman_dbus_get_connection();
+ if (!connection)
+ return -1;
+
+ g_dbus_register_interface(connection, VPN_MANAGER_PATH,
+ VPN_MANAGER_INTERFACE,
+ manager_methods,
+ manager_signals, NULL, NULL, NULL);
+
+ vpn_connect_count = 0;
+
+ return 0;
+}
+
+void __vpn_manager_cleanup(void)
+{
+ DBG("");
+
+ if (!connection)
+ return;
+
+ g_dbus_unregister_interface(connection, VPN_MANAGER_PATH,
+ VPN_MANAGER_INTERFACE);
+
+ dbus_connection_unref(connection);
+}
diff --git a/vpn/vpn-polkit.conf b/vpn/vpn-polkit.conf
new file mode 100644
index 0000000..a1dc617
--- /dev/null
+++ b/vpn/vpn-polkit.conf
@@ -0,0 +1,11 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <policy user="root">
+ <allow own="net.connman.vpn"/>
+ <allow send_interface="net.connman.vpn.Agent"/>
+ </policy>
+ <policy context="default">
+ <allow send_destination="net.connman.vpn"/>
+ </policy>
+</busconfig>
diff --git a/vpn/vpn-polkit.policy b/vpn/vpn-polkit.policy
new file mode 100644
index 0000000..0c42722
--- /dev/null
+++ b/vpn/vpn-polkit.policy
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE policyconfig PUBLIC
+ "-//freedesktop//DTD PolicyKit Policy Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/PolicyKit/1.0/policyconfig.dtd">
+
+<policyconfig>
+
+ <vendor>Connection Manager VPN daemon</vendor>
+ <icon_name>network-wireless</icon_name>
+
+ <action id="net.connman.vpn.modify">
+ <description>Settings configuration</description>
+ <message>Policy prevents modification of settings</message>
+ <defaults>
+ <allow_inactive>no</allow_inactive>
+ <allow_active>auth_self_keep_session</allow_active>
+ </defaults>
+ </action>
+
+ <action id="net.connman.vpn.secret">
+ <description>Secrets configuration</description>
+ <message>Policy prevents modification of secrets</message>
+ <defaults>
+ <allow_inactive>no</allow_inactive>
+ <allow_active>auth_admin_keep_session</allow_active>
+ </defaults>
+ </action>
+
+</policyconfig>
diff --git a/vpn/vpn-provider.c b/vpn/vpn-provider.c
new file mode 100644
index 0000000..16c0c2b
--- /dev/null
+++ b/vpn/vpn-provider.c
@@ -0,0 +1,2739 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <gdbus.h>
+#include <connman/log.h>
+#include <gweb/gresolv.h>
+#include <netdb.h>
+
+#include "../src/connman.h"
+#include "connman/agent.h"
+#include "connman/vpn-dbus.h"
+#include "vpn-provider.h"
+#include "vpn.h"
+
+static DBusConnection *connection;
+static GHashTable *provider_hash;
+static GSList *driver_list;
+static int configuration_count;
+static bool handle_routes;
+
+struct vpn_route {
+ int family;
+ char *network;
+ char *netmask;
+ char *gateway;
+};
+
+struct vpn_setting {
+ bool hide_value;
+ bool immutable;
+ char *value;
+};
+
+struct vpn_provider {
+ int refcount;
+ int index;
+ int fd;
+ enum vpn_provider_state state;
+ char *path;
+ char *identifier;
+ char *name;
+ char *type;
+ char *host;
+ char *domain;
+ int family;
+ GHashTable *routes;
+ struct vpn_provider_driver *driver;
+ void *driver_data;
+ GHashTable *setting_strings;
+ GHashTable *user_routes;
+ GSList *user_networks;
+ GResolv *resolv;
+ char **host_ip;
+ struct vpn_ipconfig *ipconfig_ipv4;
+ struct vpn_ipconfig *ipconfig_ipv6;
+ char **nameservers;
+ guint notify_id;
+ char *config_file;
+ char *config_entry;
+ bool immutable;
+ struct connman_ipaddress *prev_ipv4_addr;
+ struct connman_ipaddress *prev_ipv6_addr;
+};
+
+static void append_properties(DBusMessageIter *iter,
+ struct vpn_provider *provider);
+
+static void free_route(gpointer data)
+{
+ struct vpn_route *route = data;
+
+ g_free(route->network);
+ g_free(route->netmask);
+ g_free(route->gateway);
+
+ g_free(route);
+}
+
+static void free_setting(gpointer data)
+{
+ struct vpn_setting *setting = data;
+
+ g_free(setting->value);
+ g_free(setting);
+}
+
+static void append_route(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_route *route = user_data;
+ DBusMessageIter item;
+ int family = 0;
+
+ connman_dbus_dict_open(iter, &item);
+
+ if (!route)
+ goto empty_dict;
+
+ if (route->family == AF_INET)
+ family = 4;
+ else if (route->family == AF_INET6)
+ family = 6;
+
+ if (family != 0)
+ connman_dbus_dict_append_basic(&item, "ProtocolFamily",
+ DBUS_TYPE_INT32, &family);
+
+ if (route->network)
+ connman_dbus_dict_append_basic(&item, "Network",
+ DBUS_TYPE_STRING, &route->network);
+
+ if (route->netmask)
+ connman_dbus_dict_append_basic(&item, "Netmask",
+ DBUS_TYPE_STRING, &route->netmask);
+
+ if (route->gateway)
+ connman_dbus_dict_append_basic(&item, "Gateway",
+ DBUS_TYPE_STRING, &route->gateway);
+
+empty_dict:
+ connman_dbus_dict_close(iter, &item);
+}
+
+static void append_routes(DBusMessageIter *iter, void *user_data)
+{
+ GHashTable *routes = user_data;
+ GHashTableIter hash;
+ gpointer value, key;
+
+ if (!routes) {
+ append_route(iter, NULL);
+ return;
+ }
+
+ g_hash_table_iter_init(&hash, routes);
+
+ while (g_hash_table_iter_next(&hash, &key, &value)) {
+ DBusMessageIter dict;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT, NULL,
+ &dict);
+ append_route(&dict, value);
+ dbus_message_iter_close_container(iter, &dict);
+ }
+}
+
+static void send_routes(struct vpn_provider *provider, GHashTable *routes,
+ const char *name)
+{
+ connman_dbus_property_changed_array(provider->path,
+ VPN_CONNECTION_INTERFACE,
+ name,
+ DBUS_TYPE_DICT_ENTRY,
+ append_routes,
+ routes);
+}
+
+static int provider_routes_changed(struct vpn_provider *provider)
+{
+ DBG("provider %p", provider);
+
+ send_routes(provider, provider->routes, "ServerRoutes");
+
+ return 0;
+}
+
+static GSList *read_route_dict(GSList *routes, DBusMessageIter *dicts)
+{
+ DBusMessageIter dict, value, entry;
+ const char *network, *netmask, *gateway;
+ struct vpn_route *route;
+ int family, type;
+ const char *key;
+
+ dbus_message_iter_recurse(dicts, &entry);
+
+ network = netmask = gateway = NULL;
+ family = PF_UNSPEC;
+
+ while (dbus_message_iter_get_arg_type(&entry) == DBUS_TYPE_DICT_ENTRY) {
+
+ dbus_message_iter_recurse(&entry, &dict);
+ dbus_message_iter_get_basic(&dict, &key);
+
+ dbus_message_iter_next(&dict);
+ dbus_message_iter_recurse(&dict, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ switch (type) {
+ case DBUS_TYPE_INT32:
+ if (g_str_equal(key, "ProtocolFamily"))
+ dbus_message_iter_get_basic(&value, &family);
+ break;
+
+ case DBUS_TYPE_STRING:
+ if (g_str_equal(key, "Network"))
+ dbus_message_iter_get_basic(&value, &network);
+ else if (g_str_equal(key, "Netmask"))
+ dbus_message_iter_get_basic(&value, &netmask);
+ else if (g_str_equal(key, "Gateway"))
+ dbus_message_iter_get_basic(&value, &gateway);
+ break;
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ DBG("family %d network %s netmask %s gateway %s", family,
+ network, netmask, gateway);
+
+ if (!network || !netmask) {
+ DBG("Ignoring route as network/netmask is missing");
+ return routes;
+ }
+
+ route = g_try_new(struct vpn_route, 1);
+ if (!route) {
+ g_slist_free_full(routes, free_route);
+ return NULL;
+ }
+
+ if (family == PF_UNSPEC) {
+ family = connman_inet_check_ipaddress(network);
+ if (family < 0) {
+ DBG("Cannot get address family of %s (%d/%s)", network,
+ family, gai_strerror(family));
+
+ g_free(route);
+ return routes;
+ }
+ } else {
+ switch (family) {
+ case '4':
+ family = AF_INET;
+ break;
+ case '6':
+ family = AF_INET6;
+ break;
+ default:
+ family = PF_UNSPEC;
+ break;
+ }
+ }
+
+ route->family = family;
+ route->network = g_strdup(network);
+ route->netmask = g_strdup(netmask);
+ route->gateway = g_strdup(gateway);
+
+ routes = g_slist_prepend(routes, route);
+ return routes;
+}
+
+static GSList *get_user_networks(DBusMessageIter *array)
+{
+ DBusMessageIter entry;
+ GSList *list = NULL;
+
+ while (dbus_message_iter_get_arg_type(array) == DBUS_TYPE_ARRAY) {
+
+ dbus_message_iter_recurse(array, &entry);
+
+ while (dbus_message_iter_get_arg_type(&entry) ==
+ DBUS_TYPE_STRUCT) {
+ DBusMessageIter dicts;
+
+ dbus_message_iter_recurse(&entry, &dicts);
+
+ while (dbus_message_iter_get_arg_type(&dicts) ==
+ DBUS_TYPE_ARRAY) {
+
+ list = read_route_dict(list, &dicts);
+ dbus_message_iter_next(&dicts);
+ }
+
+ dbus_message_iter_next(&entry);
+ }
+
+ dbus_message_iter_next(array);
+ }
+
+ return list;
+}
+
+static void set_user_networks(struct vpn_provider *provider, GSList *networks)
+{
+ GSList *list;
+
+ for (list = networks; list; list = g_slist_next(list)) {
+ struct vpn_route *route = list->data;
+
+ if (__vpn_provider_append_user_route(provider,
+ route->family, route->network,
+ route->netmask, route->gateway) != 0)
+ break;
+ }
+}
+
+static void del_routes(struct vpn_provider *provider)
+{
+ GHashTableIter hash;
+ gpointer value, key;
+
+ g_hash_table_iter_init(&hash, provider->user_routes);
+ while (handle_routes && g_hash_table_iter_next(&hash,
+ &key, &value)) {
+ struct vpn_route *route = value;
+ if (route->family == AF_INET6) {
+ unsigned char prefixlen = atoi(route->netmask);
+ connman_inet_del_ipv6_network_route(provider->index,
+ route->network,
+ prefixlen);
+ } else
+ connman_inet_del_host_route(provider->index,
+ route->network);
+ }
+
+ g_hash_table_remove_all(provider->user_routes);
+ g_slist_free_full(provider->user_networks, free_route);
+ provider->user_networks = NULL;
+}
+
+static void send_value(const char *path, const char *key, const char *value)
+{
+ const char *empty = "";
+ const char *str;
+
+ if (value)
+ str = value;
+ else
+ str = empty;
+
+ connman_dbus_property_changed_basic(path,
+ VPN_CONNECTION_INTERFACE,
+ key,
+ DBUS_TYPE_STRING,
+ &str);
+}
+
+static gboolean provider_send_changed(gpointer data)
+{
+ struct vpn_provider *provider = data;
+
+ provider_routes_changed(provider);
+
+ provider->notify_id = 0;
+
+ return FALSE;
+}
+
+static void provider_schedule_changed(struct vpn_provider *provider)
+{
+ if (provider->notify_id != 0)
+ g_source_remove(provider->notify_id);
+
+ provider->notify_id = g_timeout_add(100, provider_send_changed,
+ provider);
+}
+
+static DBusMessage *get_properties(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct vpn_provider *provider = data;
+ DBusMessage *reply;
+ DBusMessageIter array;
+
+ DBG("provider %p", provider);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &array);
+
+ append_properties(&array, provider);
+
+ return reply;
+}
+
+static DBusMessage *set_property(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ struct vpn_provider *provider = data;
+ DBusMessageIter iter, value;
+ const char *name;
+ int type;
+
+ DBG("conn %p", conn);
+
+ if (provider->immutable)
+ return __connman_error_not_supported(msg);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ if (g_str_equal(name, "UserRoutes")) {
+ GSList *networks;
+
+ if (type != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ networks = get_user_networks(&value);
+ if (networks) {
+ del_routes(provider);
+ provider->user_networks = networks;
+ set_user_networks(provider, provider->user_networks);
+
+ if (!handle_routes)
+ send_routes(provider, provider->user_routes,
+ "UserRoutes");
+ }
+ } else {
+ const char *str;
+
+ dbus_message_iter_get_basic(&value, &str);
+ vpn_provider_set_string(provider, name, str);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *clear_property(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ struct vpn_provider *provider = data;
+ const char *name;
+
+ DBG("conn %p", conn);
+
+ if (provider->immutable)
+ return __connman_error_not_supported(msg);
+
+ dbus_message_get_args(msg, NULL, DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID);
+
+ if (g_str_equal(name, "UserRoutes")) {
+ del_routes(provider);
+
+ if (!handle_routes)
+ send_routes(provider, provider->user_routes, name);
+ } else if (vpn_provider_get_string(provider, name)) {
+ vpn_provider_set_string(provider, name, NULL);
+ } else {
+ return __connman_error_invalid_property(msg);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *do_connect(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ struct vpn_provider *provider = data;
+ int err;
+
+ DBG("conn %p provider %p", conn, provider);
+
+ err = __vpn_provider_connect(provider, msg);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ return NULL;
+}
+
+static DBusMessage *do_disconnect(DBusConnection *conn, DBusMessage *msg,
+ void *data)
+{
+ struct vpn_provider *provider = data;
+ int err;
+
+ DBG("conn %p provider %p", conn, provider);
+
+ err = __vpn_provider_disconnect(provider);
+ if (err < 0 && err != -EINPROGRESS)
+ return __connman_error_failed(msg, -err);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static const GDBusMethodTable connection_methods[] = {
+ { GDBUS_METHOD("GetProperties",
+ NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+ get_properties) },
+ { GDBUS_METHOD("SetProperty",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+ NULL, set_property) },
+ { GDBUS_METHOD("ClearProperty",
+ GDBUS_ARGS({ "name", "s" }), NULL,
+ clear_property) },
+ { GDBUS_ASYNC_METHOD("Connect", NULL, NULL, do_connect) },
+ { GDBUS_METHOD("Disconnect", NULL, NULL, do_disconnect) },
+ { },
+};
+
+static const GDBusSignalTable connection_signals[] = {
+ { GDBUS_SIGNAL("PropertyChanged",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { },
+};
+
+static void resolv_result(GResolvResultStatus status,
+ char **results, gpointer user_data)
+{
+ struct vpn_provider *provider = user_data;
+
+ DBG("status %d", status);
+
+ if (status == G_RESOLV_RESULT_STATUS_SUCCESS && results &&
+ g_strv_length(results) > 0)
+ provider->host_ip = g_strdupv(results);
+
+ vpn_provider_unref(provider);
+}
+
+static void provider_resolv_host_addr(struct vpn_provider *provider)
+{
+ if (!provider->host)
+ return;
+
+ if (connman_inet_check_ipaddress(provider->host) > 0)
+ return;
+
+ if (provider->host_ip)
+ return;
+
+ /*
+ * If the hostname is not numeric, try to resolv it. We do not wait
+ * the result as it might take some time. We will get the result
+ * before VPN will feed routes to us because VPN client will need
+ * the IP address also before VPN connection can be established.
+ */
+ provider->resolv = g_resolv_new(0);
+ if (!provider->resolv) {
+ DBG("Cannot resolv %s", provider->host);
+ return;
+ }
+
+ DBG("Trying to resolv %s", provider->host);
+
+ vpn_provider_ref(provider);
+
+ g_resolv_lookup_hostname(provider->resolv, provider->host,
+ resolv_result, provider);
+}
+
+void __vpn_provider_append_properties(struct vpn_provider *provider,
+ DBusMessageIter *iter)
+{
+ if (provider->host)
+ connman_dbus_dict_append_basic(iter, "Host",
+ DBUS_TYPE_STRING, &provider->host);
+
+ if (provider->domain)
+ connman_dbus_dict_append_basic(iter, "Domain",
+ DBUS_TYPE_STRING, &provider->domain);
+
+ if (provider->type)
+ connman_dbus_dict_append_basic(iter, "Type", DBUS_TYPE_STRING,
+ &provider->type);
+}
+
+int __vpn_provider_append_user_route(struct vpn_provider *provider,
+ int family, const char *network,
+ const char *netmask, const char *gateway)
+{
+ struct vpn_route *route;
+ char *key = g_strdup_printf("%d/%s/%s/%s", family, network,
+ netmask, gateway ? gateway : "");
+
+ DBG("family %d network %s netmask %s gw %s", family, network,
+ netmask, gateway);
+
+ route = g_hash_table_lookup(provider->user_routes, key);
+ if (!route) {
+ route = g_try_new0(struct vpn_route, 1);
+ if (!route) {
+ connman_error("out of memory");
+ return -ENOMEM;
+ }
+
+ route->family = family;
+ route->network = g_strdup(network);
+ route->netmask = g_strdup(netmask);
+ route->gateway = g_strdup(gateway);
+
+ g_hash_table_replace(provider->user_routes, key, route);
+ } else
+ g_free(key);
+
+ return 0;
+}
+
+static struct vpn_route *get_route(char *route_str)
+{
+ char **elems = g_strsplit(route_str, "/", 0);
+ char *network, *netmask, *gateway, *family_str;
+ int family = PF_UNSPEC;
+ struct vpn_route *route = NULL;
+
+ if (!elems)
+ return NULL;
+
+ family_str = elems[0];
+
+ network = elems[1];
+ if (!network || network[0] == '\0')
+ goto out;
+
+ netmask = elems[2];
+ if (!netmask || netmask[0] == '\0')
+ goto out;
+
+ gateway = elems[3];
+
+ route = g_try_new0(struct vpn_route, 1);
+ if (!route)
+ goto out;
+
+ if (family_str[0] == '\0' || atoi(family_str) == 0) {
+ family = PF_UNSPEC;
+ } else {
+ switch (family_str[0]) {
+ case '4':
+ family = AF_INET;
+ break;
+ case '6':
+ family = AF_INET6;
+ break;
+ }
+ }
+
+ if (g_strrstr(network, ":")) {
+ if (family != PF_UNSPEC && family != AF_INET6)
+ DBG("You have IPv6 address but you have non IPv6 route");
+ } else if (g_strrstr(network, ".")) {
+ if (family != PF_UNSPEC && family != AF_INET)
+ DBG("You have IPv4 address but you have non IPv4 route");
+
+ if (!g_strrstr(netmask, ".")) {
+ /* We have netmask length */
+ in_addr_t addr;
+ struct in_addr netmask_in;
+ unsigned char prefix_len = 32;
+
+ if (netmask) {
+ char *ptr;
+ long int value = strtol(netmask, &ptr, 10);
+ if (ptr != netmask && *ptr == '\0' &&
+ value <= 32)
+ prefix_len = value;
+ }
+
+ addr = 0xffffffff << (32 - prefix_len);
+ netmask_in.s_addr = htonl(addr);
+ netmask = inet_ntoa(netmask_in);
+
+ DBG("network %s netmask %s", network, netmask);
+ }
+ }
+
+ if (family == PF_UNSPEC) {
+ family = connman_inet_check_ipaddress(network);
+ if (family < 0 || family == PF_UNSPEC)
+ goto out;
+ }
+
+ route->family = family;
+ route->network = g_strdup(network);
+ route->netmask = g_strdup(netmask);
+ route->gateway = g_strdup(gateway);
+
+out:
+ g_strfreev(elems);
+ return route;
+}
+
+static GSList *get_routes(gchar **networks)
+{
+ struct vpn_route *route;
+ GSList *routes = NULL;
+ int i;
+
+ for (i = 0; networks[i]; i++) {
+ route = get_route(networks[i]);
+ if (route)
+ routes = g_slist_prepend(routes, route);
+ }
+
+ return routes;
+}
+
+static int provider_load_from_keyfile(struct vpn_provider *provider,
+ GKeyFile *keyfile)
+{
+ gsize idx = 0;
+ gchar **settings;
+ gchar *key, *value;
+ gsize length, num_user_networks;
+ gchar **networks = NULL;
+
+ settings = g_key_file_get_keys(keyfile, provider->identifier, &length,
+ NULL);
+ if (!settings) {
+ g_key_file_free(keyfile);
+ return -ENOENT;
+ }
+
+ while (idx < length) {
+ key = settings[idx];
+ if (key) {
+ if (g_str_equal(key, "Networks")) {
+ networks = __vpn_config_get_string_list(keyfile,
+ provider->identifier,
+ key,
+ &num_user_networks,
+ NULL);
+ provider->user_networks = get_routes(networks);
+
+ } else {
+ value = __vpn_config_get_string(keyfile,
+ provider->identifier,
+ key, NULL);
+ vpn_provider_set_string(provider, key,
+ value);
+ g_free(value);
+ }
+ }
+ idx += 1;
+ }
+ g_strfreev(settings);
+ g_strfreev(networks);
+
+ if (provider->user_networks)
+ set_user_networks(provider, provider->user_networks);
+
+ return 0;
+}
+
+
+static int vpn_provider_load(struct vpn_provider *provider)
+{
+ GKeyFile *keyfile;
+
+ DBG("provider %p", provider);
+
+ keyfile = __connman_storage_load_provider(provider->identifier);
+ if (!keyfile)
+ return -ENOENT;
+
+ provider_load_from_keyfile(provider, keyfile);
+
+ g_key_file_free(keyfile);
+ return 0;
+}
+
+static gchar **create_network_list(GSList *networks, gsize *count)
+{
+ GSList *list;
+ gchar **result = NULL;
+ unsigned int num_elems = 0;
+
+ for (list = networks; list; list = g_slist_next(list)) {
+ struct vpn_route *route = list->data;
+ int family;
+
+ result = g_try_realloc(result,
+ (num_elems + 1) * sizeof(gchar *));
+ if (!result)
+ return NULL;
+
+ switch (route->family) {
+ case AF_INET:
+ family = 4;
+ break;
+ case AF_INET6:
+ family = 6;
+ break;
+ default:
+ family = 0;
+ break;
+ }
+
+ result[num_elems] = g_strdup_printf("%d/%s/%s/%s",
+ family, route->network, route->netmask,
+ !route->gateway ? "" : route->gateway);
+
+ num_elems++;
+ }
+
+ result = g_try_realloc(result, (num_elems + 1) * sizeof(gchar *));
+ if (!result)
+ return NULL;
+
+ result[num_elems] = NULL;
+ *count = num_elems;
+ return result;
+}
+
+static int vpn_provider_save(struct vpn_provider *provider)
+{
+ GKeyFile *keyfile;
+
+ DBG("provider %p immutable %s", provider,
+ provider->immutable ? "yes" : "no");
+
+ if (provider->immutable) {
+ /*
+ * Do not save providers that are provisioned via .config
+ * file.
+ */
+ return -EPERM;
+ }
+
+ keyfile = g_key_file_new();
+ if (!keyfile)
+ return -ENOMEM;
+
+ g_key_file_set_string(keyfile, provider->identifier,
+ "Name", provider->name);
+ g_key_file_set_string(keyfile, provider->identifier,
+ "Type", provider->type);
+ g_key_file_set_string(keyfile, provider->identifier,
+ "Host", provider->host);
+ g_key_file_set_string(keyfile, provider->identifier,
+ "VPN.Domain", provider->domain);
+ if (provider->user_networks) {
+ gchar **networks;
+ gsize network_count;
+
+ networks = create_network_list(provider->user_networks,
+ &network_count);
+ if (networks) {
+ g_key_file_set_string_list(keyfile,
+ provider->identifier,
+ "Networks",
+ (const gchar ** const)networks,
+ network_count);
+ g_strfreev(networks);
+ }
+ }
+
+ if (provider->config_file && strlen(provider->config_file) > 0)
+ g_key_file_set_string(keyfile, provider->identifier,
+ "Config.file", provider->config_file);
+
+ if (provider->config_entry &&
+ strlen(provider->config_entry) > 0)
+ g_key_file_set_string(keyfile, provider->identifier,
+ "Config.ident", provider->config_entry);
+
+ if (provider->driver && provider->driver->save)
+ provider->driver->save(provider, keyfile);
+
+ __connman_storage_save_provider(keyfile, provider->identifier);
+ g_key_file_free(keyfile);
+
+ return 0;
+}
+
+struct vpn_provider *__vpn_provider_lookup(const char *identifier)
+{
+ struct vpn_provider *provider = NULL;
+
+ provider = g_hash_table_lookup(provider_hash, identifier);
+
+ return provider;
+}
+
+static bool match_driver(struct vpn_provider *provider,
+ struct vpn_provider_driver *driver)
+{
+ if (g_strcmp0(driver->name, provider->type) == 0)
+ return true;
+
+ return false;
+}
+
+static int provider_probe(struct vpn_provider *provider)
+{
+ GSList *list;
+
+ DBG("provider %p driver %p name %s", provider, provider->driver,
+ provider->name);
+
+ if (provider->driver)
+ return -EALREADY;
+
+ for (list = driver_list; list; list = list->next) {
+ struct vpn_provider_driver *driver = list->data;
+
+ if (!match_driver(provider, driver))
+ continue;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (driver->probe && driver->probe(provider) == 0) {
+ provider->driver = driver;
+ break;
+ }
+ }
+
+ if (!provider->driver)
+ return -ENODEV;
+
+ return 0;
+}
+
+static void provider_remove(struct vpn_provider *provider)
+{
+ if (provider->driver) {
+ provider->driver->remove(provider);
+ provider->driver = NULL;
+ }
+}
+
+static int provider_register(struct vpn_provider *provider)
+{
+ return provider_probe(provider);
+}
+
+static void provider_unregister(struct vpn_provider *provider)
+{
+ provider_remove(provider);
+}
+
+struct vpn_provider *
+vpn_provider_ref_debug(struct vpn_provider *provider,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount + 1,
+ file, line, caller);
+
+ __sync_fetch_and_add(&provider->refcount, 1);
+
+ return provider;
+}
+
+static void provider_destruct(struct vpn_provider *provider)
+{
+ DBG("provider %p", provider);
+
+ if (provider->notify_id != 0)
+ g_source_remove(provider->notify_id);
+
+ g_free(provider->name);
+ g_free(provider->type);
+ g_free(provider->host);
+ g_free(provider->domain);
+ g_free(provider->identifier);
+ g_free(provider->path);
+ g_slist_free_full(provider->user_networks, free_route);
+ g_strfreev(provider->nameservers);
+ g_hash_table_destroy(provider->routes);
+ g_hash_table_destroy(provider->user_routes);
+ g_hash_table_destroy(provider->setting_strings);
+ if (provider->resolv) {
+ g_resolv_unref(provider->resolv);
+ provider->resolv = NULL;
+ }
+ __vpn_ipconfig_unref(provider->ipconfig_ipv4);
+ __vpn_ipconfig_unref(provider->ipconfig_ipv6);
+
+ g_strfreev(provider->host_ip);
+ g_free(provider->config_file);
+ g_free(provider->config_entry);
+ connman_ipaddress_free(provider->prev_ipv4_addr);
+ connman_ipaddress_free(provider->prev_ipv6_addr);
+ g_free(provider);
+}
+
+void vpn_provider_unref_debug(struct vpn_provider *provider,
+ const char *file, int line, const char *caller)
+{
+ DBG("%p ref %d by %s:%d:%s()", provider, provider->refcount - 1,
+ file, line, caller);
+
+ if (__sync_fetch_and_sub(&provider->refcount, 1) != 1)
+ return;
+
+ provider_remove(provider);
+
+ provider_destruct(provider);
+}
+
+static void configuration_count_add(void)
+{
+ DBG("count %d", configuration_count + 1);
+
+ __sync_fetch_and_add(&configuration_count, 1);
+}
+
+static void configuration_count_del(void)
+{
+ DBG("count %d", configuration_count - 1);
+
+ if (__sync_fetch_and_sub(&configuration_count, 1) != 1)
+ return;
+}
+
+int __vpn_provider_disconnect(struct vpn_provider *provider)
+{
+ int err;
+
+ DBG("provider %p", provider);
+
+ if (provider->driver && provider->driver->disconnect)
+ err = provider->driver->disconnect(provider);
+ else
+ return -EOPNOTSUPP;
+
+ if (err == -EINPROGRESS)
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_CONNECT);
+
+ return err;
+}
+
+static void connect_cb(struct vpn_provider *provider, void *user_data,
+ int error)
+{
+ DBusMessage *pending = user_data;
+
+ DBG("provider %p user %p error %d", provider, user_data, error);
+
+ if (error != 0) {
+ DBusMessage *reply = __connman_error_failed(pending, error);
+ if (reply)
+ g_dbus_send_message(connection, reply);
+
+ vpn_provider_indicate_error(provider,
+ VPN_PROVIDER_ERROR_CONNECT_FAILED);
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
+ } else
+ g_dbus_send_reply(connection, pending, DBUS_TYPE_INVALID);
+
+ dbus_message_unref(pending);
+}
+
+int __vpn_provider_connect(struct vpn_provider *provider, DBusMessage *msg)
+{
+ int err;
+
+ DBG("provider %p", provider);
+
+ if (provider->driver && provider->driver->connect) {
+ dbus_message_ref(msg);
+ err = provider->driver->connect(provider, connect_cb,
+ dbus_message_get_sender(msg),
+ msg);
+ } else
+ return -EOPNOTSUPP;
+
+ if (err == -EINPROGRESS)
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_CONNECT);
+
+ return err;
+}
+
+static void connection_removed_signal(struct vpn_provider *provider)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ signal = dbus_message_new_signal(VPN_MANAGER_PATH,
+ VPN_MANAGER_INTERFACE, "ConnectionRemoved");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
+ &provider->path);
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+}
+
+static char *get_ident(const char *path)
+{
+ char *pos;
+
+ if (*path != '/')
+ return NULL;
+
+ pos = strrchr(path, '/');
+ if (!pos)
+ return NULL;
+
+ return pos + 1;
+}
+
+int __vpn_provider_remove(const char *path)
+{
+ struct vpn_provider *provider;
+ char *ident;
+
+ DBG("path %s", path);
+
+ ident = get_ident(path);
+
+ provider = __vpn_provider_lookup(ident);
+ if (provider)
+ return __vpn_provider_delete(provider);
+
+ return -ENXIO;
+}
+
+int __vpn_provider_delete(struct vpn_provider *provider)
+{
+ DBG("Deleting VPN %s", provider->identifier);
+
+ connection_removed_signal(provider);
+
+ provider_unregister(provider);
+
+ __connman_storage_remove_provider(provider->identifier);
+
+ g_hash_table_remove(provider_hash, provider->identifier);
+
+ return 0;
+}
+
+static void append_ipv4(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ const char *address, *gateway, *peer;
+
+ address = __vpn_ipconfig_get_local(provider->ipconfig_ipv4);
+ if (address) {
+ in_addr_t addr;
+ struct in_addr netmask;
+ char *mask;
+ int prefixlen;
+
+ prefixlen = __vpn_ipconfig_get_prefixlen(
+ provider->ipconfig_ipv4);
+
+ addr = 0xffffffff << (32 - prefixlen);
+ netmask.s_addr = htonl(addr);
+ mask = inet_ntoa(netmask);
+
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &address);
+
+ connman_dbus_dict_append_basic(iter, "Netmask",
+ DBUS_TYPE_STRING, &mask);
+ }
+
+ gateway = __vpn_ipconfig_get_gateway(provider->ipconfig_ipv4);
+ if (gateway)
+ connman_dbus_dict_append_basic(iter, "Gateway",
+ DBUS_TYPE_STRING, &gateway);
+
+ peer = __vpn_ipconfig_get_peer(provider->ipconfig_ipv4);
+ if (peer)
+ connman_dbus_dict_append_basic(iter, "Peer",
+ DBUS_TYPE_STRING, &peer);
+}
+
+static void append_ipv6(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+ const char *address, *gateway, *peer;
+
+ address = __vpn_ipconfig_get_local(provider->ipconfig_ipv6);
+ if (address) {
+ unsigned char prefixlen;
+
+ connman_dbus_dict_append_basic(iter, "Address",
+ DBUS_TYPE_STRING, &address);
+
+ prefixlen = __vpn_ipconfig_get_prefixlen(
+ provider->ipconfig_ipv6);
+
+ connman_dbus_dict_append_basic(iter, "PrefixLength",
+ DBUS_TYPE_BYTE, &prefixlen);
+ }
+
+ gateway = __vpn_ipconfig_get_gateway(provider->ipconfig_ipv6);
+ if (gateway)
+ connman_dbus_dict_append_basic(iter, "Gateway",
+ DBUS_TYPE_STRING, &gateway);
+
+ peer = __vpn_ipconfig_get_peer(provider->ipconfig_ipv6);
+ if (peer)
+ connman_dbus_dict_append_basic(iter, "Peer",
+ DBUS_TYPE_STRING, &peer);
+}
+
+static const char *state2string(enum vpn_provider_state state)
+{
+ switch (state) {
+ case VPN_PROVIDER_STATE_UNKNOWN:
+ break;
+ case VPN_PROVIDER_STATE_IDLE:
+ return "idle";
+ case VPN_PROVIDER_STATE_CONNECT:
+ return "configuration";
+ case VPN_PROVIDER_STATE_READY:
+ return "ready";
+ case VPN_PROVIDER_STATE_DISCONNECT:
+ return "disconnect";
+ case VPN_PROVIDER_STATE_FAILURE:
+ return "failure";
+ }
+
+ return NULL;
+}
+
+static void append_nameservers(DBusMessageIter *iter, char **servers)
+{
+ int i;
+
+ DBG("%p", servers);
+
+ for (i = 0; servers[i]; i++) {
+ DBG("servers[%d] %s", i, servers[i]);
+ dbus_message_iter_append_basic(iter,
+ DBUS_TYPE_STRING, &servers[i]);
+ }
+}
+
+static void append_dns(DBusMessageIter *iter, void *user_data)
+{
+ struct vpn_provider *provider = user_data;
+
+ if (provider->nameservers)
+ append_nameservers(iter, provider->nameservers);
+}
+
+static int provider_indicate_state(struct vpn_provider *provider,
+ enum vpn_provider_state state)
+{
+ const char *str;
+ enum vpn_provider_state old_state;
+
+ str = state2string(state);
+ DBG("provider %p state %s/%d", provider, str, state);
+ if (!str)
+ return -EINVAL;
+
+ old_state = provider->state;
+ provider->state = state;
+
+ if (state == VPN_PROVIDER_STATE_READY) {
+ connman_dbus_property_changed_basic(provider->path,
+ VPN_CONNECTION_INTERFACE, "Index",
+ DBUS_TYPE_INT32, &provider->index);
+
+ if (provider->family == AF_INET)
+ connman_dbus_property_changed_dict(provider->path,
+ VPN_CONNECTION_INTERFACE, "IPv4",
+ append_ipv4, provider);
+ else if (provider->family == AF_INET6)
+ connman_dbus_property_changed_dict(provider->path,
+ VPN_CONNECTION_INTERFACE, "IPv6",
+ append_ipv6, provider);
+
+ connman_dbus_property_changed_array(provider->path,
+ VPN_CONNECTION_INTERFACE,
+ "Nameservers",
+ DBUS_TYPE_STRING,
+ append_dns, provider);
+
+ if (provider->domain)
+ connman_dbus_property_changed_basic(provider->path,
+ VPN_CONNECTION_INTERFACE,
+ "Domain",
+ DBUS_TYPE_STRING,
+ &provider->domain);
+ }
+
+ if (old_state != state)
+ connman_dbus_property_changed_basic(provider->path,
+ VPN_CONNECTION_INTERFACE, "State",
+ DBUS_TYPE_STRING, &str);
+
+ return 0;
+}
+
+static void append_state(DBusMessageIter *iter,
+ struct vpn_provider *provider)
+{
+ char *str;
+
+ switch (provider->state) {
+ case VPN_PROVIDER_STATE_UNKNOWN:
+ case VPN_PROVIDER_STATE_IDLE:
+ str = "idle";
+ break;
+ case VPN_PROVIDER_STATE_CONNECT:
+ str = "configuration";
+ break;
+ case VPN_PROVIDER_STATE_READY:
+ str = "ready";
+ break;
+ case VPN_PROVIDER_STATE_DISCONNECT:
+ str = "disconnect";
+ break;
+ case VPN_PROVIDER_STATE_FAILURE:
+ str = "failure";
+ break;
+ }
+
+ connman_dbus_dict_append_basic(iter, "State",
+ DBUS_TYPE_STRING, &str);
+}
+
+static void append_properties(DBusMessageIter *iter,
+ struct vpn_provider *provider)
+{
+ DBusMessageIter dict;
+ GHashTableIter hash;
+ gpointer value, key;
+ dbus_bool_t immutable;
+
+ connman_dbus_dict_open(iter, &dict);
+
+ append_state(&dict, provider);
+
+ if (provider->type)
+ connman_dbus_dict_append_basic(&dict, "Type",
+ DBUS_TYPE_STRING, &provider->type);
+
+ if (provider->name)
+ connman_dbus_dict_append_basic(&dict, "Name",
+ DBUS_TYPE_STRING, &provider->name);
+
+ if (provider->host)
+ connman_dbus_dict_append_basic(&dict, "Host",
+ DBUS_TYPE_STRING, &provider->host);
+ if (provider->index >= 0)
+ connman_dbus_dict_append_basic(&dict, "Index",
+ DBUS_TYPE_INT32, &provider->index);
+ if (provider->domain)
+ connman_dbus_dict_append_basic(&dict, "Domain",
+ DBUS_TYPE_STRING, &provider->domain);
+
+ immutable = provider->immutable;
+ connman_dbus_dict_append_basic(&dict, "Immutable", DBUS_TYPE_BOOLEAN,
+ &immutable);
+
+ if (provider->family == AF_INET)
+ connman_dbus_dict_append_dict(&dict, "IPv4", append_ipv4,
+ provider);
+ else if (provider->family == AF_INET6)
+ connman_dbus_dict_append_dict(&dict, "IPv6", append_ipv6,
+ provider);
+
+ connman_dbus_dict_append_array(&dict, "Nameservers",
+ DBUS_TYPE_STRING, append_dns, provider);
+
+ connman_dbus_dict_append_array(&dict, "UserRoutes",
+ DBUS_TYPE_DICT_ENTRY, append_routes,
+ provider->user_routes);
+
+ connman_dbus_dict_append_array(&dict, "ServerRoutes",
+ DBUS_TYPE_DICT_ENTRY, append_routes,
+ provider->routes);
+
+ if (provider->setting_strings) {
+ g_hash_table_iter_init(&hash, provider->setting_strings);
+
+ while (g_hash_table_iter_next(&hash, &key, &value)) {
+ struct vpn_setting *setting = value;
+
+ if (!setting->hide_value &&
+ setting->value)
+ connman_dbus_dict_append_basic(&dict, key,
+ DBUS_TYPE_STRING,
+ &setting->value);
+ }
+ }
+
+ connman_dbus_dict_close(iter, &dict);
+}
+
+static void connection_added_signal(struct vpn_provider *provider)
+{
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ signal = dbus_message_new_signal(VPN_MANAGER_PATH,
+ VPN_MANAGER_INTERFACE, "ConnectionAdded");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_OBJECT_PATH,
+ &provider->path);
+ append_properties(&iter, provider);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+}
+
+static bool check_host(char **hosts, char *host)
+{
+ int i;
+
+ if (!hosts)
+ return false;
+
+ for (i = 0; hosts[i]; i++) {
+ if (g_strcmp0(hosts[i], host) == 0)
+ return true;
+ }
+
+ return false;
+}
+
+static void provider_append_routes(gpointer key, gpointer value,
+ gpointer user_data)
+{
+ struct vpn_route *route = value;
+ struct vpn_provider *provider = user_data;
+ int index = provider->index;
+
+ if (!handle_routes)
+ return;
+
+ /*
+ * If the VPN administrator/user has given a route to
+ * VPN server, then we must discard that because the
+ * server cannot be contacted via VPN tunnel.
+ */
+ if (check_host(provider->host_ip, route->network)) {
+ DBG("Discarding VPN route to %s via %s at index %d",
+ route->network, route->gateway, index);
+ return;
+ }
+
+ if (route->family == AF_INET6) {
+ unsigned char prefix_len = atoi(route->netmask);
+
+ connman_inet_add_ipv6_network_route(index, route->network,
+ route->gateway,
+ prefix_len);
+ } else {
+ connman_inet_add_network_route(index, route->network,
+ route->gateway,
+ route->netmask);
+ }
+}
+
+static int set_connected(struct vpn_provider *provider,
+ bool connected)
+{
+ struct vpn_ipconfig *ipconfig;
+
+ DBG("provider %p id %s connected %d", provider,
+ provider->identifier, connected);
+
+ if (connected) {
+ if (provider->family == AF_INET6)
+ ipconfig = provider->ipconfig_ipv6;
+ else
+ ipconfig = provider->ipconfig_ipv4;
+
+ __vpn_ipconfig_address_add(ipconfig, provider->family);
+
+ if (handle_routes)
+ __vpn_ipconfig_gateway_add(ipconfig, provider->family);
+
+ provider_indicate_state(provider,
+ VPN_PROVIDER_STATE_READY);
+
+ g_hash_table_foreach(provider->routes, provider_append_routes,
+ provider);
+
+ g_hash_table_foreach(provider->user_routes,
+ provider_append_routes, provider);
+
+ } else {
+ provider_indicate_state(provider,
+ VPN_PROVIDER_STATE_DISCONNECT);
+
+ provider_indicate_state(provider,
+ VPN_PROVIDER_STATE_IDLE);
+ }
+
+ return 0;
+}
+
+int vpn_provider_set_state(struct vpn_provider *provider,
+ enum vpn_provider_state state)
+{
+ if (!provider)
+ return -EINVAL;
+
+ switch (state) {
+ case VPN_PROVIDER_STATE_UNKNOWN:
+ return -EINVAL;
+ case VPN_PROVIDER_STATE_IDLE:
+ return set_connected(provider, false);
+ case VPN_PROVIDER_STATE_CONNECT:
+ return provider_indicate_state(provider, state);
+ case VPN_PROVIDER_STATE_READY:
+ return set_connected(provider, true);
+ case VPN_PROVIDER_STATE_DISCONNECT:
+ return provider_indicate_state(provider, state);
+ case VPN_PROVIDER_STATE_FAILURE:
+ return provider_indicate_state(provider, state);
+ }
+ return -EINVAL;
+}
+
+int vpn_provider_indicate_error(struct vpn_provider *provider,
+ enum vpn_provider_error error)
+{
+ DBG("provider %p id %s error %d", provider, provider->identifier,
+ error);
+
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_FAILURE);
+
+ switch (error) {
+ case VPN_PROVIDER_ERROR_UNKNOWN:
+ case VPN_PROVIDER_ERROR_CONNECT_FAILED:
+ break;
+
+ case VPN_PROVIDER_ERROR_LOGIN_FAILED:
+ case VPN_PROVIDER_ERROR_AUTH_FAILED:
+ vpn_provider_set_state(provider, VPN_PROVIDER_STATE_IDLE);
+ break;
+ }
+
+ return 0;
+}
+
+static int connection_unregister(struct vpn_provider *provider)
+{
+ DBG("provider %p path %s", provider, provider->path);
+
+ if (!provider->path)
+ return -EALREADY;
+
+ g_dbus_unregister_interface(connection, provider->path,
+ VPN_CONNECTION_INTERFACE);
+
+ g_free(provider->path);
+ provider->path = NULL;
+
+ return 0;
+}
+
+static int connection_register(struct vpn_provider *provider)
+{
+ DBG("provider %p path %s", provider, provider->path);
+
+ if (provider->path)
+ return -EALREADY;
+
+ provider->path = g_strdup_printf("%s/connection/%s", VPN_PATH,
+ provider->identifier);
+
+ g_dbus_register_interface(connection, provider->path,
+ VPN_CONNECTION_INTERFACE,
+ connection_methods, connection_signals,
+ NULL, provider, NULL);
+
+ return 0;
+}
+
+static void unregister_provider(gpointer data)
+{
+ struct vpn_provider *provider = data;
+
+ configuration_count_del();
+
+ connection_unregister(provider);
+
+ vpn_provider_unref(provider);
+}
+
+static void provider_initialize(struct vpn_provider *provider)
+{
+ DBG("provider %p", provider);
+
+ provider->index = 0;
+ provider->fd = -1;
+ provider->name = NULL;
+ provider->type = NULL;
+ provider->domain = NULL;
+ provider->identifier = NULL;
+ provider->immutable = false;
+ provider->user_networks = NULL;
+ provider->routes = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_route);
+ provider->user_routes = g_hash_table_new_full(g_str_hash, g_str_equal,
+ g_free, free_route);
+ provider->setting_strings = g_hash_table_new_full(g_str_hash,
+ g_str_equal, g_free, free_setting);
+}
+
+static struct vpn_provider *vpn_provider_new(void)
+{
+ struct vpn_provider *provider;
+
+ provider = g_try_new0(struct vpn_provider, 1);
+ if (!provider)
+ return NULL;
+
+ provider->refcount = 1;
+
+ DBG("provider %p", provider);
+ provider_initialize(provider);
+
+ return provider;
+}
+
+static struct vpn_provider *vpn_provider_get(const char *identifier)
+{
+ struct vpn_provider *provider;
+
+ provider = g_hash_table_lookup(provider_hash, identifier);
+ if (provider)
+ return provider;
+
+ provider = vpn_provider_new();
+ if (!provider)
+ return NULL;
+
+ DBG("provider %p", provider);
+
+ provider->identifier = g_strdup(identifier);
+
+ g_hash_table_insert(provider_hash, provider->identifier, provider);
+
+ configuration_count_add();
+
+ return provider;
+}
+
+static void provider_dbus_ident(char *ident)
+{
+ int i, len = strlen(ident);
+
+ for (i = 0; i < len; i++) {
+ if (ident[i] >= '0' && ident[i] <= '9')
+ continue;
+ if (ident[i] >= 'a' && ident[i] <= 'z')
+ continue;
+ if (ident[i] >= 'A' && ident[i] <= 'Z')
+ continue;
+ ident[i] = '_';
+ }
+}
+
+static struct vpn_provider *provider_create_from_keyfile(GKeyFile *keyfile,
+ const char *ident)
+{
+ struct vpn_provider *provider;
+
+ if (!keyfile || !ident)
+ return NULL;
+
+ provider = __vpn_provider_lookup(ident);
+ if (!provider) {
+ provider = vpn_provider_get(ident);
+ if (!provider) {
+ DBG("can not create provider");
+ return NULL;
+ }
+
+ provider_load_from_keyfile(provider, keyfile);
+
+ if (!provider->name || !provider->host ||
+ !provider->domain) {
+ DBG("cannot get name, host or domain");
+ vpn_provider_unref(provider);
+ return NULL;
+ }
+
+ if (provider_register(provider) == 0)
+ connection_register(provider);
+ }
+ return provider;
+}
+
+static void provider_create_all_from_type(const char *provider_type)
+{
+ unsigned int i;
+ char **providers;
+ char *id, *type;
+ GKeyFile *keyfile;
+
+ DBG("provider type %s", provider_type);
+
+ providers = __connman_storage_get_providers();
+
+ if (!providers)
+ return;
+
+ for (i = 0; providers[i]; i += 1) {
+
+ if (strncmp(providers[i], "provider_", 9) != 0)
+ continue;
+
+ id = providers[i] + 9;
+ keyfile = __connman_storage_load_provider(id);
+
+ if (!keyfile)
+ continue;
+
+ type = __vpn_config_get_string(keyfile, id, "Type", NULL);
+
+ DBG("keyfile %p id %s type %s", keyfile, id, type);
+
+ if (strcmp(provider_type, type) != 0) {
+ g_free(type);
+ g_key_file_free(keyfile);
+ continue;
+ }
+
+ if (!provider_create_from_keyfile(keyfile, id))
+ DBG("could not create provider");
+
+ g_free(type);
+ g_key_file_free(keyfile);
+ }
+ g_strfreev(providers);
+}
+
+char *__vpn_provider_create_identifier(const char *host, const char *domain)
+{
+ char *ident;
+
+ ident = g_strdup_printf("%s_%s", host, domain);
+ if (!ident)
+ return NULL;
+
+ provider_dbus_ident(ident);
+
+ return ident;
+}
+
+int __vpn_provider_create(DBusMessage *msg)
+{
+ struct vpn_provider *provider;
+ DBusMessageIter iter, array;
+ const char *type = NULL, *name = NULL;
+ const char *host = NULL, *domain = NULL;
+ GSList *networks = NULL;
+ char *ident;
+ int err;
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ switch (dbus_message_iter_get_arg_type(&value)) {
+ case DBUS_TYPE_STRING:
+ if (g_str_equal(key, "Type"))
+ dbus_message_iter_get_basic(&value, &type);
+ else if (g_str_equal(key, "Name"))
+ dbus_message_iter_get_basic(&value, &name);
+ else if (g_str_equal(key, "Host"))
+ dbus_message_iter_get_basic(&value, &host);
+ else if (g_str_equal(key, "VPN.Domain") ||
+ g_str_equal(key, "Domain"))
+ dbus_message_iter_get_basic(&value, &domain);
+ break;
+ case DBUS_TYPE_ARRAY:
+ if (g_str_equal(key, "UserRoutes"))
+ networks = get_user_networks(&value);
+ break;
+ }
+
+ dbus_message_iter_next(&array);
+ }
+
+ if (!host || !domain)
+ return -EINVAL;
+
+ DBG("Type %s name %s networks %p", type, name, networks);
+
+ if (!type || !name)
+ return -EOPNOTSUPP;
+
+ ident = __vpn_provider_create_identifier(host, domain);
+ DBG("ident %s", ident);
+
+ provider = __vpn_provider_lookup(ident);
+ if (!provider) {
+ provider = vpn_provider_get(ident);
+ if (!provider) {
+ DBG("can not create provider");
+ g_free(ident);
+ return -EOPNOTSUPP;
+ }
+
+ provider->host = g_strdup(host);
+ provider->domain = g_strdup(domain);
+ provider->name = g_strdup(name);
+ provider->type = g_strdup(type);
+
+ if (provider_register(provider) == 0)
+ vpn_provider_load(provider);
+
+ provider_resolv_host_addr(provider);
+ }
+
+ if (networks) {
+ g_slist_free_full(provider->user_networks, free_route);
+ provider->user_networks = networks;
+ set_user_networks(provider, provider->user_networks);
+ }
+
+ dbus_message_iter_init(msg, &iter);
+ dbus_message_iter_recurse(&iter, &array);
+
+ while (dbus_message_iter_get_arg_type(&array) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value;
+ const char *key, *str;
+
+ dbus_message_iter_recurse(&array, &entry);
+ dbus_message_iter_get_basic(&entry, &key);
+
+ dbus_message_iter_next(&entry);
+ dbus_message_iter_recurse(&entry, &value);
+
+ switch (dbus_message_iter_get_arg_type(&value)) {
+ case DBUS_TYPE_STRING:
+ dbus_message_iter_get_basic(&value, &str);
+ vpn_provider_set_string(provider, key, str);
+ break;
+ }
+
+ dbus_message_iter_next(&array);
+ }
+
+ g_free(ident);
+
+ vpn_provider_save(provider);
+
+ err = provider_register(provider);
+ if (err != 0 && err != -EALREADY)
+ return err;
+
+ connection_register(provider);
+
+ DBG("provider %p index %d path %s", provider, provider->index,
+ provider->path);
+
+ g_dbus_send_reply(connection, msg,
+ DBUS_TYPE_OBJECT_PATH, &provider->path,
+ DBUS_TYPE_INVALID);
+
+ connection_added_signal(provider);
+
+ return 0;
+}
+
+static const char *get_string(GHashTable *settings, const char *key)
+{
+ DBG("settings %p key %s", settings, key);
+
+ return g_hash_table_lookup(settings, key);
+}
+
+static GSList *parse_user_networks(const char *network_str)
+{
+ GSList *networks = NULL;
+ char **elems;
+ int i = 0;
+
+ if (!network_str)
+ return NULL;
+
+ elems = g_strsplit(network_str, ",", 0);
+ if (!elems)
+ return NULL;
+
+ while (elems[i]) {
+ struct vpn_route *vpn_route;
+ char *network, *netmask, *gateway;
+ int family;
+ char **route;
+
+ route = g_strsplit(elems[i], "/", 0);
+ if (!route)
+ goto next;
+
+ network = route[0];
+ if (!network || network[0] == '\0')
+ goto next;
+
+ family = connman_inet_check_ipaddress(network);
+ if (family < 0) {
+ DBG("Cannot get address family of %s (%d/%s)", network,
+ family, gai_strerror(family));
+
+ goto next;
+ }
+
+ switch (family) {
+ case AF_INET:
+ break;
+ case AF_INET6:
+ break;
+ default:
+ DBG("Unsupported address family %d", family);
+ goto next;
+ }
+
+ netmask = route[1];
+ if (!netmask || netmask[0] == '\0')
+ goto next;
+
+ gateway = route[2];
+
+ vpn_route = g_try_new0(struct vpn_route, 1);
+ if (!vpn_route) {
+ g_strfreev(route);
+ break;
+ }
+
+ vpn_route->family = family;
+ vpn_route->network = g_strdup(network);
+ vpn_route->netmask = g_strdup(netmask);
+ vpn_route->gateway = g_strdup(gateway);
+
+ DBG("route %s/%s%s%s", network, netmask,
+ gateway ? " via " : "", gateway ? gateway : "");
+
+ networks = g_slist_prepend(networks, vpn_route);
+
+ next:
+ g_strfreev(route);
+ i++;
+ }
+
+ g_strfreev(elems);
+
+ return g_slist_reverse(networks);
+}
+
+int __vpn_provider_create_from_config(GHashTable *settings,
+ const char *config_ident,
+ const char *config_entry)
+{
+ struct vpn_provider *provider;
+ const char *type, *name, *host, *domain, *networks_str;
+ GSList *networks;
+ char *ident = NULL;
+ GHashTableIter hash;
+ gpointer value, key;
+ int err;
+
+ type = get_string(settings, "Type");
+ name = get_string(settings, "Name");
+ host = get_string(settings, "Host");
+ domain = get_string(settings, "Domain");
+ networks_str = get_string(settings, "Networks");
+ networks = parse_user_networks(networks_str);
+
+ if (!host || !domain) {
+ err = -EINVAL;
+ goto fail;
+ }
+
+ DBG("type %s name %s networks %s", type, name, networks_str);
+
+ if (!type || !name) {
+ err = -EOPNOTSUPP;
+ goto fail;
+ }
+
+ ident = __vpn_provider_create_identifier(host, domain);
+ DBG("ident %s", ident);
+
+ provider = __vpn_provider_lookup(ident);
+ if (!provider) {
+ provider = vpn_provider_get(ident);
+ if (!provider) {
+ DBG("can not create provider");
+ err = -EOPNOTSUPP;
+ goto fail;
+ }
+
+ provider->host = g_strdup(host);
+ provider->domain = g_strdup(domain);
+ provider->name = g_strdup(name);
+ provider->type = g_ascii_strdown(type, -1);
+
+ provider->config_file = g_strdup(config_ident);
+ provider->config_entry = g_strdup(config_entry);
+
+ provider_register(provider);
+
+ provider_resolv_host_addr(provider);
+ }
+
+ if (networks) {
+ g_slist_free_full(provider->user_networks, free_route);
+ provider->user_networks = networks;
+ set_user_networks(provider, provider->user_networks);
+ }
+
+ g_hash_table_iter_init(&hash, settings);
+
+ while (g_hash_table_iter_next(&hash, &key, &value))
+ __vpn_provider_set_string_immutable(provider, key, value);
+
+ provider->immutable = true;
+
+ vpn_provider_save(provider);
+
+ err = provider_register(provider);
+ if (err != 0 && err != -EALREADY)
+ goto fail;
+
+ connection_register(provider);
+
+ DBG("provider %p index %d path %s", provider, provider->index,
+ provider->path);
+
+ connection_added_signal(provider);
+
+ g_free(ident);
+
+ return 0;
+
+fail:
+ g_free(ident);
+ g_slist_free_full(networks, free_route);
+
+ return err;
+}
+
+static void append_connection_structs(DBusMessageIter *iter, void *user_data)
+{
+ DBusMessageIter entry;
+ GHashTableIter hash;
+ gpointer value, key;
+
+ g_hash_table_iter_init(&hash, provider_hash);
+
+ while (g_hash_table_iter_next(&hash, &key, &value)) {
+ struct vpn_provider *provider = value;
+
+ DBG("path %s", provider->path);
+
+ if (!provider->identifier)
+ continue;
+
+ dbus_message_iter_open_container(iter, DBUS_TYPE_STRUCT,
+ NULL, &entry);
+ dbus_message_iter_append_basic(&entry, DBUS_TYPE_OBJECT_PATH,
+ &provider->path);
+ append_properties(&entry, provider);
+ dbus_message_iter_close_container(iter, &entry);
+ }
+}
+
+DBusMessage *__vpn_provider_get_connections(DBusMessage *msg)
+{
+ DBusMessage *reply;
+
+ DBG("");
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ __connman_dbus_append_objpath_dict_array(reply,
+ append_connection_structs, NULL);
+
+ return reply;
+}
+
+const char *__vpn_provider_get_ident(struct vpn_provider *provider)
+{
+ if (!provider)
+ return NULL;
+
+ return provider->identifier;
+}
+
+static int set_string(struct vpn_provider *provider,
+ const char *key, const char *value,
+ bool hide_value, bool immutable)
+{
+ DBG("provider %p key %s immutable %s value %s", provider, key,
+ immutable ? "yes" : "no",
+ hide_value ? "<not printed>" : value);
+
+ if (g_str_equal(key, "Type")) {
+ g_free(provider->type);
+ provider->type = g_ascii_strdown(value, -1);
+ send_value(provider->path, "Type", provider->type);
+ } else if (g_str_equal(key, "Name")) {
+ g_free(provider->name);
+ provider->name = g_strdup(value);
+ send_value(provider->path, "Name", provider->name);
+ } else if (g_str_equal(key, "Host")) {
+ g_free(provider->host);
+ provider->host = g_strdup(value);
+ send_value(provider->path, "Host", provider->host);
+ } else if (g_str_equal(key, "VPN.Domain") ||
+ g_str_equal(key, "Domain")) {
+ g_free(provider->domain);
+ provider->domain = g_strdup(value);
+ send_value(provider->path, "Domain", provider->domain);
+ } else {
+ struct vpn_setting *setting;
+
+ setting = g_hash_table_lookup(provider->setting_strings, key);
+ if (setting && !immutable &&
+ setting->immutable) {
+ DBG("Trying to set immutable variable %s", key);
+ return -EPERM;
+ }
+
+ setting = g_try_new0(struct vpn_setting, 1);
+ if (!setting)
+ return -ENOMEM;
+
+ setting->value = g_strdup(value);
+ setting->hide_value = hide_value;
+
+ if (immutable)
+ setting->immutable = true;
+
+ if (!hide_value)
+ send_value(provider->path, key, setting->value);
+
+ g_hash_table_replace(provider->setting_strings,
+ g_strdup(key), setting);
+ }
+
+ return 0;
+}
+
+int vpn_provider_set_string(struct vpn_provider *provider,
+ const char *key, const char *value)
+{
+ return set_string(provider, key, value, false, false);
+}
+
+int vpn_provider_set_string_hide_value(struct vpn_provider *provider,
+ const char *key, const char *value)
+{
+ return set_string(provider, key, value, true, false);
+}
+
+int __vpn_provider_set_string_immutable(struct vpn_provider *provider,
+ const char *key, const char *value)
+{
+ return set_string(provider, key, value, false, true);
+}
+
+const char *vpn_provider_get_string(struct vpn_provider *provider,
+ const char *key)
+{
+ struct vpn_setting *setting;
+
+ DBG("provider %p key %s", provider, key);
+
+ if (g_str_equal(key, "Type"))
+ return provider->type;
+ else if (g_str_equal(key, "Name"))
+ return provider->name;
+ else if (g_str_equal(key, "Host"))
+ return provider->host;
+ else if (g_str_equal(key, "HostIP")) {
+ if (!provider->host_ip ||
+ !provider->host_ip[0])
+ return provider->host;
+ else
+ return provider->host_ip[0];
+ } else if (g_str_equal(key, "VPN.Domain") ||
+ g_str_equal(key, "Domain"))
+ return provider->domain;
+
+ setting = g_hash_table_lookup(provider->setting_strings, key);
+ if (!setting)
+ return NULL;
+
+ return setting->value;
+}
+
+bool __vpn_provider_check_routes(struct vpn_provider *provider)
+{
+ if (!provider)
+ return false;
+
+ if (provider->user_routes &&
+ g_hash_table_size(provider->user_routes) > 0)
+ return true;
+
+ if (provider->routes &&
+ g_hash_table_size(provider->routes) > 0)
+ return true;
+
+ return false;
+}
+
+void *vpn_provider_get_data(struct vpn_provider *provider)
+{
+ return provider->driver_data;
+}
+
+void vpn_provider_set_data(struct vpn_provider *provider, void *data)
+{
+ provider->driver_data = data;
+}
+
+void vpn_provider_set_index(struct vpn_provider *provider, int index)
+{
+ DBG("index %d provider %p", index, provider);
+
+ if (!provider->ipconfig_ipv4) {
+ provider->ipconfig_ipv4 = __vpn_ipconfig_create(index,
+ AF_INET);
+ if (!provider->ipconfig_ipv4) {
+ DBG("Couldnt create ipconfig for IPv4");
+ goto done;
+ }
+ }
+
+ __vpn_ipconfig_set_index(provider->ipconfig_ipv4, index);
+
+ if (!provider->ipconfig_ipv6) {
+ provider->ipconfig_ipv6 = __vpn_ipconfig_create(index,
+ AF_INET6);
+ if (!provider->ipconfig_ipv6) {
+ DBG("Couldnt create ipconfig for IPv6");
+ goto done;
+ }
+ }
+
+ __vpn_ipconfig_set_index(provider->ipconfig_ipv6, index);
+
+done:
+ provider->index = index;
+}
+
+int vpn_provider_get_index(struct vpn_provider *provider)
+{
+ return provider->index;
+}
+
+int vpn_provider_set_ipaddress(struct vpn_provider *provider,
+ struct connman_ipaddress *ipaddress)
+{
+ struct vpn_ipconfig *ipconfig = NULL;
+
+ switch (ipaddress->family) {
+ case AF_INET:
+ ipconfig = provider->ipconfig_ipv4;
+ break;
+ case AF_INET6:
+ ipconfig = provider->ipconfig_ipv6;
+ break;
+ default:
+ break;
+ }
+
+ DBG("provider %p state %d ipconfig %p family %d", provider,
+ provider->state, ipconfig, ipaddress->family);
+
+ if (!ipconfig)
+ return -EINVAL;
+
+ provider->family = ipaddress->family;
+
+ if (provider->state == VPN_PROVIDER_STATE_CONNECT ||
+ provider->state == VPN_PROVIDER_STATE_READY) {
+ struct connman_ipaddress *addr =
+ __vpn_ipconfig_get_address(ipconfig);
+
+ /*
+ * Remember the old address so that we can remove it in notify
+ * function in plugins/vpn.c if we ever restart
+ */
+ if (ipaddress->family == AF_INET6) {
+ connman_ipaddress_free(provider->prev_ipv6_addr);
+ provider->prev_ipv6_addr =
+ connman_ipaddress_copy(addr);
+ } else {
+ connman_ipaddress_free(provider->prev_ipv4_addr);
+ provider->prev_ipv4_addr =
+ connman_ipaddress_copy(addr);
+ }
+ }
+
+ if (ipaddress->local) {
+ __vpn_ipconfig_set_local(ipconfig, ipaddress->local);
+ __vpn_ipconfig_set_peer(ipconfig, ipaddress->peer);
+ __vpn_ipconfig_set_broadcast(ipconfig, ipaddress->broadcast);
+ __vpn_ipconfig_set_gateway(ipconfig, ipaddress->gateway);
+ __vpn_ipconfig_set_prefixlen(ipconfig, ipaddress->prefixlen);
+ }
+
+ return 0;
+}
+
+int vpn_provider_set_pac(struct vpn_provider *provider,
+ const char *pac)
+{
+ DBG("provider %p pac %s", provider, pac);
+
+ return 0;
+}
+
+
+int vpn_provider_set_domain(struct vpn_provider *provider,
+ const char *domain)
+{
+ DBG("provider %p domain %s", provider, domain);
+
+ g_free(provider->domain);
+ provider->domain = g_strdup(domain);
+
+ return 0;
+}
+
+int vpn_provider_set_nameservers(struct vpn_provider *provider,
+ const char *nameservers)
+{
+ DBG("provider %p nameservers %s", provider, nameservers);
+
+ g_strfreev(provider->nameservers);
+ provider->nameservers = NULL;
+
+ if (!nameservers)
+ return 0;
+
+ provider->nameservers = g_strsplit(nameservers, " ", 0);
+
+ return 0;
+}
+
+enum provider_route_type {
+ PROVIDER_ROUTE_TYPE_NONE = 0,
+ PROVIDER_ROUTE_TYPE_MASK = 1,
+ PROVIDER_ROUTE_TYPE_ADDR = 2,
+ PROVIDER_ROUTE_TYPE_GW = 3,
+};
+
+static int route_env_parse(struct vpn_provider *provider, const char *key,
+ int *family, unsigned long *idx,
+ enum provider_route_type *type)
+{
+ char *end;
+ const char *start;
+
+ DBG("name %s", provider->name);
+
+ if (!strcmp(provider->type, "openvpn")) {
+ if (g_str_has_prefix(key, "route_network_")) {
+ start = key + strlen("route_network_");
+ *type = PROVIDER_ROUTE_TYPE_ADDR;
+ } else if (g_str_has_prefix(key, "route_netmask_")) {
+ start = key + strlen("route_netmask_");
+ *type = PROVIDER_ROUTE_TYPE_MASK;
+ } else if (g_str_has_prefix(key, "route_gateway_")) {
+ start = key + strlen("route_gateway_");
+ *type = PROVIDER_ROUTE_TYPE_GW;
+ } else
+ return -EINVAL;
+
+ *family = AF_INET;
+ *idx = g_ascii_strtoull(start, &end, 10);
+
+ } else if (!strcmp(provider->type, "openconnect")) {
+ if (g_str_has_prefix(key, "CISCO_SPLIT_INC_")) {
+ *family = AF_INET;
+ start = key + strlen("CISCO_SPLIT_INC_");
+ } else if (g_str_has_prefix(key,
+ "CISCO_IPV6_SPLIT_INC_")) {
+ *family = AF_INET6;
+ start = key + strlen("CISCO_IPV6_SPLIT_INC_");
+ } else
+ return -EINVAL;
+
+ *idx = g_ascii_strtoull(start, &end, 10);
+
+ if (strncmp(end, "_ADDR", 5) == 0)
+ *type = PROVIDER_ROUTE_TYPE_ADDR;
+ else if (strncmp(end, "_MASK", 5) == 0)
+ *type = PROVIDER_ROUTE_TYPE_MASK;
+ else if (strncmp(end, "_MASKLEN", 8) == 0 &&
+ *family == AF_INET6) {
+ *type = PROVIDER_ROUTE_TYPE_MASK;
+ } else
+ return -EINVAL;
+ }
+
+ return 0;
+}
+
+int vpn_provider_append_route(struct vpn_provider *provider,
+ const char *key, const char *value)
+{
+ struct vpn_route *route;
+ int ret, family = 0;
+ unsigned long idx = 0;
+ enum provider_route_type type = PROVIDER_ROUTE_TYPE_NONE;
+
+ DBG("key %s value %s", key, value);
+
+ ret = route_env_parse(provider, key, &family, &idx, &type);
+ if (ret < 0)
+ return ret;
+
+ DBG("idx %lu family %d type %d", idx, family, type);
+
+ route = g_hash_table_lookup(provider->routes, GINT_TO_POINTER(idx));
+ if (!route) {
+ route = g_try_new0(struct vpn_route, 1);
+ if (!route) {
+ connman_error("out of memory");
+ return -ENOMEM;
+ }
+
+ route->family = family;
+
+ g_hash_table_replace(provider->routes, GINT_TO_POINTER(idx),
+ route);
+ }
+
+ switch (type) {
+ case PROVIDER_ROUTE_TYPE_NONE:
+ break;
+ case PROVIDER_ROUTE_TYPE_MASK:
+ route->netmask = g_strdup(value);
+ break;
+ case PROVIDER_ROUTE_TYPE_ADDR:
+ route->network = g_strdup(value);
+ break;
+ case PROVIDER_ROUTE_TYPE_GW:
+ route->gateway = g_strdup(value);
+ break;
+ }
+
+ if (!handle_routes) {
+ if (route->netmask && route->gateway &&
+ route->network)
+ provider_schedule_changed(provider);
+ }
+
+ return 0;
+}
+
+const char *vpn_provider_get_driver_name(struct vpn_provider *provider)
+{
+ if (!provider->driver)
+ return NULL;
+
+ return provider->driver->name;
+}
+
+const char *vpn_provider_get_save_group(struct vpn_provider *provider)
+{
+ return provider->identifier;
+}
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ return 0;
+}
+
+static void clean_provider(gpointer key, gpointer value, gpointer user_data)
+{
+ struct vpn_provider *provider = value;
+
+ if (provider->driver && provider->driver->remove)
+ provider->driver->remove(provider);
+
+ connection_unregister(provider);
+}
+
+int vpn_provider_driver_register(struct vpn_provider_driver *driver)
+{
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+ provider_create_all_from_type(driver->name);
+ return 0;
+}
+
+void vpn_provider_driver_unregister(struct vpn_provider_driver *driver)
+{
+ GHashTableIter iter;
+ gpointer value, key;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ driver_list = g_slist_remove(driver_list, driver);
+
+ g_hash_table_iter_init(&iter, provider_hash);
+ while (g_hash_table_iter_next(&iter, &key, &value)) {
+ struct vpn_provider *provider = value;
+
+ if (provider && provider->driver &&
+ provider->driver->type == driver->type &&
+ g_strcmp0(provider->driver->name,
+ driver->name) == 0) {
+ provider->driver = NULL;
+ }
+ }
+}
+
+const char *vpn_provider_get_name(struct vpn_provider *provider)
+{
+ return provider->name;
+}
+
+const char *vpn_provider_get_host(struct vpn_provider *provider)
+{
+ return provider->host;
+}
+
+const char *vpn_provider_get_path(struct vpn_provider *provider)
+{
+ return provider->path;
+}
+
+void vpn_provider_change_address(struct vpn_provider *provider)
+{
+ switch (provider->family) {
+ case AF_INET:
+ connman_inet_set_address(provider->index,
+ __vpn_ipconfig_get_address(provider->ipconfig_ipv4));
+ break;
+ case AF_INET6:
+ connman_inet_set_ipv6_address(provider->index,
+ __vpn_ipconfig_get_address(provider->ipconfig_ipv6));
+ break;
+ default:
+ break;
+ }
+}
+
+void vpn_provider_clear_address(struct vpn_provider *provider, int family)
+{
+ const char *address;
+ unsigned char len;
+
+ DBG("provider %p family %d ipv4 %p ipv6 %p", provider, family,
+ provider->prev_ipv4_addr, provider->prev_ipv6_addr);
+
+ switch (family) {
+ case AF_INET:
+ if (provider->prev_ipv4_addr) {
+ connman_ipaddress_get_ip(provider->prev_ipv4_addr,
+ &address, &len);
+
+ DBG("ipv4 %s/%d", address, len);
+
+ connman_inet_clear_address(provider->index,
+ provider->prev_ipv4_addr);
+ connman_ipaddress_free(provider->prev_ipv4_addr);
+ provider->prev_ipv4_addr = NULL;
+ }
+ break;
+ case AF_INET6:
+ if (provider->prev_ipv6_addr) {
+ connman_ipaddress_get_ip(provider->prev_ipv6_addr,
+ &address, &len);
+
+ DBG("ipv6 %s/%d", address, len);
+
+ connman_inet_clear_ipv6_address(provider->index,
+ address, len);
+
+ connman_ipaddress_free(provider->prev_ipv6_addr);
+ provider->prev_ipv6_addr = NULL;
+ }
+ break;
+ default:
+ break;
+ }
+}
+
+static int agent_probe(struct connman_agent *agent)
+{
+ DBG("agent %p", agent);
+ return 0;
+}
+
+static void agent_remove(struct connman_agent *agent)
+{
+ DBG("agent %p", agent);
+}
+
+static struct connman_agent_driver agent_driver = {
+ .name = "vpn",
+ .interface = VPN_AGENT_INTERFACE,
+ .probe = agent_probe,
+ .remove = agent_remove,
+};
+
+static void remove_unprovisioned_providers(void)
+{
+ gchar **providers;
+ GKeyFile *keyfile, *configkeyfile;
+ char *file, *section;
+ int i = 0;
+
+ providers = __connman_storage_get_providers();
+ if (!providers)
+ return;
+
+ for (; providers[i]; i++) {
+ char *group = providers[i] + sizeof("provider_") - 1;
+ file = section = NULL;
+ keyfile = configkeyfile = NULL;
+
+ keyfile = __connman_storage_load_provider(group);
+ if (!keyfile)
+ continue;
+
+ file = __vpn_config_get_string(keyfile, group,
+ "Config.file", NULL);
+ if (!file)
+ goto next;
+
+ section = __vpn_config_get_string(keyfile, group,
+ "Config.ident", NULL);
+ if (!section)
+ goto next;
+
+ configkeyfile = __connman_storage_load_provider_config(file);
+ if (!configkeyfile) {
+ /*
+ * Config file is missing, remove the provisioned
+ * service.
+ */
+ __connman_storage_remove_provider(group);
+ goto next;
+ }
+
+ if (!g_key_file_has_group(configkeyfile, section))
+ /*
+ * Config section is missing, remove the provisioned
+ * service.
+ */
+ __connman_storage_remove_provider(group);
+
+ next:
+ if (keyfile)
+ g_key_file_free(keyfile);
+
+ if (configkeyfile)
+ g_key_file_free(configkeyfile);
+
+ g_free(section);
+ g_free(file);
+ }
+
+ g_strfreev(providers);
+}
+
+int __vpn_provider_init(bool do_routes)
+{
+ int err;
+
+ DBG("");
+
+ handle_routes = do_routes;
+
+ err = connman_agent_driver_register(&agent_driver);
+ if (err < 0) {
+ connman_error("Cannot register agent driver for %s",
+ agent_driver.name);
+ return err;
+ }
+
+ connection = connman_dbus_get_connection();
+
+ remove_unprovisioned_providers();
+
+ provider_hash = g_hash_table_new_full(g_str_hash, g_str_equal,
+ NULL, unregister_provider);
+ return 0;
+}
+
+void __vpn_provider_cleanup(void)
+{
+ DBG("");
+
+ connman_agent_driver_unregister(&agent_driver);
+
+ g_hash_table_foreach(provider_hash, clean_provider, NULL);
+
+ g_hash_table_destroy(provider_hash);
+ provider_hash = NULL;
+
+ dbus_connection_unref(connection);
+}
diff --git a/vpn/vpn-provider.h b/vpn/vpn-provider.h
new file mode 100644
index 0000000..8105d7f
--- /dev/null
+++ b/vpn/vpn-provider.h
@@ -0,0 +1,144 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2007-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __VPN_PROVIDER_H
+#define __VPN_PROVIDER_H
+
+#include <stdbool.h>
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:provider
+ * @title: Provider premitives
+ * @short_description: Functions for handling providers
+ */
+
+enum vpn_provider_type {
+ VPN_PROVIDER_TYPE_UNKNOWN = 0,
+ VPN_PROVIDER_TYPE_VPN = 1,
+};
+
+enum vpn_provider_state {
+ VPN_PROVIDER_STATE_UNKNOWN = 0,
+ VPN_PROVIDER_STATE_IDLE = 1,
+ VPN_PROVIDER_STATE_CONNECT = 2,
+ VPN_PROVIDER_STATE_READY = 3,
+ VPN_PROVIDER_STATE_DISCONNECT = 4,
+ VPN_PROVIDER_STATE_FAILURE = 5,
+};
+
+enum vpn_provider_error {
+ VPN_PROVIDER_ERROR_UNKNOWN = 0,
+ VPN_PROVIDER_ERROR_CONNECT_FAILED = 1,
+ VPN_PROVIDER_ERROR_LOGIN_FAILED = 2,
+ VPN_PROVIDER_ERROR_AUTH_FAILED = 3,
+};
+
+struct vpn_provider;
+struct connman_ipaddress;
+
+#define vpn_provider_ref(provider) \
+ vpn_provider_ref_debug(provider, __FILE__, __LINE__, __func__)
+
+#define vpn_provider_unref(provider) \
+ vpn_provider_unref_debug(provider, __FILE__, __LINE__, __func__)
+
+struct vpn_provider *
+vpn_provider_ref_debug(struct vpn_provider *provider,
+ const char *file, int line, const char *caller);
+void vpn_provider_unref_debug(struct vpn_provider *provider,
+ const char *file, int line, const char *caller);
+
+int vpn_provider_set_string(struct vpn_provider *provider,
+ const char *key, const char *value);
+int vpn_provider_set_string_hide_value(struct vpn_provider *provider,
+ const char *key, const char *value);
+const char *vpn_provider_get_string(struct vpn_provider *provider,
+ const char *key);
+
+int vpn_provider_set_state(struct vpn_provider *provider,
+ enum vpn_provider_state state);
+
+int vpn_provider_indicate_error(struct vpn_provider *provider,
+ enum vpn_provider_error error);
+
+void vpn_provider_set_index(struct vpn_provider *provider, int index);
+int vpn_provider_get_index(struct vpn_provider *provider);
+
+void vpn_provider_set_data(struct vpn_provider *provider, void *data);
+void *vpn_provider_get_data(struct vpn_provider *provider);
+int vpn_provider_set_ipaddress(struct vpn_provider *provider,
+ struct connman_ipaddress *ipaddress);
+int vpn_provider_set_pac(struct vpn_provider *provider,
+ const char *pac);
+int vpn_provider_set_domain(struct vpn_provider *provider,
+ const char *domain);
+int vpn_provider_set_nameservers(struct vpn_provider *provider,
+ const char *nameservers);
+int vpn_provider_append_route(struct vpn_provider *provider,
+ const char *key, const char *value);
+
+const char *vpn_provider_get_driver_name(struct vpn_provider *provider);
+const char *vpn_provider_get_save_group(struct vpn_provider *provider);
+
+const char *vpn_provider_get_name(struct vpn_provider *provider);
+const char *vpn_provider_get_host(struct vpn_provider *provider);
+const char *vpn_provider_get_path(struct vpn_provider *provider);
+void vpn_provider_change_address(struct vpn_provider *provider);
+void vpn_provider_clear_address(struct vpn_provider *provider, int family);
+
+typedef void (* vpn_provider_connect_cb_t) (struct vpn_provider *provider,
+ void *user_data, int error);
+
+typedef void (* vpn_provider_auth_cb_t) (struct vpn_provider *provider,
+ const char *authenticator,
+ const char *error, void *user_data);
+
+typedef void (* vpn_provider_password_cb_t) (struct vpn_provider *provider,
+ const char *username,
+ const char *password,
+ const char *error, void *user_data);
+
+struct vpn_provider_driver {
+ const char *name;
+ enum vpn_provider_type type;
+ int (*probe) (struct vpn_provider *provider);
+ int (*remove) (struct vpn_provider *provider);
+ int (*connect) (struct vpn_provider *provider,
+ vpn_provider_connect_cb_t cb, const char *dbus_sender,
+ void *user_data);
+ int (*disconnect) (struct vpn_provider *provider);
+ int (*save) (struct vpn_provider *provider, GKeyFile *keyfile);
+};
+
+int vpn_provider_driver_register(struct vpn_provider_driver *driver);
+void vpn_provider_driver_unregister(struct vpn_provider_driver *driver);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __VPN_PROVIDER_H */
diff --git a/vpn/vpn-rtnl.c b/vpn/vpn-rtnl.c
new file mode 100644
index 0000000..a7565db
--- /dev/null
+++ b/vpn/vpn-rtnl.c
@@ -0,0 +1,1181 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/ioctl.h>
+#include <arpa/inet.h>
+#include <netinet/ether.h>
+#include <netinet/icmp6.h>
+#include <net/if_arp.h>
+#include <linux/if.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+#include <linux/wireless.h>
+
+#include <glib.h>
+
+#include <connman/log.h>
+
+#include "vpn.h"
+
+#include "vpn-rtnl.h"
+
+#ifndef ARPHDR_PHONET_PIPE
+#define ARPHDR_PHONET_PIPE (821)
+#endif
+
+#define print(arg...) do { if (0) connman_info(arg); } while (0)
+#define debug(arg...) do { if (0) DBG(arg); } while (0)
+
+struct watch_data {
+ unsigned int id;
+ int index;
+ vpn_rtnl_link_cb_t newlink;
+ void *user_data;
+};
+
+static GSList *watch_list = NULL;
+static unsigned int watch_id = 0;
+
+static GSList *update_list = NULL;
+static guint update_interval = G_MAXUINT;
+static guint update_timeout = 0;
+
+struct interface_data {
+ int index;
+ char *ident;
+};
+
+static GHashTable *interface_list = NULL;
+
+static void free_interface(gpointer data)
+{
+ struct interface_data *interface = data;
+
+ g_free(interface->ident);
+ g_free(interface);
+}
+
+/**
+ * vpn_rtnl_add_newlink_watch:
+ * @index: network device index
+ * @callback: callback function
+ * @user_data: callback data;
+ *
+ * Add a new RTNL watch for newlink events
+ *
+ * Returns: %0 on failure and a unique id on success
+ */
+unsigned int vpn_rtnl_add_newlink_watch(int index,
+ vpn_rtnl_link_cb_t callback, void *user_data)
+{
+ struct watch_data *watch;
+
+ watch = g_try_new0(struct watch_data, 1);
+ if (!watch)
+ return 0;
+
+ watch->id = ++watch_id;
+ watch->index = index;
+
+ watch->newlink = callback;
+ watch->user_data = user_data;
+
+ watch_list = g_slist_prepend(watch_list, watch);
+
+ DBG("id %d", watch->id);
+
+ if (callback) {
+ unsigned int flags = __vpn_ipconfig_get_flags_from_index(index);
+
+ if (flags > 0)
+ callback(flags, 0, user_data);
+ }
+
+ return watch->id;
+}
+
+/**
+ * vpn_rtnl_remove_watch:
+ * @id: watch identifier
+ *
+ * Remove the RTNL watch for the identifier
+ */
+void vpn_rtnl_remove_watch(unsigned int id)
+{
+ GSList *list;
+
+ DBG("id %d", id);
+
+ if (id == 0)
+ return;
+
+ for (list = watch_list; list; list = list->next) {
+ struct watch_data *watch = list->data;
+
+ if (watch->id == id) {
+ watch_list = g_slist_remove(watch_list, watch);
+ g_free(watch);
+ break;
+ }
+ }
+}
+
+static void trigger_rtnl(int index, void *user_data)
+{
+ struct vpn_rtnl *rtnl = user_data;
+
+ if (rtnl->newlink) {
+ unsigned short type = __vpn_ipconfig_get_type_from_index(index);
+ unsigned int flags = __vpn_ipconfig_get_flags_from_index(index);
+
+ rtnl->newlink(type, index, flags, 0);
+ }
+}
+
+static GSList *rtnl_list = NULL;
+
+static gint compare_priority(gconstpointer a, gconstpointer b)
+{
+ const struct vpn_rtnl *rtnl1 = a;
+ const struct vpn_rtnl *rtnl2 = b;
+
+ return rtnl2->priority - rtnl1->priority;
+}
+
+/**
+ * vpn_rtnl_register:
+ * @rtnl: RTNL module
+ *
+ * Register a new RTNL module
+ *
+ * Returns: %0 on success
+ */
+int vpn_rtnl_register(struct vpn_rtnl *rtnl)
+{
+ DBG("rtnl %p name %s", rtnl, rtnl->name);
+
+ rtnl_list = g_slist_insert_sorted(rtnl_list, rtnl,
+ compare_priority);
+
+ __vpn_ipconfig_foreach(trigger_rtnl, rtnl);
+
+ return 0;
+}
+
+/**
+ * vpn_rtnl_unregister:
+ * @rtnl: RTNL module
+ *
+ * Remove a previously registered RTNL module
+ */
+void vpn_rtnl_unregister(struct vpn_rtnl *rtnl)
+{
+ DBG("rtnl %p name %s", rtnl, rtnl->name);
+
+ rtnl_list = g_slist_remove(rtnl_list, rtnl);
+}
+
+static const char *operstate2str(unsigned char operstate)
+{
+ switch (operstate) {
+ case IF_OPER_UNKNOWN:
+ return "UNKNOWN";
+ case IF_OPER_NOTPRESENT:
+ return "NOT-PRESENT";
+ case IF_OPER_DOWN:
+ return "DOWN";
+ case IF_OPER_LOWERLAYERDOWN:
+ return "LOWER-LAYER-DOWN";
+ case IF_OPER_TESTING:
+ return "TESTING";
+ case IF_OPER_DORMANT:
+ return "DORMANT";
+ case IF_OPER_UP:
+ return "UP";
+ }
+
+ return "";
+}
+
+static void extract_link(struct ifinfomsg *msg, int bytes,
+ struct ether_addr *address, const char **ifname,
+ unsigned int *mtu, unsigned char *operstate,
+ struct rtnl_link_stats *stats)
+{
+ struct rtattr *attr;
+
+ for (attr = IFLA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFLA_ADDRESS:
+ if (address)
+ memcpy(address, RTA_DATA(attr), ETH_ALEN);
+ break;
+ case IFLA_IFNAME:
+ if (ifname)
+ *ifname = RTA_DATA(attr);
+ break;
+ case IFLA_MTU:
+ if (mtu)
+ *mtu = *((unsigned int *) RTA_DATA(attr));
+ break;
+ case IFLA_STATS:
+ if (stats)
+ memcpy(stats, RTA_DATA(attr),
+ sizeof(struct rtnl_link_stats));
+ break;
+ case IFLA_OPERSTATE:
+ if (operstate)
+ *operstate = *((unsigned char *) RTA_DATA(attr));
+ break;
+ case IFLA_LINKMODE:
+ break;
+ }
+ }
+}
+
+static void process_newlink(unsigned short type, int index, unsigned flags,
+ unsigned change, struct ifinfomsg *msg, int bytes)
+{
+ struct ether_addr address = {{ 0, 0, 0, 0, 0, 0 }};
+ struct ether_addr compare = {{ 0, 0, 0, 0, 0, 0 }};
+ struct rtnl_link_stats stats;
+ unsigned char operstate = 0xff;
+ struct interface_data *interface;
+ const char *ifname = NULL;
+ unsigned int mtu = 0;
+ char ident[13], str[18];
+ GSList *list;
+
+ memset(&stats, 0, sizeof(stats));
+ extract_link(msg, bytes, &address, &ifname, &mtu, &operstate, &stats);
+
+ snprintf(ident, 13, "%02x%02x%02x%02x%02x%02x",
+ address.ether_addr_octet[0],
+ address.ether_addr_octet[1],
+ address.ether_addr_octet[2],
+ address.ether_addr_octet[3],
+ address.ether_addr_octet[4],
+ address.ether_addr_octet[5]);
+
+ snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
+ address.ether_addr_octet[0],
+ address.ether_addr_octet[1],
+ address.ether_addr_octet[2],
+ address.ether_addr_octet[3],
+ address.ether_addr_octet[4],
+ address.ether_addr_octet[5]);
+
+ switch (type) {
+ case ARPHRD_ETHER:
+ case ARPHRD_LOOPBACK:
+ case ARPHDR_PHONET_PIPE:
+ case ARPHRD_NONE:
+ __vpn_ipconfig_newlink(index, type, flags,
+ str, mtu, &stats);
+ break;
+ }
+
+ if (memcmp(&address, &compare, ETH_ALEN) != 0)
+ connman_info("%s {newlink} index %d address %s mtu %u",
+ ifname, index, str, mtu);
+
+ if (operstate != 0xff)
+ connman_info("%s {newlink} index %d operstate %u <%s>",
+ ifname, index, operstate,
+ operstate2str(operstate));
+
+ interface = g_hash_table_lookup(interface_list, GINT_TO_POINTER(index));
+ if (!interface) {
+ interface = g_new0(struct interface_data, 1);
+ interface->index = index;
+ interface->ident = g_strdup(ident);
+
+ g_hash_table_insert(interface_list,
+ GINT_TO_POINTER(index), interface);
+ }
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct vpn_rtnl *rtnl = list->data;
+
+ if (rtnl->newlink)
+ rtnl->newlink(type, index, flags, change);
+ }
+
+ for (list = watch_list; list; list = list->next) {
+ struct watch_data *watch = list->data;
+
+ if (watch->index != index)
+ continue;
+
+ if (watch->newlink)
+ watch->newlink(flags, change, watch->user_data);
+ }
+}
+
+static void process_dellink(unsigned short type, int index, unsigned flags,
+ unsigned change, struct ifinfomsg *msg, int bytes)
+{
+ struct rtnl_link_stats stats;
+ unsigned char operstate = 0xff;
+ const char *ifname = NULL;
+ GSList *list;
+
+ memset(&stats, 0, sizeof(stats));
+ extract_link(msg, bytes, NULL, &ifname, NULL, &operstate, &stats);
+
+ if (operstate != 0xff)
+ connman_info("%s {dellink} index %d operstate %u <%s>",
+ ifname, index, operstate,
+ operstate2str(operstate));
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct vpn_rtnl *rtnl = list->data;
+
+ if (rtnl->dellink)
+ rtnl->dellink(type, index, flags, change);
+ }
+
+ switch (type) {
+ case ARPHRD_ETHER:
+ case ARPHRD_LOOPBACK:
+ case ARPHRD_NONE:
+ __vpn_ipconfig_dellink(index, &stats);
+ break;
+ }
+
+ g_hash_table_remove(interface_list, GINT_TO_POINTER(index));
+}
+
+static void extract_ipv4_route(struct rtmsg *msg, int bytes, int *index,
+ struct in_addr *dst,
+ struct in_addr *gateway)
+{
+ struct rtattr *attr;
+
+ for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ if (dst)
+ *dst = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case RTA_GATEWAY:
+ if (gateway)
+ *gateway = *((struct in_addr *) RTA_DATA(attr));
+ break;
+ case RTA_OIF:
+ if (index)
+ *index = *((int *) RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+static void extract_ipv6_route(struct rtmsg *msg, int bytes, int *index,
+ struct in6_addr *dst,
+ struct in6_addr *gateway)
+{
+ struct rtattr *attr;
+
+ for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ if (dst)
+ *dst = *((struct in6_addr *) RTA_DATA(attr));
+ break;
+ case RTA_GATEWAY:
+ if (gateway)
+ *gateway =
+ *((struct in6_addr *) RTA_DATA(attr));
+ break;
+ case RTA_OIF:
+ if (index)
+ *index = *((int *) RTA_DATA(attr));
+ break;
+ }
+ }
+}
+
+static void process_newroute(unsigned char family, unsigned char scope,
+ struct rtmsg *msg, int bytes)
+{
+ GSList *list;
+ char dststr[INET6_ADDRSTRLEN], gatewaystr[INET6_ADDRSTRLEN];
+ int index = -1;
+
+ if (family == AF_INET) {
+ struct in_addr dst = { INADDR_ANY }, gateway = { INADDR_ANY };
+
+ extract_ipv4_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK && dst.s_addr == INADDR_ANY))
+ return;
+
+ if (dst.s_addr != INADDR_ANY)
+ return;
+
+ } else if (family == AF_INET6) {
+ struct in6_addr dst = IN6ADDR_ANY_INIT,
+ gateway = IN6ADDR_ANY_INIT;
+
+ extract_ipv6_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK &&
+ IN6_IS_ADDR_UNSPECIFIED(&dst)))
+ return;
+
+ if (!IN6_IS_ADDR_UNSPECIFIED(&dst))
+ return;
+ } else
+ return;
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct vpn_rtnl *rtnl = list->data;
+
+ if (rtnl->newgateway)
+ rtnl->newgateway(index, gatewaystr);
+ }
+}
+
+static void process_delroute(unsigned char family, unsigned char scope,
+ struct rtmsg *msg, int bytes)
+{
+ GSList *list;
+ char dststr[INET6_ADDRSTRLEN], gatewaystr[INET6_ADDRSTRLEN];
+ int index = -1;
+
+ if (family == AF_INET) {
+ struct in_addr dst = { INADDR_ANY }, gateway = { INADDR_ANY };
+
+ extract_ipv4_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK && dst.s_addr == INADDR_ANY))
+ return;
+
+ if (dst.s_addr != INADDR_ANY)
+ return;
+
+ } else if (family == AF_INET6) {
+ struct in6_addr dst = IN6ADDR_ANY_INIT,
+ gateway = IN6ADDR_ANY_INIT;
+
+ extract_ipv6_route(msg, bytes, &index, &dst, &gateway);
+
+ inet_ntop(family, &dst, dststr, sizeof(dststr));
+ inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
+
+ /* skip host specific routes */
+ if (scope != RT_SCOPE_UNIVERSE &&
+ !(scope == RT_SCOPE_LINK &&
+ IN6_IS_ADDR_UNSPECIFIED(&dst)))
+ return;
+
+ if (!IN6_IS_ADDR_UNSPECIFIED(&dst))
+ return;
+ } else
+ return;
+
+ for (list = rtnl_list; list; list = list->next) {
+ struct vpn_rtnl *rtnl = list->data;
+
+ if (rtnl->delgateway)
+ rtnl->delgateway(index, gatewaystr);
+ }
+}
+
+static inline void print_ether(struct rtattr *attr, const char *name)
+{
+ int len = (int) RTA_PAYLOAD(attr);
+
+ if (len == ETH_ALEN) {
+ struct ether_addr eth;
+ memcpy(ð, RTA_DATA(attr), ETH_ALEN);
+ print(" attr %s (len %d) %s\n", name, len, ether_ntoa(ð));
+ } else
+ print(" attr %s (len %d)\n", name, len);
+}
+
+static inline void print_inet(struct rtattr *attr, const char *name,
+ unsigned char family)
+{
+ int len = (int) RTA_PAYLOAD(attr);
+
+ if (family == AF_INET && len == sizeof(struct in_addr)) {
+ struct in_addr addr;
+ addr = *((struct in_addr *) RTA_DATA(attr));
+ print(" attr %s (len %d) %s\n", name, len, inet_ntoa(addr));
+ } else
+ print(" attr %s (len %d)\n", name, len);
+}
+
+static inline void print_string(struct rtattr *attr, const char *name)
+{
+ print(" attr %s (len %d) %s\n", name, (int) RTA_PAYLOAD(attr),
+ (char *) RTA_DATA(attr));
+}
+
+static inline void print_byte(struct rtattr *attr, const char *name)
+{
+ print(" attr %s (len %d) 0x%02x\n", name, (int) RTA_PAYLOAD(attr),
+ *((unsigned char *) RTA_DATA(attr)));
+}
+
+static inline void print_integer(struct rtattr *attr, const char *name)
+{
+ print(" attr %s (len %d) %d\n", name, (int) RTA_PAYLOAD(attr),
+ *((int *) RTA_DATA(attr)));
+}
+
+static inline void print_attr(struct rtattr *attr, const char *name)
+{
+ int len = (int) RTA_PAYLOAD(attr);
+
+ if (name && len > 0)
+ print(" attr %s (len %d)\n", name, len);
+ else
+ print(" attr %d (len %d)\n", attr->rta_type, len);
+}
+
+static void rtnl_link(struct nlmsghdr *hdr)
+{
+ struct ifinfomsg *msg;
+ struct rtattr *attr;
+ int bytes;
+
+ msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
+ bytes = IFLA_PAYLOAD(hdr);
+
+ print("ifi_index %d ifi_flags 0x%04x", msg->ifi_index, msg->ifi_flags);
+
+ for (attr = IFLA_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case IFLA_ADDRESS:
+ print_ether(attr, "address");
+ break;
+ case IFLA_BROADCAST:
+ print_ether(attr, "broadcast");
+ break;
+ case IFLA_IFNAME:
+ print_string(attr, "ifname");
+ break;
+ case IFLA_MTU:
+ print_integer(attr, "mtu");
+ break;
+ case IFLA_LINK:
+ print_attr(attr, "link");
+ break;
+ case IFLA_QDISC:
+ print_attr(attr, "qdisc");
+ break;
+ case IFLA_STATS:
+ print_attr(attr, "stats");
+ break;
+ case IFLA_COST:
+ print_attr(attr, "cost");
+ break;
+ case IFLA_PRIORITY:
+ print_attr(attr, "priority");
+ break;
+ case IFLA_MASTER:
+ print_attr(attr, "master");
+ break;
+ case IFLA_WIRELESS:
+ print_attr(attr, "wireless");
+ break;
+ case IFLA_PROTINFO:
+ print_attr(attr, "protinfo");
+ break;
+ case IFLA_TXQLEN:
+ print_integer(attr, "txqlen");
+ break;
+ case IFLA_MAP:
+ print_attr(attr, "map");
+ break;
+ case IFLA_WEIGHT:
+ print_attr(attr, "weight");
+ break;
+ case IFLA_OPERSTATE:
+ print_byte(attr, "operstate");
+ break;
+ case IFLA_LINKMODE:
+ print_byte(attr, "linkmode");
+ break;
+ default:
+ print_attr(attr, NULL);
+ break;
+ }
+ }
+}
+
+static void rtnl_newlink(struct nlmsghdr *hdr)
+{
+ struct ifinfomsg *msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
+
+ rtnl_link(hdr);
+
+ process_newlink(msg->ifi_type, msg->ifi_index, msg->ifi_flags,
+ msg->ifi_change, msg, IFA_PAYLOAD(hdr));
+}
+
+static void rtnl_dellink(struct nlmsghdr *hdr)
+{
+ struct ifinfomsg *msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
+
+ rtnl_link(hdr);
+
+ process_dellink(msg->ifi_type, msg->ifi_index, msg->ifi_flags,
+ msg->ifi_change, msg, IFA_PAYLOAD(hdr));
+}
+
+static void rtnl_route(struct nlmsghdr *hdr)
+{
+ struct rtmsg *msg;
+ struct rtattr *attr;
+ int bytes;
+
+ msg = (struct rtmsg *) NLMSG_DATA(hdr);
+ bytes = RTM_PAYLOAD(hdr);
+
+ print("rtm_family %d rtm_table %d rtm_protocol %d",
+ msg->rtm_family, msg->rtm_table, msg->rtm_protocol);
+ print("rtm_scope %d rtm_type %d rtm_flags 0x%04x",
+ msg->rtm_scope, msg->rtm_type, msg->rtm_flags);
+
+ for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
+ attr = RTA_NEXT(attr, bytes)) {
+ switch (attr->rta_type) {
+ case RTA_DST:
+ print_inet(attr, "dst", msg->rtm_family);
+ break;
+ case RTA_SRC:
+ print_inet(attr, "src", msg->rtm_family);
+ break;
+ case RTA_IIF:
+ print_string(attr, "iif");
+ break;
+ case RTA_OIF:
+ print_integer(attr, "oif");
+ break;
+ case RTA_GATEWAY:
+ print_inet(attr, "gateway", msg->rtm_family);
+ break;
+ case RTA_PRIORITY:
+ print_attr(attr, "priority");
+ break;
+ case RTA_PREFSRC:
+ print_inet(attr, "prefsrc", msg->rtm_family);
+ break;
+ case RTA_METRICS:
+ print_attr(attr, "metrics");
+ break;
+ case RTA_TABLE:
+ print_integer(attr, "table");
+ break;
+ default:
+ print_attr(attr, NULL);
+ break;
+ }
+ }
+}
+
+static bool is_route_rtmsg(struct rtmsg *msg)
+{
+
+ if (msg->rtm_table != RT_TABLE_MAIN)
+ return false;
+
+ if (msg->rtm_protocol != RTPROT_BOOT &&
+ msg->rtm_protocol != RTPROT_KERNEL)
+ return false;
+
+ if (msg->rtm_type != RTN_UNICAST)
+ return false;
+
+ return true;
+}
+
+static void rtnl_newroute(struct nlmsghdr *hdr)
+{
+ struct rtmsg *msg = (struct rtmsg *) NLMSG_DATA(hdr);
+
+ rtnl_route(hdr);
+
+ if (is_route_rtmsg(msg))
+ process_newroute(msg->rtm_family, msg->rtm_scope,
+ msg, RTM_PAYLOAD(hdr));
+}
+
+static void rtnl_delroute(struct nlmsghdr *hdr)
+{
+ struct rtmsg *msg = (struct rtmsg *) NLMSG_DATA(hdr);
+
+ rtnl_route(hdr);
+
+ if (is_route_rtmsg(msg))
+ process_delroute(msg->rtm_family, msg->rtm_scope,
+ msg, RTM_PAYLOAD(hdr));
+}
+
+static const char *type2string(uint16_t type)
+{
+ switch (type) {
+ case NLMSG_NOOP:
+ return "NOOP";
+ case NLMSG_ERROR:
+ return "ERROR";
+ case NLMSG_DONE:
+ return "DONE";
+ case NLMSG_OVERRUN:
+ return "OVERRUN";
+ case RTM_GETLINK:
+ return "GETLINK";
+ case RTM_NEWLINK:
+ return "NEWLINK";
+ case RTM_DELLINK:
+ return "DELLINK";
+ case RTM_NEWADDR:
+ return "NEWADDR";
+ case RTM_DELADDR:
+ return "DELADDR";
+ case RTM_GETROUTE:
+ return "GETROUTE";
+ case RTM_NEWROUTE:
+ return "NEWROUTE";
+ case RTM_DELROUTE:
+ return "DELROUTE";
+ case RTM_NEWNDUSEROPT:
+ return "NEWNDUSEROPT";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+static GIOChannel *channel = NULL;
+
+struct rtnl_request {
+ struct nlmsghdr hdr;
+ struct rtgenmsg msg;
+};
+#define RTNL_REQUEST_SIZE (sizeof(struct nlmsghdr) + sizeof(struct rtgenmsg))
+
+static GSList *request_list = NULL;
+static guint32 request_seq = 0;
+
+static struct rtnl_request *find_request(guint32 seq)
+{
+ GSList *list;
+
+ for (list = request_list; list; list = list->next) {
+ struct rtnl_request *req = list->data;
+
+ if (req->hdr.nlmsg_seq == seq)
+ return req;
+ }
+
+ return NULL;
+}
+
+static int send_request(struct rtnl_request *req)
+{
+ struct sockaddr_nl addr;
+ int sk;
+
+ debug("%s len %d type %d flags 0x%04x seq %d",
+ type2string(req->hdr.nlmsg_type),
+ req->hdr.nlmsg_len, req->hdr.nlmsg_type,
+ req->hdr.nlmsg_flags, req->hdr.nlmsg_seq);
+
+ sk = g_io_channel_unix_get_fd(channel);
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+
+ return sendto(sk, req, req->hdr.nlmsg_len, 0,
+ (struct sockaddr *) &addr, sizeof(addr));
+}
+
+static int queue_request(struct rtnl_request *req)
+{
+ request_list = g_slist_append(request_list, req);
+
+ if (g_slist_length(request_list) > 1)
+ return 0;
+
+ return send_request(req);
+}
+
+static int process_response(guint32 seq)
+{
+ struct rtnl_request *req;
+
+ debug("seq %d", seq);
+
+ req = find_request(seq);
+ if (req) {
+ request_list = g_slist_remove(request_list, req);
+ g_free(req);
+ }
+
+ req = g_slist_nth_data(request_list, 0);
+ if (!req)
+ return 0;
+
+ return send_request(req);
+}
+
+static void rtnl_message(void *buf, size_t len)
+{
+ debug("buf %p len %zd", buf, len);
+
+ while (len > 0) {
+ struct nlmsghdr *hdr = buf;
+ struct nlmsgerr *err;
+
+ if (!NLMSG_OK(hdr, len))
+ break;
+
+ debug("%s len %d type %d flags 0x%04x seq %d pid %d",
+ type2string(hdr->nlmsg_type),
+ hdr->nlmsg_len, hdr->nlmsg_type,
+ hdr->nlmsg_flags, hdr->nlmsg_seq,
+ hdr->nlmsg_pid);
+
+ switch (hdr->nlmsg_type) {
+ case NLMSG_NOOP:
+ case NLMSG_OVERRUN:
+ return;
+ case NLMSG_DONE:
+ process_response(hdr->nlmsg_seq);
+ return;
+ case NLMSG_ERROR:
+ err = NLMSG_DATA(hdr);
+ DBG("error %d (%s)", -err->error,
+ strerror(-err->error));
+ return;
+ case RTM_NEWLINK:
+ rtnl_newlink(hdr);
+ break;
+ case RTM_DELLINK:
+ rtnl_dellink(hdr);
+ break;
+ case RTM_NEWADDR:
+ break;
+ case RTM_DELADDR:
+ break;
+ case RTM_NEWROUTE:
+ rtnl_newroute(hdr);
+ break;
+ case RTM_DELROUTE:
+ rtnl_delroute(hdr);
+ break;
+ }
+
+ len -= hdr->nlmsg_len;
+ buf += hdr->nlmsg_len;
+ }
+}
+
+static gboolean netlink_event(GIOChannel *chan, GIOCondition cond, gpointer data)
+{
+ unsigned char buf[4096];
+ struct sockaddr_nl nladdr;
+ socklen_t addr_len = sizeof(nladdr);
+ ssize_t status;
+ int fd;
+
+ if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
+ return FALSE;
+
+ memset(buf, 0, sizeof(buf));
+ memset(&nladdr, 0, sizeof(nladdr));
+
+ fd = g_io_channel_unix_get_fd(chan);
+
+ status = recvfrom(fd, buf, sizeof(buf), 0,
+ (struct sockaddr *) &nladdr, &addr_len);
+ if (status < 0) {
+ if (errno == EINTR || errno == EAGAIN)
+ return TRUE;
+
+ return FALSE;
+ }
+
+ if (status == 0)
+ return FALSE;
+
+ if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
+ DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
+ return TRUE;
+ }
+
+ rtnl_message(buf, status);
+
+ return TRUE;
+}
+
+static int send_getlink(void)
+{
+ struct rtnl_request *req;
+
+ debug("");
+
+ req = g_try_malloc0(RTNL_REQUEST_SIZE);
+ if (!req)
+ return -ENOMEM;
+
+ req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
+ req->hdr.nlmsg_type = RTM_GETLINK;
+ req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req->hdr.nlmsg_pid = 0;
+ req->hdr.nlmsg_seq = request_seq++;
+ req->msg.rtgen_family = AF_INET;
+
+ return queue_request(req);
+}
+
+static int send_getaddr(void)
+{
+ struct rtnl_request *req;
+
+ debug("");
+
+ req = g_try_malloc0(RTNL_REQUEST_SIZE);
+ if (!req)
+ return -ENOMEM;
+
+ req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
+ req->hdr.nlmsg_type = RTM_GETADDR;
+ req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req->hdr.nlmsg_pid = 0;
+ req->hdr.nlmsg_seq = request_seq++;
+ req->msg.rtgen_family = AF_INET;
+
+ return queue_request(req);
+}
+
+static int send_getroute(void)
+{
+ struct rtnl_request *req;
+
+ debug("");
+
+ req = g_try_malloc0(RTNL_REQUEST_SIZE);
+ if (!req)
+ return -ENOMEM;
+
+ req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
+ req->hdr.nlmsg_type = RTM_GETROUTE;
+ req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
+ req->hdr.nlmsg_pid = 0;
+ req->hdr.nlmsg_seq = request_seq++;
+ req->msg.rtgen_family = AF_INET;
+
+ return queue_request(req);
+}
+
+static gboolean update_timeout_cb(gpointer user_data)
+{
+ __vpn_rtnl_request_update();
+
+ return TRUE;
+}
+
+static void update_interval_callback(guint min)
+{
+ if (update_timeout > 0)
+ g_source_remove(update_timeout);
+
+ if (min < G_MAXUINT) {
+ update_interval = min;
+ update_timeout = g_timeout_add_seconds(update_interval,
+ update_timeout_cb, NULL);
+ } else {
+ update_timeout = 0;
+ update_interval = G_MAXUINT;
+ }
+}
+
+static gint compare_interval(gconstpointer a, gconstpointer b)
+{
+ guint val_a = GPOINTER_TO_UINT(a);
+ guint val_b = GPOINTER_TO_UINT(b);
+
+ return val_a - val_b;
+}
+
+unsigned int __vpn_rtnl_update_interval_add(unsigned int interval)
+{
+ guint min;
+
+ if (interval == 0)
+ return 0;
+
+ update_list = g_slist_insert_sorted(update_list,
+ GUINT_TO_POINTER(interval), compare_interval);
+
+ min = GPOINTER_TO_UINT(g_slist_nth_data(update_list, 0));
+ if (min < update_interval) {
+ update_interval_callback(min);
+ __vpn_rtnl_request_update();
+ }
+
+ return update_interval;
+}
+
+unsigned int __vpn_rtnl_update_interval_remove(unsigned int interval)
+{
+ guint min = G_MAXUINT;
+
+ if (interval == 0)
+ return 0;
+
+ update_list = g_slist_remove(update_list, GINT_TO_POINTER(interval));
+
+ if (update_list)
+ min = GPOINTER_TO_UINT(g_slist_nth_data(update_list, 0));
+
+ if (min > update_interval)
+ update_interval_callback(min);
+
+ return min;
+}
+
+int __vpn_rtnl_request_update(void)
+{
+ return send_getlink();
+}
+
+int __vpn_rtnl_init(void)
+{
+ struct sockaddr_nl addr;
+ int sk;
+
+ DBG("");
+
+ interface_list = g_hash_table_new_full(g_direct_hash, g_direct_equal,
+ NULL, free_interface);
+
+ sk = socket(PF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
+ if (sk < 0)
+ return -1;
+
+ memset(&addr, 0, sizeof(addr));
+ addr.nl_family = AF_NETLINK;
+ addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE |
+ RTMGRP_IPV6_IFADDR | RTMGRP_IPV6_ROUTE |
+ (1<<(RTNLGRP_ND_USEROPT-1));
+
+ if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
+ close(sk);
+ return -1;
+ }
+
+ channel = g_io_channel_unix_new(sk);
+ g_io_channel_set_close_on_unref(channel, TRUE);
+
+ g_io_channel_set_encoding(channel, NULL, NULL);
+ g_io_channel_set_buffered(channel, FALSE);
+
+ g_io_add_watch(channel, G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
+ netlink_event, NULL);
+
+ return 0;
+}
+
+void __vpn_rtnl_start(void)
+{
+ DBG("");
+
+ send_getlink();
+ send_getaddr();
+ send_getroute();
+}
+
+void __vpn_rtnl_cleanup(void)
+{
+ GSList *list;
+
+ DBG("");
+
+ for (list = watch_list; list; list = list->next) {
+ struct watch_data *watch = list->data;
+
+ DBG("removing watch %d", watch->id);
+
+ g_free(watch);
+ list->data = NULL;
+ }
+
+ g_slist_free(watch_list);
+ watch_list = NULL;
+
+ g_slist_free(update_list);
+ update_list = NULL;
+
+ for (list = request_list; list; list = list->next) {
+ struct rtnl_request *req = list->data;
+
+ debug("%s len %d type %d flags 0x%04x seq %d",
+ type2string(req->hdr.nlmsg_type),
+ req->hdr.nlmsg_len, req->hdr.nlmsg_type,
+ req->hdr.nlmsg_flags, req->hdr.nlmsg_seq);
+
+ g_free(req);
+ list->data = NULL;
+ }
+
+ g_slist_free(request_list);
+ request_list = NULL;
+
+ g_io_channel_shutdown(channel, TRUE, NULL);
+ g_io_channel_unref(channel);
+
+ channel = NULL;
+
+ g_hash_table_destroy(interface_list);
+}
diff --git a/vpn/vpn-rtnl.h b/vpn/vpn-rtnl.h
new file mode 100644
index 0000000..aa640a6
--- /dev/null
+++ b/vpn/vpn-rtnl.h
@@ -0,0 +1,65 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#ifndef __VPN_RTNL_H
+#define __VPN_RTNL_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * SECTION:rtnl
+ * @title: RTNL premitives
+ * @short_description: Functions for registering RTNL modules
+ */
+
+typedef void (* vpn_rtnl_link_cb_t) (unsigned flags, unsigned change,
+ void *user_data);
+
+unsigned int vpn_rtnl_add_newlink_watch(int index,
+ vpn_rtnl_link_cb_t callback, void *user_data);
+
+void vpn_rtnl_remove_watch(unsigned int id);
+
+#define VPN_RTNL_PRIORITY_LOW -100
+#define VPN_RTNL_PRIORITY_DEFAULT 0
+#define VPN_RTNL_PRIORITY_HIGH 100
+
+struct vpn_rtnl {
+ const char *name;
+ int priority;
+ void (*newlink) (unsigned short type, int index,
+ unsigned flags, unsigned change);
+ void (*dellink) (unsigned short type, int index,
+ unsigned flags, unsigned change);
+ void (*newgateway) (int index, const char *gateway);
+ void (*delgateway) (int index, const char *gateway);
+};
+
+int vpn_rtnl_register(struct vpn_rtnl *rtnl);
+void vpn_rtnl_unregister(struct vpn_rtnl *rtnl);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __VPN_RTNL_H */
diff --git a/vpn/vpn.h b/vpn/vpn.h
new file mode 100644
index 0000000..8bf86bd
--- /dev/null
+++ b/vpn/vpn.h
@@ -0,0 +1,118 @@
+/*
+ *
+ * ConnMan VPN daemon
+ *
+ * Copyright (C) 2012-2013 Intel Corporation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ */
+
+#include <stdbool.h>
+
+#include <glib.h>
+
+#define VPN_API_SUBJECT_TO_CHANGE
+
+#include <connman/dbus.h>
+
+int __vpn_manager_init(void);
+void __vpn_manager_cleanup(void);
+
+struct vpn_ipconfig;
+
+struct connman_ipaddress *__vpn_ipconfig_get_address(struct vpn_ipconfig *ipconfig);
+unsigned short __vpn_ipconfig_get_type_from_index(int index);
+unsigned int __vpn_ipconfig_get_flags_from_index(int index);
+void __vpn_ipconfig_foreach(void (*function) (int index,
+ void *user_data), void *user_data);
+void __vpn_ipconfig_set_local(struct vpn_ipconfig *ipconfig,
+ const char *address);
+const char *__vpn_ipconfig_get_local(struct vpn_ipconfig *ipconfig);
+void __vpn_ipconfig_set_peer(struct vpn_ipconfig *ipconfig,
+ const char *address);
+const char *__vpn_ipconfig_get_peer(struct vpn_ipconfig *ipconfig);
+void __vpn_ipconfig_set_broadcast(struct vpn_ipconfig *ipconfig,
+ const char *broadcast);
+void __vpn_ipconfig_set_gateway(struct vpn_ipconfig *ipconfig,
+ const char *gateway);
+const char *__vpn_ipconfig_get_gateway(struct vpn_ipconfig *ipconfig);
+void __vpn_ipconfig_set_prefixlen(struct vpn_ipconfig *ipconfig,
+ unsigned char prefixlen);
+unsigned char __vpn_ipconfig_get_prefixlen(struct vpn_ipconfig *ipconfig);
+int __vpn_ipconfig_address_add(struct vpn_ipconfig *ipconfig, int family);
+int __vpn_ipconfig_gateway_add(struct vpn_ipconfig *ipconfig, int family);
+void __vpn_ipconfig_unref_debug(struct vpn_ipconfig *ipconfig,
+ const char *file, int line, const char *caller);
+#define __vpn_ipconfig_unref(ipconfig) \
+ __vpn_ipconfig_unref_debug(ipconfig, __FILE__, __LINE__, __func__)
+struct vpn_ipconfig *__vpn_ipconfig_create(int index, int family);
+void __vpn_ipconfig_set_index(struct vpn_ipconfig *ipconfig,
+ int index);
+struct rtnl_link_stats;
+
+void __vpn_ipconfig_newlink(int index, unsigned short type,
+ unsigned int flags, const char *address,
+ unsigned short mtu,
+ struct rtnl_link_stats *stats);
+void __vpn_ipconfig_dellink(int index, struct rtnl_link_stats *stats);
+int __vpn_ipconfig_init(void);
+void __vpn_ipconfig_cleanup(void);
+
+#include "vpn-provider.h"
+
+char *__vpn_provider_create_identifier(const char *host, const char *domain);
+bool __vpn_provider_check_routes(struct vpn_provider *provider);
+int __vpn_provider_append_user_route(struct vpn_provider *provider,
+ int family, const char *network,
+ const char *netmask, const char *gateway);
+void __vpn_provider_append_properties(struct vpn_provider *provider, DBusMessageIter *iter);
+void __vpn_provider_list(DBusMessageIter *iter, void *user_data);
+int __vpn_provider_create(DBusMessage *msg);
+int __vpn_provider_create_from_config(GHashTable *settings,
+ const char *config_ident, const char *config_entry);
+int __vpn_provider_set_string_immutable(struct vpn_provider *provider,
+ const char *key, const char *value);
+DBusMessage *__vpn_provider_get_connections(DBusMessage *msg);
+const char * __vpn_provider_get_ident(struct vpn_provider *provider);
+struct vpn_provider *__vpn_provider_lookup(const char *identifier);
+int __vpn_provider_indicate_state(struct vpn_provider *provider,
+ enum vpn_provider_state state);
+int __vpn_provider_indicate_error(struct vpn_provider *provider,
+ enum vpn_provider_error error);
+int __vpn_provider_connect(struct vpn_provider *provider, DBusMessage *msg);
+int __vpn_provider_connect_path(const char *path);
+int __vpn_provider_disconnect(struct vpn_provider *provider);
+int __vpn_provider_remove(const char *path);
+int __vpn_provider_delete(struct vpn_provider *provider);
+void __vpn_provider_cleanup(void);
+int __vpn_provider_init(bool handle_routes);
+
+#include "vpn-rtnl.h"
+
+int __vpn_rtnl_init(void);
+void __vpn_rtnl_start(void);
+void __vpn_rtnl_cleanup(void);
+
+unsigned int __vpn_rtnl_update_interval_add(unsigned int interval);
+unsigned int __vpn_rtnl_update_interval_remove(unsigned int interval);
+int __vpn_rtnl_request_update(void);
+int __vpn_rtnl_send(const void *buf, size_t len);
+
+int __vpn_config_init(void);
+void __vpn_config_cleanup(void);
+char *__vpn_config_get_string(GKeyFile *key_file,
+ const char *group_name, const char *key, GError **error);
+char **__vpn_config_get_string_list(GKeyFile *key_file,
+ const char *group_name, const char *key, gsize *length, GError **error);
diff --git a/vpn/vpn.ver b/vpn/vpn.ver
new file mode 100644
index 0000000..b887706
--- /dev/null
+++ b/vpn/vpn.ver
@@ -0,0 +1,8 @@
+{
+ global:
+ connman_*;
+ vpn_*;
+ g_dbus_*;
+ local:
+ *;
+};