--- /dev/null
+Hocheol Seo <hocheol.seo@samsung.com>
+Injun Yang <injun.yang@samsung.com>,
+Seungyoun Ju <sy39.ju@samsung.com>
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(mobileap-agent C)
+
+SET(SRCS src/mobileap_agent.c
+ src/mobileap_main.c
+ src/mobileap_wifi.c
+ src/mobileap_usb.c
+ src/mobileap_bluetooth.c
+ src/mobileap_handler.c
+ src/mobileap_common.c
+ src/mobileap_notification.c
+ src/mobileap_network.c
+)
+
+SET(APP_VENDOR "samsung")
+SET(APP_NAME mobileap-agent)
+SET(APP_DIR /usr/bin)
+SET(INCLUDE_DIR ${CMAKE_SOURCE_DIR}/include)
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "Private")
+ SET(CMAKE_BUILD_TYPE "Release")
+ ADD_DEFINITIONS("-D__PRIVATE_CODE__")
+ SET(PRIVATE_REQUIRED_PKGS "mdm kies-control-point")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "Private")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+INCLUDE_DIRECTORIES(${INCLUDE_DIR})
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED dlog dbus-glib-1 pmapi vconf notification libssl secure-storage capi-network-connection capi-network-bluetooth ${PRIVATE_REQUIRED_PKGS})
+FOREACH(flag ${pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag}")
+ENDFOREACH(flag)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS}")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2")
+
+FIND_PROGRAM(UNAME NAMES uname)
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+IF("${ARCH}" STREQUAL "arm")
+ ADD_DEFINITIONS("-DTARGET")
+ MESSAGE("add -DTARGET")
+ENDIF("${ARCH}" STREQUAL "arm")
+
+FIND_PROGRAM(DBUS_BINDING_TOOL NAMES dbus-binding-tool)
+EXEC_PROGRAM("${DBUS_BINDING_TOOL}" ARGS "--prefix=mobileap ${INCLUDE_DIR}/mobileap-dbus-interface.xml --mode=glib-server --output=${INCLUDE_DIR}/mobileap-server-stub.h")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DVENDOR=\"${APP_VENDOR}\"")
+ADD_DEFINITIONS("-DAPPNAME=\"${APP_NAME}\"")
+ADD_DEFINITIONS("-DAPP_DIR=\"${APP_DIR}\"")
+
+SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -Wl,--as-needed")
+
+ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS})
+
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/packaging/com.samsung.mobileap.service DESTINATION share/dbus-1/services)
+
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" ?>
+
+<!DOCTYPE node PUBLIC
+ "-//freedesktop//DTD D-Bus Object Introspection 1.0//EN"
+ "http://standards.freedesktop.org/dbus/1.0/introspect.dtd">
+
+<node>
+ <interface name="com.samsung.mobileap">
+
+ <!-- Method definitions -->
+
+ <method name="deinit">
+ </method>
+
+ <method name="disable">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="enable_wifi_tethering">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="s" name="ssid" direction="in"/>
+ <arg type="s" name="key" direction="in"/>
+ <arg type="i" name="visibility" direction="in"/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="disable_wifi_tethering">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="enable_bt_tethering">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="disable_bt_tethering">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="enable_usb_tethering">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="disable_usb_tethering">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="u" name="result" direction="out"/>
+ </method>
+
+ <method name="get_station_info">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="a(usss)" name="station" direction="out"/>
+ </method>
+
+ <method name="get_usb_station_info">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="a(sss)" name="usb_station" direction="out"/>
+ </method>
+
+ <method name="get_data_packet_usage">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="u" name="type" direction="out"/>
+ <arg type="t" name="rx_data" direction="out"/>
+ <arg type="t" name="tx_data" direction="out"/>
+ </method>
+
+ <method name="get_usb_interface_info">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="a(ssss)" name="interface" direction="out"/>
+ </method>
+
+ <method name="get_wifi_tethering_hide_mode">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="i" name="hide_mode" direction="out"/>
+ </method>
+
+ <method name="set_wifi_tethering_hide_mode">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="i" name="hide_mode" direction="in"/>
+ </method>
+
+ <method name="get_wifi_tethering_ssid">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="s" name="ssid" direction="out"/>
+ </method>
+
+ <method name="get_wifi_tethering_security_type">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="s" name="security_type" direction="out"/>
+ </method>
+
+ <method name="set_wifi_tethering_security_type">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="s" name="security_type" direction="in"/>
+ </method>
+
+ <method name="get_wifi_tethering_passphrase">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="s" name="passphrase" direction="out"/>
+ <arg type="u" name="len" direction="out"/>
+ </method>
+
+ <method name="set_wifi_tethering_passphrase">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value=""/>
+ <arg type="s" name="passphrase" direction="in"/>
+ <arg type="u" name="len" direction="in"/>
+ </method>
+
+ <!-- Signal (D-Bus) definitions -->
+ <signal name="net_closed">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="sta_connected">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="sta_disconnected">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="wifi_on">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="wifi_off">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="usb_on">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="usb_off">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="bluetooth_on">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="bluetooth_off">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="no_data_timeout">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="low_batt_mode">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="flight_mode">
+ <arg type="s" name="arg1" direction="out"/>
+ </signal>
+
+ <signal name="dhcp_status">
+ <arg type="s" name="member" direction="out"/>
+ <arg type="s" name="ip" direction="out"/>
+ <arg type="s" name="mac" direction="out"/>
+ <arg type="s" name="name" direction="out"/>
+ </signal>
+
+ </interface>
+</node>
+
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_INTERNAL_H__
+#define __MOBILEAP_INTERNAL_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Client / Agent common */
+#define DBUS_STRUCT_UINT_STRING (dbus_g_type_get_struct ("GValueArray", \
+ G_TYPE_UINT, G_TYPE_STRING, G_TYPE_INVALID))
+
+#define DBUS_STRUCT_STATIONS (dbus_g_type_get_struct ("GValueArray", \
+ G_TYPE_UINT, G_TYPE_STRING, G_TYPE_STRING, \
+ G_TYPE_STRING, G_TYPE_INVALID))
+
+#define DBUS_STRUCT_STATION (dbus_g_type_get_struct ("GValueArray", \
+ G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, \
+ G_TYPE_INVALID))
+
+#define DBUS_STRUCT_INTERFACE (dbus_g_type_get_struct ("GValueArray", \
+ G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, \
+ G_TYPE_STRING, G_TYPE_INVALID))
+
+
+#define SOFTAP_SERVICE_OBJECT_PATH "/MobileAP"
+#define SOFTAP_SERVICE_NAME "com.samsung.mobileap"
+#define SOFTAP_SERVICE_INTERFACE "com.samsung.mobileap"
+
+#define SIGNAL_NAME_NET_CLOSED "net_closed"
+#define SIGNAL_NAME_STA_CONNECT "sta_connected"
+#define SIGNAL_NAME_STA_DISCONNECT "sta_disconnected"
+#define SIGNAL_NAME_WIFI_TETHER_ON "wifi_on"
+#define SIGNAL_NAME_WIFI_TETHER_OFF "wifi_off"
+#define SIGNAL_NAME_USB_TETHER_ON "usb_on"
+#define SIGNAL_NAME_USB_TETHER_OFF "usb_off"
+#define SIGNAL_NAME_BT_TETHER_ON "bluetooth_on"
+#define SIGNAL_NAME_BT_TETHER_OFF "bluetooth_off"
+#define SIGNAL_NAME_NO_DATA_TIMEOUT "no_data_timeout"
+#define SIGNAL_NAME_LOW_BATTERY_MODE "low_batt_mode"
+#define SIGNAL_NAME_FLIGHT_MODE "flight_mode"
+#define SIGNAL_NAME_DHCP_STATUS "dhcp_status"
+
+#define SIGNAL_MSG_NOT_AVAIL_INTERFACE "Interface is not available"
+
+#define DNSMASQ_LEASES_FILE "/var/lib/misc/dnsmasq.leases"
+#define IP_USB_SUBNET "192.168.129"
+
+typedef enum {
+ E_SIGNAL_NET_CLOSED,
+ E_SIGNAL_STA_CONNECT,
+ E_SIGNAL_STA_DISCONNECT,
+ E_SIGNAL_WIFI_TETHER_ON,
+ E_SIGNAL_WIFI_TETHER_OFF,
+ E_SIGNAL_USB_TETHER_ON,
+ E_SIGNAL_USB_TETHER_OFF,
+ E_SIGNAL_BT_TETHER_ON,
+ E_SIGNAL_BT_TETHER_OFF,
+ E_SIGNAL_NO_DATA_TIMEOUT,
+ E_SIGNAL_LOW_BATTERY_MODE,
+ E_SIGNAL_FLIGHT_MODE,
+ E_SIGNAL_MAX
+} mobile_ap_sig_e;
+
+/**
+* WiFi tethering configuration
+*/
+#define MOBILE_AP_WIFI_CHANNEL 7 /**< Channel number */
+#define MOBILE_AP_WIFI_BSSID_LEN 6 /**< BSSID Length */
+#define MOBILE_AP_WIFI_SSID_MAX_LEN 31 /**< Maximum length of ssid */
+#define MOBILE_AP_WIFI_KEY_MIN_LEN 8 /**< Minimum length of wifi key */
+#define MOBILE_AP_WIFI_KEY_MAX_LEN 63 /**< Maximum length of wifi key */
+
+/**
+* Common configuration
+*/
+#define MOBILE_AP_MAX_WIFI_STA 8
+#define MOBILE_AP_MAX_BT_STA 7
+#define MOBILE_AP_MAX_USB_STA 1
+#define MOBILE_AP_MAX_CONNECTED_STA 16 /**< Maximum connected station. 8(Wi-Fi) + 7(BT) + 1(USB) */
+
+#define MOBILE_AP_STR_INFO_LEN 20 /**< length of the ip or mac address*/
+#define MOBILE_AP_STR_HOSTNAME_LEN 32 /**< length of the hostname */
+#define MOBILE_AP_NAME_UNKNOWN "UNKNOWN"
+
+/**
+* Mobile AP error code
+*/
+typedef enum {
+ MOBILE_AP_ERROR_NONE, /**< No error */
+ MOBILE_AP_ERROR_RESOURCE, /**< Socket creation error, file open error */
+ MOBILE_AP_ERROR_INTERNAL, /**< Driver related error */
+ MOBILE_AP_ERROR_INVALID_PARAM, /**< Invalid parameter */
+ MOBILE_AP_ERROR_ALREADY_ENABLED, /**< Mobile AP is already ON */
+ MOBILE_AP_ERROR_NOT_ENABLED, /**< Mobile AP is not ON, so cannot be disabled */
+ MOBILE_AP_ERROR_NET_OPEN, /**< PDP network open error */
+ MOBILE_AP_ERROR_NET_CLOSE, /**< PDP network close error */
+ MOBILE_AP_ERROR_DHCP, /**< DHCP error */
+ MOBILE_AP_ERROR_IN_PROGRESS, /**< Request is in progress */
+ MOBILE_AP_ERROR_NOT_PERMITTED, /**< Operation is not permitted */
+
+ MOBILE_AP_ERROR_MAX
+} mobile_ap_error_code_e;
+
+/**
+* Event type on callback
+*/
+typedef enum {
+ MOBILE_AP_ENABLE_CFM, /* mobile_ap_enable() */
+ MOBILE_AP_DISABLE_CFM, /* mobile_ap_disable() */
+
+ MOBILE_AP_ENABLE_WIFI_TETHERING_CFM, /* mobile_ap_enable_wifi_tethering() */
+ MOBILE_AP_DISABLE_WIFI_TETHERING_CFM, /* mobile_ap_disable_wifi_tethering() */
+ MOBILE_AP_CHANGE_WIFI_CONFIG_CFM, /* mobile_ap_change_wifi_config() */
+
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, /* mobile_ap_enable_usb_tethering() */
+ MOBILE_AP_DISABLE_USB_TETHERING_CFM, /* mobile_ap_disable_usb_tethering() */
+
+ MOBILE_AP_ENABLE_BT_TETHERING_CFM, /* mobile_ap_enable_bt_tethering() */
+ MOBILE_AP_DISABLE_BT_TETHERING_CFM, /* mobile_ap_disable_bt_tethering() */
+
+ MOBILE_AP_GET_STATION_INFO_CFM, /* mobile_ap_get_station_info() */
+ MOBILE_AP_GET_DATA_PACKET_USAGE_CFM, /* mobile_ap_get_data_packet_usage() */
+
+ MOBILE_AP_DISABLED_IND, /* Turning off tethering service indication */
+
+ MOBILE_AP_ENABLED_WIFI_TETHERING_IND, /* Turning on WiFi tethering indication */
+ MOBILE_AP_DISABLED_WIFI_TETHERING_IND, /* Turning off WiFi tethering indication */
+
+ MOBILE_AP_ENABLED_USB_TETHERING_IND, /* Turning on USB tethering indication */
+ MOBILE_AP_DISABLED_USB_TETHERING_IND, /* Turning off USB tethering indication */
+
+ MOBILE_AP_ENABLED_BT_TETHERING_IND, /* Turning on BT tethering indication */
+ MOBILE_AP_DISABLED_BT_TETHERING_IND, /* Turning off BT tethering indication */
+
+ MOBILE_AP_STATION_CONNECT_IND, /* Station connection indication */
+ MOBILE_AP_STATION_DISCONNECT_IND, /* Station disconnection indication */
+ MOBILE_AP_USB_STATION_CONNECT_IND,
+
+ MOBILE_AP_MAX_EVENT,
+} mobile_ap_event_e;
+
+typedef enum {
+ MOBILE_AP_TYPE_WIFI,
+ MOBILE_AP_TYPE_USB,
+ MOBILE_AP_TYPE_BT,
+ MOBILE_AP_TYPE_MAX,
+} mobile_ap_type_e;
+
+typedef struct {
+ unsigned long long pdp_tx_bytes; /**< packet data transmitted */
+ unsigned long long pdp_rx_bytes; /**< packet data received */
+} mobile_ap_data_packet_usage_t;
+
+typedef struct {
+ mobile_ap_type_e interface; /**< interface type */
+ char ip[MOBILE_AP_STR_INFO_LEN]; /**< assigned IP address */
+ char mac[MOBILE_AP_STR_INFO_LEN]; /**< MAC Address */
+ char hostname[MOBILE_AP_STR_HOSTNAME_LEN]; /**< alphanumeric name */
+} mobile_ap_station_info_t;
+
+typedef struct {
+ mobile_ap_type_e interface; /**< interface type */
+ char interface_name[MOBILE_AP_STR_INFO_LEN]; /**< interface alphanumeric name */
+ char ip_address[MOBILE_AP_STR_INFO_LEN]; /**< assigned ip addresss to interface */
+ char gateway_address[MOBILE_AP_STR_INFO_LEN]; /**< gateway address of interface */
+ char subnet_mask[MOBILE_AP_STR_INFO_LEN]; /**< subnet mask of interface */
+} mobile_ap_interface_info_t;
+
+typedef struct {
+ unsigned short number; /**< Number of connected device */
+ mobile_ap_station_info_t sta_info[MOBILE_AP_MAX_CONNECTED_STA];
+} mobile_ap_device_info_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MOBILEAP_INTERNAL_H__ */
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_AGENT_H__
+#define __MOBILEAP_AGENT_H__
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <dlog.h>
+#include <vconf.h>
+#include <netinet/in.h>
+
+#include "mobileap.h"
+
+#define MH_MID "mh_agent"
+#define DBG(fmt, args...) LOG(LOG_DEBUG, MH_MID, "[%s()][Ln:%d] "fmt, \
+ __func__, __LINE__, ##args)
+#define ERR(fmt, args...) LOG(LOG_ERROR, MH_MID, "[%s()][Ln:%d] "fmt, \
+ __func__, __LINE__, ##args)
+
+#define DRIVER_DELAY 250000 /* micro seconds */
+
+#define IF_BUF_LEN 32
+#define NET_BUF_LEN 12
+#define INTERFACE_NAME_LEN 12
+#define SECURITY_TYPE_LEN 32
+
+/* Network Interface */
+#define IP_SUBNET_MASK "255.255.255.0"
+
+#define WIFI_IF "wlan0"
+#define IP_ADDRESS_WIFI 0xC0A83D02 /* 192.168.61.2 */
+
+#define SOFTAP_IF "wl0.1"
+#define IP_ADDRESS_SOFTAP 0xC0A83D01 /* 192.168.61.1 */
+
+#define USB_IF "usb0"
+#define IP_ADDRESS_USB 0xC0A88103 /* 192.168.129.3 */
+
+#define BT_IF_PREFIX "bnep"
+#define BT_IF_ALL BT_IF_PREFIX"+"
+#define IP_ADDRESS_BT_1 0xC0A88201 /* 192.168.130.1 */
+#define IP_ADDRESS_BT_2 0xC0A88301 /* 192.168.131.1 */
+#define IP_ADDRESS_BT_3 0xC0A88401 /* 192.168.132.1 */
+#define IP_ADDRESS_BT_4 0xC0A88501 /* 192.168.133.1 */
+#define IP_ADDRESS_BT_5 0xC0A88601 /* 192.168.134.1 */
+#define IP_ADDRESS_BT_6 0xC0A88701 /* 192.168.135.1 */
+#define IP_ADDRESS_BT_7 0xC0A88801 /* 192.168.136.1 */
+
+#define RET_FAILURE (-1)
+#define RET_SUCCESS (0)
+#define MAX_BUF_SIZE (256u)
+
+#define DNSMASQ_CONF_LEN 1024
+#define DNSMASQ_CONF "dhcp-range=192.168.61.3,192.168.61.150,255.255.255.0\n" \
+ "dhcp-range=192.168.130.2,192.168.130.150,255.255.255.0\n" \
+ "dhcp-range=192.168.131.2,192.168.131.150,255.255.255.0\n" \
+ "dhcp-range=192.168.132.2,192.168.132.150,255.255.255.0\n" \
+ "dhcp-range=192.168.133.2,192.168.133.150,255.255.255.0\n" \
+ "dhcp-range=192.168.134.2,192.168.134.150,255.255.255.0\n" \
+ "dhcp-range=192.168.135.2,192.168.135.150,255.255.255.0\n" \
+ "dhcp-range=192.168.136.2,192.168.136.150,255.255.255.0\n" \
+ "dhcp-range=192.168.137.2,192.168.137.150,255.255.255.0\n" \
+ "dhcp-range=set:blue,192.168.129.4,192.168.129.150,255.255.255.0\n"\
+ "dhcp-option=option:dns-server,%s\n" \
+ "enable-dbus\n" \
+ "dhcp-option=tag:blue,option:router,192.168.129.3\n"
+#define DNSMASQ_CONF_FILE "/tmp/dnsmasq.conf"
+
+/* Start of hostapd configuration */
+#define MH_CTRL_INTF "/tmp/mh_wpa_ctrl"
+#define MH_MONITOR_INTF "/tmp/mh_wpa_monitor"
+
+#define HOSTAPD_BIN "/usr/sbin/hostapd"
+#define HOSTAPD_ENTROPY_FILE "/opt/var/lib/misc/hostapd.bin"
+#define HOSTAPD_CONF_FILE "/opt/var/lib/misc/hostapd.conf"
+#define HOSTAPD_CTRL_INTF_DIR "/opt/var/lib/misc/hostapd"
+#define HOSTAPD_CONF_LEN 1024
+#define HOSTAPD_CONF "interface=%s\n" \
+ "driver=nl80211\n" \
+ "ctrl_interface=%s\n" \
+ "ssid=%s\n" \
+ "channel=%d\n" \
+ "ignore_broadcast_ssid=%d\n" \
+ "max_num_sta=%d\n" \
+ "%s\n"
+#define HOSTAPD_DEBUG_FILE "/tmp/hostapd.log"
+#define HOSTAPD_REQ_MAX_LEN 128
+#define HOSTAPD_RETRY_MAX 5
+#define HOSTAPD_RETRY_DELAY 500000 /* us */
+#define HOSTAPD_STA_DISCONN "AP-STA-DISCONNECTED " /* from wpa_ctrl.h */
+#define HOSTAPD_MONITOR_ATTACH "ATTACH"
+#define HOSTAPD_MONITOR_DETACH "DETACH"
+/* End of hostapd configuration */
+
+#define WLAN_SCRIPT "/usr/bin/wlan.sh"
+
+#define IP_FORWARD "/proc/sys/net/ipv4/ip_forward"
+#define IPTABLES "/usr/sbin/iptables"
+#define GREP "/bin/grep"
+#define AWK "/usr/bin/awk"
+#define DATA_USAGE_FILE "/tmp/tethering_data_usage.txt"
+#define MASQUERADE_RULE "-o %s -j MASQUERADE"
+#define DNS_FORWARD_RULE "-p udp -i %s --dport 53 -j DNAT --to %s"
+#define FORWARD_RULE "-i %s -o %s"
+#ifndef __USE_CONNMAN_DNS_ADDR__
+#define GOOGLE_PUBLIC_DNS "8.8.8.8"
+#endif /* __USE_CONNMAN_DNS_ADDR__ */
+
+#define MOBILE_AP_STATE_NONE 0
+#define MOBILE_AP_STATE_WIFI 1
+#define MOBILE_AP_STATE_USB 2
+#define MOBILE_AP_STATE_BT 4
+#define MOBILE_AP_STATE_ALL 7
+
+#define DNSMASQ_DBUS_INTERFACE "uk.org.thekelleys.dnsmasq"
+
+#define PROC_NET_DEV "/proc/net/dev"
+#define MAX_TRANSFER_CHECK_COUNT 180 /* 30 minutes */
+#define CHECK_NET_STATE_RETRY_COUNT 5
+#define PSK_ITERATION_COUNT 4096
+
+typedef struct {
+ /* The parent class object state. */
+ GObject parent;
+
+ /* instance member */
+ DBusGMethodInvocation *bt_context;
+ DBusGMethodInvocation *usb_context;
+ guint source_id;
+ GSList *bt_device;
+
+ int init_count;
+ int hide_mode;
+ int transfer_check_count;
+ unsigned long long rx_bytes;
+ unsigned long long tx_bytes;
+
+ char ssid[MOBILE_AP_WIFI_SSID_MAX_LEN + 1];
+ char key[MOBILE_AP_WIFI_KEY_MAX_LEN + 1];
+ char security_type[SECURITY_TYPE_LEN];
+} MobileAPObject;
+
+typedef struct {
+ /* The parent class state. */
+ GObjectClass parent;
+
+ /* class member */
+ guint signals[E_SIGNAL_MAX];
+} MobileAPObjectClass;
+
+typedef struct {
+ unsigned int number; /* Number of connected device */
+ /* BSSID list of connected device */
+ char bssid[MOBILE_AP_MAX_WIFI_STA][MOBILE_AP_STR_INFO_LEN];
+} softap_device_info_t;
+
+typedef struct {
+ const char *key;
+ vconf_callback_fn cb;
+ int *value;
+} vconf_reg_t;
+
+
+typedef enum {
+ MOBILE_AP_DRV_INTERFACE_NONE,
+ MOBILE_AP_WEXT,
+ MOBILE_AP_NL80211,
+} mobile_ap_drv_interface_e;
+
+/* ssid : 32 key : 64 */
+int _mh_core_enable_softap(const char *ssid, const char *security,
+ const char *key, int hide_mode);
+int _mh_core_disable_softap(void);
+int _mh_core_get_device_info(softap_device_info_t *di);
+int _mh_core_execute_dhcp_server(void);
+int _mh_core_terminate_dhcp_server(void);
+int _mh_core_enable_masquerade(const char *ext_if);
+int _mh_core_disable_masquerade(const char *ext_if);
+void _mh_core_add_data_to_array(GPtrArray *array, guint type, gchar *dev_name);
+int _mh_core_set_ip_address(const char *if_name, const in_addr_t ip);
+
+
+gboolean _init_tethering(MobileAPObject *obj);
+gboolean _deinit_tethering(MobileAPObject *obj);
+gboolean _mobileap_clear_state(int state);
+
+
+int _mobileap_is_disabled(void);
+int _mobileap_is_enabled(int state);
+gboolean _mobileap_set_state(int state);
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_BLUETOOTH_H__
+#define __MOBILEAP_BLUETOOTH_H__
+
+#include "mobileap_agent.h"
+
+void _bt_get_remote_device_name(MobileAPObject *obj, const char *mac, char **name);
+mobile_ap_error_code_e _disable_bt_tethering(MobileAPObject *obj);
+
+gboolean mobileap_enable_bt_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+gboolean mobileap_disable_bt_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_COMMON_H__
+#define __MOBILEAP_COMMON_H__
+
+#include <glib.h>
+
+#include "mobileap_agent.h"
+
+/* Need translation */
+#define MH_NOTI_STR "Connected device (%d)"
+#define MH_NOTI_TITLE "Tethering is available"
+
+gint _slist_find_station_by_interface(gconstpointer a, gconstpointer b);
+gint _slist_find_station_by_mac(gconstpointer a, gconstpointer b);
+
+void _emit_mobileap_dbus_signal(MobileAPObject *obj,
+ mobile_ap_sig_e num, const gchar *message);
+void _send_dbus_station_info(const char *member,
+ mobile_ap_station_info_t *info);
+void _update_station_count(int count);
+int _add_station_info(mobile_ap_station_info_t *info);
+int _remove_station_info(gconstpointer data, GCompareFunc func);
+int _remove_station_info_all(mobile_ap_type_e type);
+int _get_station_info(gconstpointer data, GCompareFunc func,
+ mobile_ap_station_info_t **si);
+int _get_station_count(int *count);
+int _station_info_foreach(GFunc func, void *user_data);
+int _add_data_usage_rule(const char *src, const char *dest);
+int _del_data_usage_rule(const char *src, const char *dest);
+int _get_data_usage(const char *src, const char *dest, unsigned long long *tx, unsigned long long *rx);
+int _execute_command(const char *cmd);
+int _get_tethering_type_from_ip(const char *ip, mobile_ap_type_e *type);
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_HANDLER_H__
+#define __MOBILEAP_HANDLER_H__
+
+
+void _register_vconf_cb(void *user_data);
+void _unregister_vconf_cb(void *user_data);
+
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_NETWORK_H__
+#define __MOBILEAP_NETWORK_H__
+
+#include <glib.h>
+#include <net_connection.h>
+
+gboolean _get_network_interface_name(char **if_name);
+gboolean _set_masquerade(void);
+gboolean _unset_masquerade(void);
+gboolean _open_network(void);
+gboolean _close_network(void);
+gboolean _init_network(void *user_data);
+gboolean _deinit_network(void);
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_NOTIFICATION_H__
+#define __MOBILEAP_NOTIFICATION_H__
+
+#include <notification.h>
+
+#define MH_NOTI_STR_MAX 50
+#define MH_NOTI_ICON_PATH "/usr/apps/org.tizen.tethering/res/images/Q02_Notification_MobileAP.png"
+
+notification_h _create_notification(void);
+int _insert_notification(notification_h noti, char *title, char *content, char *icon_path);
+int _delete_notification(void);
+int _set_notification_app_launch(notification_h noti);
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_USB_H__
+#define __MOBILEAP_USB_H__
+
+#include "mobileap_agent.h"
+
+
+mobile_ap_error_code_e _disable_usb_tethering(MobileAPObject *obj);
+
+gboolean mobileap_enable_usb_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+gboolean mobileap_disable_usb_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+gboolean mobileap_get_usb_station_info(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+gboolean mobileap_get_usb_interface_info(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+#endif
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#ifndef __MOBILEAP_WIFI_H__
+#define __MOBILEAP_WIFI_H__
+
+#include "mobileap_agent.h"
+
+#define SOFTAP_SECURITY_TYPE_OPEN_STR "open"
+#define SOFTAP_SECURITY_TYPE_WPA2_PSK_STR "wpa2-psk"
+#define SOFTAP_PASSPHRASE_PATH "wifi_tethering.txt"
+
+typedef enum {
+ SOFTAP_SECURITY_TYPE_OPEN,
+ SOFTAP_SECURITY_TYPE_WPA2_PSK,
+} softap_security_type_e;
+
+void _register_wifi_station_handler(void);
+void _add_wifi_device_to_array(softap_device_info_t *di, GPtrArray *array);
+mobile_ap_error_code_e _disable_wifi_tethering(MobileAPObject *obj);
+
+/* Dbus method */
+gboolean mobileap_enable_wifi_tethering(MobileAPObject *obj, gchar *ssid,
+ gchar *key, gint hide_mode,
+ DBusGMethodInvocation *context);
+
+gboolean mobileap_disable_wifi_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+gboolean mobileap_get_wifi_tethering_hide_mode(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+gboolean mobileap_set_wifi_tethering_hide_mode(MobileAPObject *obj,
+ gint hide_mode, DBusGMethodInvocation *context);
+
+gboolean mobileap_get_wifi_tethering_ssid(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+gboolean mobileap_get_wifi_tethering_security_type(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+gboolean mobileap_set_wifi_tethering_security_type(MobileAPObject *obj,
+ gchar *security_type, DBusGMethodInvocation *context);
+
+gboolean mobileap_get_wifi_tethering_passphrase(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+
+gboolean mobileap_set_wifi_tethering_passphrase(MobileAPObject *obj,
+ gchar *passphrase, guint len, DBusGMethodInvocation *context);
+#endif /* __MOBILEAP_WIFI_H__ */
--- /dev/null
+<manifest>
+ <request>
+ <domain name="_"/>
+ </request>
+</manifest>
--- /dev/null
+[D-BUS Service]
+Name=com.samsung.mobileap
+Exec=/usr/bin/mobileap-agent
--- /dev/null
+Name: mobileap-agent
+Summary: Mobile AP daemon for setting tethering environments
+Version: 0.1.76
+Release: 1
+Group: TO_BE/FILLED_IN
+License: Apache License Version 2.0
+Source0: %{name}-%{version}.tar.gz
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(dbus-glib-1)
+BuildRequires: pkgconfig(glib-2.0)
+BuildRequires: pkgconfig(gthread-2.0)
+BuildRequires: pkgconfig(pmapi)
+BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(notification)
+BuildRequires: pkgconfig(libssl)
+BuildRequires: pkgconfig(secure-storage)
+BuildRequires: pkgconfig(capi-network-connection)
+BuildRequires: pkgconfig(capi-network-bluetooth)
+BuildRequires: cmake
+Requires(post): /usr/bin/vconftool
+Requires: iptables
+Requires: dnsmasq
+%description
+Mobile AP daemon for setting tethering environments
+
+%prep
+%setup -q
+
+%build
+export CFLAGS+=" -fpie"
+CFLAGS="${CFLAGS}" cmake . -DCMAKE_INSTALL_PREFIX="%{_prefix}"
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+
+%post
+/usr/bin/vconftool set -t int memory/mobile_hotspot/connected_device "0" -u 0 -i -f
+/usr/bin/vconftool set -t int memory/mobile_hotspot/mode "0" -u 0 -i -f
+/usr/bin/vconftool set -t int db/mobile_hotspot/security "0" -u 0 -f
+/usr/bin/vconftool set -t int db/mobile_hotspot/hide "0" -u 0 -f
+
+%files
+%manifest mobileap-agent.manifest
+%defattr(-,root,root,-)
+/usr/share/dbus-1/services/com.samsung.mobileap.service
+%{_bindir}/mobileap-agent
+
+%changelog
+* Tue Oct 30 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.76-1
+- Vconf enum is changed (SETTING_USB_MOBILE_HOTSPOT -> SETTING_USB_TETHERING_MODE)
+- Private code is separated
+
+* Mon Oct 29 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.75-1
+- Code clean-up and path for notification icon is changed
+
+* Thu Oct 22 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.74-1
+- License is added
+
+* Thu Oct 11 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.73-1
+- Source package name is changed (libmobileap -> mobileap-agent)
+
+* Thu Oct 11 2012 Injun Yang <injun.yang@samsung.com> 0.1.72-1
+- Launch kcp-agent
+
+* Fri Sep 28 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.71-1
+- Fix memory corruption
+
+* Fri Sep 21 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.70-1
+- Manifest file is added for SMACK
+
+* Wed Sep 19 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.69-1
+- The code for Legacy APIs is removed
+
+* Wed Sep 14 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.68-1
+- Bluetooth PAN Managed APIs are applied
+- MDM Phase 2 implementation
+
+* Wed Sep 06 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.67-1
+- Connection Managed APIs are applied
+- Network status is not checked in agent
+
+* Wed Aug 01 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.66-1
+- Wi-Fi tethering setting values are managed here
+- Deprecated APIs from glib-2.3.0 are replaced
+- Notification Icon is changed
+
+* Fri Jul 13 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.65-1
+- Wi-Fi tethering disable / enable issues are fixed
+
+* Fri Jul 06 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.64-1
+- Unnecessary dependency is removed
+
+* Mon Jun 25 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.63-1
+- Data usage is fixed
+
+* Thu May 31 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.62-1
+- Wi-Fi tethering security is implemented
+- API for getting USB interface information is implemented
+
+* Wed May 23 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.61-1
+- Tethering app. dependency is added
+
+* Tue May 22 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.60-1
+- Wi-Fi interface name is changed from eth0 to wlan0
+
+* Tue May 22 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.59-1
+- Below changes are applied
+- Ignore mdm failure case
+- CAPI bugs are fixed
+- Bug of _remove_station_info_all() is fixed
+- Launch tethering applicatoin from notification
+
+* Tue May 08 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.58-1
+- Hostapd control interface is implemented
+
+* Mon Apr 09 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.57-1
+- Unused vconfkey is removed
+
+* Wed Mar 14 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.56-1
+- Export API's are changed
+
+* Mon Feb 06 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.55-2
+- Fix build error
+
+* Mon Feb 06 2012 Seungyoun Ju <sy39.ju@samsung.com> 0.1.55-1
+- Test code is modified
+- Code clean-up
+- Notification is implemented
+- MDM bug fix
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <sys/stat.h>
+#include <sys/un.h>
+#include <errno.h>
+#include <sys/ioctl.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <dbus/dbus-glib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <linux/wireless.h>
+
+#include <openssl/evp.h>
+#include <openssl/sha.h>
+
+#include "mobileap_common.h"
+#include "mobileap_agent.h"
+
+static pid_t dnsmasq_pid = 0;
+static pid_t hostapd_pid = 0;
+static int hostapd_ctrl_fd = 0;
+static int hostapd_monitor_fd = 0;
+static GIOChannel *hostapd_io_channel = NULL;
+static guint hostapd_io_source = 0;
+
+static int __issue_ioctl(int sock_fd, char *if_name, char *cmd, char *buf)
+{
+ int ret_val = MOBILE_AP_ERROR_NONE;
+ struct iwreq iwr;
+
+ memset(buf, 0, MAX_BUF_SIZE);
+ memset(&iwr, 0, sizeof(iwr));
+
+ /* Configure ioctl parameters */
+ g_strlcpy(iwr.ifr_name, if_name, IFNAMSIZ);
+ g_strlcpy(buf, cmd, MAX_BUF_SIZE);
+ iwr.u.data.pointer = buf;
+ iwr.u.data.length = MAX_BUF_SIZE;
+
+ usleep(DRIVER_DELAY);
+
+ /* Issue ioctl */
+ if ((ioctl(sock_fd, SIOCSIWPRIV, &iwr)) < 0) {
+ ERR("ioctl failed...!!!\n");
+ ret_val = MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ return ret_val;
+}
+
+static int __get_dns_server(char *dns_server, int len)
+{
+#ifndef __USE_CONNMAN_DNS_ADDR__
+ g_strlcpy(dns_server, GOOGLE_PUBLIC_DNS, len);
+ DBG("DNS server [%s]\n", dns_server);
+
+ return EXIT_SUCCESS;
+#else
+ int ret = EXIT_FAILURE;
+ GError *error = NULL;
+ DBusGConnection *bus = NULL;
+ DBusGProxy *manager_proxy = NULL;
+ DBusGProxy *service_proxy = NULL;
+ gchar *service_object_path = NULL;
+
+ GHashTable *hash = NULL;
+ GValue *value;
+ const gchar *state;
+ gchar **dns_server_list = NULL;
+ GPtrArray *service_list = NULL;
+
+ bus = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
+ if (error) {
+ ERR("Couldn't connect to the System bus[%s]", error->message);
+ g_error_free(error);
+ return ret;
+ }
+
+ manager_proxy = dbus_g_proxy_new_for_name(bus, "net.connman",
+ "/",
+ "net.connman.Manager");
+ if (!manager_proxy) {
+ ERR("Couldn't create the proxy object");
+ goto done;
+ }
+
+ dbus_g_proxy_call(manager_proxy, "GetProperties", &error, G_TYPE_INVALID,
+ dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
+ &hash, G_TYPE_INVALID);
+ if (error) {
+ ERR("GetProperties failed[%s]", error->message);
+ g_error_free(error);
+ goto done;
+ }
+
+ /*
+ dict entry(
+ string "Services"
+ variant array [
+ object path "/profile/default/cellular_45001_cellular_Samsung3G_1"
+ object path "/profile/default/cellular_45001_cellular_Samsung3G_MMS_2"
+ ]
+ )
+ */
+ value = g_hash_table_lookup(hash, "Services");
+
+ service_list = g_value_get_boxed(value);
+ if (!service_list) {
+ ERR("No service available");
+ goto done;
+ }
+
+ service_object_path = g_ptr_array_index(service_list, 0);
+ DBG("service object path : %s\n", service_object_path);
+
+ service_proxy = dbus_g_proxy_new_for_name(bus, "net.connman",
+ service_object_path,
+ "net.connman.Service");
+ if (!service_proxy) {
+ ERR("Couldn't create the proxy object");
+ goto done;
+ }
+
+ dbus_g_proxy_call(service_proxy, "GetProperties", &error, G_TYPE_INVALID,
+ dbus_g_type_get_map("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
+ &hash, G_TYPE_INVALID);
+ if (error) {
+ ERR("GetProperties failed[%s]", error->message);
+ g_error_free(error);
+ goto done;
+ }
+
+ /*
+ dict entry(
+ string "State"
+ variant string "online"
+ )
+
+ dict entry(
+ string "Nameservers"
+ variant array [
+ string "165.213.73.226"
+ string "10.32.192.11"
+ ]
+ )
+ */
+ value = g_hash_table_lookup(hash, "State");
+ state = value ? g_value_get_string(value) : NULL;
+ DBG("Network state : %s\n", state);
+
+ if (g_strcmp0(state, "ready") != 0 && g_strcmp0(state, "online") != 0) {
+ ERR("Network is not connected\n");
+ goto done;
+ }
+
+ value = g_hash_table_lookup(hash, "Nameservers");
+
+ dns_server_list = g_value_get_boxed(value);
+ if (!dns_server_list) {
+ ERR("No Nameserver exist");
+ goto done;
+ }
+ g_strlcpy(dns_server, *dns_server_list, len);
+ DBG("DNS server [%s]\n", dns_server);
+
+ ret = EXIT_SUCCESS;
+done:
+ if (dns_server_list)
+ g_strfreev(dns_server_list);
+ if (service_list)
+ g_ptr_array_free(service_list, TRUE);
+ if (manager_proxy)
+ g_object_unref(manager_proxy);
+ if (service_proxy)
+ g_object_unref(service_proxy);
+ if (bus)
+ dbus_g_connection_unref(bus);
+
+ return ret;
+#endif
+}
+
+static int __get_psk_hexascii(const char *pass, const unsigned char *salt, char *psk, unsigned int psk_len)
+{
+ if (pass == NULL || salt == NULL || psk == NULL || psk_len == 0) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ if (psk_len < SHA256_DIGEST_LENGTH * 2 + 1) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ int i;
+ int d_16;
+ int r_16;
+ unsigned char buf[SHA256_DIGEST_LENGTH] = {0, };
+
+ if (!PKCS5_PBKDF2_HMAC_SHA1(pass, strlen(pass),
+ salt, strlen((const char *)salt),
+ PSK_ITERATION_COUNT, sizeof(buf), buf)) {
+ ERR("Getting psk is failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ for (i = 0; i < SHA256_DIGEST_LENGTH; i++) {
+ d_16 = buf[i] >> 4;
+ r_16 = buf[i] & 0xf;
+
+ psk[i << 1] = d_16 < 10 ? d_16 + '0' : d_16 - 10 + 'a';
+ psk[(i << 1) + 1] = r_16 < 10 ? r_16 + '0' : r_16 - 10 + 'a';
+ }
+ psk[i << 1] = '\0';
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static int __execute_hostapd(const char *ssid, const char *security,
+ const char *key, int hide_mode)
+{
+ DBG("+\n");
+
+ char psk[2 * SHA256_DIGEST_LENGTH + 1] = {0, };
+ char buf[HOSTAPD_CONF_LEN] = "";
+ char sec_buf[HOSTAPD_CONF_LEN] = "";
+ FILE *fp = NULL;
+ pid_t pid;
+
+ if (security != NULL && !strcmp(security, "wpa2-psk")) {
+ if (__get_psk_hexascii(key, (const unsigned char *)ssid, psk,
+ sizeof(psk)) != MOBILE_AP_ERROR_NONE) {
+ ERR("Getting PSK(Hex ascii type) is failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ snprintf(sec_buf, HOSTAPD_CONF_LEN,
+ "\nwpa=2\nrsn_pairwise=CCMP\nwpa_psk=%s",
+ psk);
+ }
+
+ snprintf(buf, HOSTAPD_CONF_LEN, HOSTAPD_CONF,
+ WIFI_IF,
+ HOSTAPD_CTRL_INTF_DIR,
+ ssid,
+ MOBILE_AP_WIFI_CHANNEL,
+ hide_mode ? 2 : 0,
+ MOBILE_AP_MAX_WIFI_STA,
+ sec_buf);
+
+ fp = fopen(HOSTAPD_CONF_FILE, "w");
+ if (NULL == fp) {
+ ERR("Could not create the file.\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+ fputs(buf, fp);
+ fclose(fp);
+
+ pid = fork();
+ if (pid < 0) {
+ ERR("fork failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ if (pid == 0) {
+ if (execl(HOSTAPD_BIN, HOSTAPD_BIN, "-e", HOSTAPD_ENTROPY_FILE,
+ HOSTAPD_CONF_FILE,
+ "-f", HOSTAPD_DEBUG_FILE, "-d",
+ (char *)NULL)) {
+ ERR("execl failed\n");
+ }
+
+ ERR("Should not get here!");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ hostapd_pid = pid;
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static int __terminate_hostapd()
+{
+ DBG("+\n");
+
+ if (hostapd_pid == 0) {
+ DBG("There is no hostapd\n");
+ return MOBILE_AP_ERROR_NONE;
+ }
+
+ kill(hostapd_pid, SIGTERM);
+ waitpid(hostapd_pid, NULL, 0);
+ hostapd_pid = 0;
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+/*
+ * number NUM_STA(void)
+ * addr STA-FIRST(void)
+ * addr STA-NEXT(addr)
+ * void DISASSOCIATE(addr)
+ * void READ_WHITELIST(filename)
+ * void SET_MAXCLIENT(number)
+ */
+static int __send_hostapd_req(int fd, const char *req, const int req_len,
+ char *buf, int *buf_len)
+{
+ if (fd < 0 || req == NULL || req_len <= 0 ||
+ buf == NULL || buf_len == NULL || *buf_len <= 0) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ struct timeval tv = {10, 0};
+ fd_set fds;
+ int ret = 0;
+
+ ret = send(fd, req, req_len, 0);
+ if (ret < 0) {
+ ERR("send is failed : %s\n", strerror(errno));
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ while (TRUE) {
+ FD_ZERO(&fds);
+ FD_SET(fd, &fds);
+ ret = select(fd + 1, &fds, NULL, NULL, &tv);
+ if (ret < 0) {
+ return MOBILE_AP_ERROR_INTERNAL;
+ } else if (ret == 0) {
+ ERR("There is no response from hostapd\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ } else if (!FD_ISSET(fd, &fds)) {
+ ERR("Unknown case\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ ret = recv(fd, buf, (*buf_len) - 1, 0);
+ if (ret < 0) {
+ ERR("recv is failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ if (buf[0] == '<') {
+ DBG("Unsolicited message\n");
+ continue;
+ }
+
+ *buf_len = ret;
+ buf[ret] = '\0';
+ if (ret == 0) {
+ ERR("socket is closed\n");
+ }
+
+ break;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static int __open_hostapd_intf(int *fd, const char *intf)
+{
+ if (fd == NULL || intf == NULL) {
+ ERR("fd is NULL\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ DBG("+\n");
+
+ int retry = 0;
+ char ctrl_intf[255] = {0, };
+ struct sockaddr_un src;
+ struct sockaddr_un dest;
+ struct stat stat_buf;
+
+ *fd = socket(PF_UNIX, SOCK_DGRAM, 0);
+ if (*fd < 0) {
+ ERR("socket is failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ src.sun_family = AF_UNIX;
+ g_strlcpy(src.sun_path, intf, sizeof(src.sun_path));
+
+ if (stat(src.sun_path, &stat_buf) == 0) {
+ DBG("There is already mh interface. It will be removed\n");
+ unlink(src.sun_path);
+ }
+
+ if (bind(*fd, (struct sockaddr *)&src, sizeof(src)) < 0) {
+ ERR("bind is failed\n");
+ close(*fd);
+ *fd = -1;
+ unlink(src.sun_path);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ snprintf(ctrl_intf, sizeof(ctrl_intf), "%s/%s",
+ HOSTAPD_CTRL_INTF_DIR, WIFI_IF);
+ dest.sun_family = AF_UNIX;
+ g_strlcpy(dest.sun_path, ctrl_intf, sizeof(dest.sun_path));
+
+ while (connect(*fd, (struct sockaddr *)&dest, sizeof(dest)) < 0) {
+ DBG("connect is failed : %s\n", strerror(errno));
+ if (++retry >= HOSTAPD_RETRY_MAX)
+ goto FAIL;
+ usleep(HOSTAPD_RETRY_DELAY);
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+
+FAIL:
+ ERR("Cannot make connection to hostapd\n");
+ close(*fd);
+ *fd = -1;
+ unlink(src.sun_path);
+
+ return MOBILE_AP_ERROR_INTERNAL;
+}
+
+static int __close_hostapd_intf(int *fd)
+{
+ DBG("+\n");
+
+ if (fd == NULL) {
+ ERR("fd is NULL\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ if (*fd > 0)
+ close(*fd);
+ *fd = -1;
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static gboolean __hostapd_monitor_cb(GIOChannel *source)
+{
+ DBG("+\n");
+
+ char buf[HOSTAPD_REQ_MAX_LEN] = {0, };
+ char *pbuf = NULL;
+ gsize read = 0;
+
+#if !GLIB_CHECK_VERSION(2, 31, 0)
+ int ret = 0;
+
+ ret = g_io_channel_read(hostapd_io_channel, buf,
+ HOSTAPD_REQ_MAX_LEN, &read);
+ if (ret != G_IO_ERROR_NONE) {
+ ERR("g_io_channel_read is failed\n");
+ return FALSE;
+ }
+#else
+ GError *err = NULL;
+
+ g_io_channel_read_chars(hostapd_io_channel, buf,
+ HOSTAPD_REQ_MAX_LEN, &read, &err);
+ if (err != NULL) {
+ ERR("g_io_channel_read_chars is failed : %s\n", err->message);
+ g_error_free(err);
+ return FALSE;
+ }
+#endif
+
+ buf[read] = '\0';
+ pbuf = strrchr(buf, '\n');
+ if (pbuf != NULL)
+ *pbuf = '\0';
+
+ if (buf[0] == '<' && (pbuf = strchr(buf, '>')) != NULL) {
+ pbuf++;
+ } else {
+ pbuf = buf;
+ }
+
+ DBG("Event : %s\n", pbuf);
+
+ if (!strncmp(pbuf, HOSTAPD_STA_DISCONN, strlen(HOSTAPD_STA_DISCONN))) {
+ pbuf = strchr(pbuf, ' ');
+ if (pbuf == NULL) {
+ ERR("There is no info. for disconnected station\n");
+ return TRUE;
+ }
+ pbuf++;
+
+ DBG("Disconnected station MAC : %s\n", pbuf);
+ _remove_station_info(pbuf, _slist_find_station_by_mac);
+
+ return TRUE;
+ } else {
+ DBG("Event is not handled\n");
+ }
+
+ return TRUE;
+}
+
+static int __open_hostapd_monitor(int *fd)
+{
+ if (fd == NULL) {
+ ERR("fd is NULL\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ DBG("+\n");
+
+ char buf[HOSTAPD_REQ_MAX_LEN] = {0, };
+ int buf_len = 0;
+
+ if (__open_hostapd_intf(fd, MH_MONITOR_INTF) != MOBILE_AP_ERROR_NONE) {
+ ERR("__open_hostapd_intf() is failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ hostapd_io_channel = g_io_channel_unix_new(*fd);
+ if (hostapd_io_channel == NULL) {
+ ERR("g_io_channel_unix_new is failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ g_io_channel_set_encoding(hostapd_io_channel, NULL, NULL);
+ g_io_channel_set_flags(hostapd_io_channel,
+ G_IO_FLAG_APPEND | G_IO_FLAG_NONBLOCK, NULL);
+
+ hostapd_io_source = g_io_add_watch(hostapd_io_channel, G_IO_IN,
+ (GIOFunc)__hostapd_monitor_cb, NULL);
+
+ buf_len = sizeof(buf);
+ __send_hostapd_req(*fd, HOSTAPD_MONITOR_ATTACH,
+ strlen(HOSTAPD_MONITOR_ATTACH), buf, &buf_len);
+ DBG("return : %s\n", buf);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static int __close_hostapd_monitor(int *fd)
+{
+ GError *err = NULL;
+ char buf[HOSTAPD_REQ_MAX_LEN] = {0, };
+ int buf_len = 0;
+
+ buf_len = sizeof(buf);
+ __send_hostapd_req(*fd, HOSTAPD_MONITOR_DETACH,
+ strlen(HOSTAPD_MONITOR_DETACH), buf, &buf_len);
+ DBG("return : %s\n", buf);
+
+ if (hostapd_io_source != 0) {
+ g_source_remove(hostapd_io_source);
+ hostapd_io_source = 0;
+ }
+
+ if (hostapd_io_channel != NULL) {
+ g_io_channel_shutdown(hostapd_io_channel, TRUE, &err);
+ g_io_channel_unref(hostapd_io_channel);
+ hostapd_io_channel = NULL;
+ }
+
+ __close_hostapd_intf(fd);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_drv_interface_e __get_drv_interface(void)
+{
+ static mobile_ap_drv_interface_e drv_interface = MOBILE_AP_DRV_INTERFACE_NONE;
+
+ if (drv_interface != MOBILE_AP_DRV_INTERFACE_NONE) {
+ return drv_interface;
+ }
+
+ const char *drv_rfkill_path = "/sys/devices/platform";
+ const char *wext_drv[] = {
+ "bcm4329-b1", "bcm4330-b0",
+ "bcm4330-b1", "bcm4330-b2",
+ NULL};
+
+ char path[MAX_BUF_SIZE] = { 0 };
+ struct stat stat_buf = { 0 };
+ int fd = 0;
+ int i = 0;
+
+ drv_interface = MOBILE_AP_NL80211;
+
+ for (i = 0; wext_drv[i] != NULL; i++) {
+ snprintf(path, sizeof(path), "%s/%s",
+ drv_rfkill_path, wext_drv[i]);
+ fd = open(path, O_RDONLY);
+ if (fd < 0)
+ continue;
+
+ if (fstat(fd, &stat_buf) == 0 && S_ISDIR(stat_buf.st_mode)) {
+ drv_interface = MOBILE_AP_WEXT;
+ close(fd);
+ break;
+ }
+
+ close(fd);
+ }
+
+ return drv_interface;
+}
+
+int _mh_core_enable_softap(const char *ssid, const char *security,
+ const char *key, int hide_mode)
+{
+ if (ssid == NULL || security == NULL || key == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ char cmd[MAX_BUF_SIZE];
+ int ret_status = MOBILE_AP_ERROR_NONE;
+ mobile_ap_drv_interface_e drv_interface = MOBILE_AP_DRV_INTERFACE_NONE;
+
+ int sock_fd;
+ char *if_name = WIFI_IF;
+ char buf[MAX_BUF_SIZE] = { 0 };
+
+ snprintf(cmd, sizeof(cmd), "%s softap", WLAN_SCRIPT);
+ if (_execute_command(cmd)) {
+ ERR("execute script failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ drv_interface = __get_drv_interface();
+
+ switch (drv_interface) {
+ case MOBILE_AP_WEXT:
+ if ((sock_fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
+ ERR("Failed to open socket...!!!\n");
+ ret_status = MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ snprintf(cmd, MAX_BUF_SIZE, "ASCII_CMD=AP_CFG,"
+ "SSID_LEN=%d,SSID=%s,"
+ "SEC=%s,KEY_LEN=%d,KEY=%s,CHANNEL=%d,"
+ "PREAMBLE=0,MAX_SCB=%d,HIDE=%d,END",
+ strlen(ssid), ssid,
+ security, strlen(key), key,
+ MOBILE_AP_WIFI_CHANNEL,
+ MOBILE_AP_MAX_WIFI_STA, hide_mode);
+ ret_status = __issue_ioctl(sock_fd, if_name, cmd, buf);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("__issue_ioctl failed...!!!\n");
+ close(sock_fd);
+ break;
+ }
+
+ /* Start broadcasting of BSS. */
+ snprintf(cmd, MAX_BUF_SIZE, "ASCII_CMD=AP_BSS_START");
+ ret_status = __issue_ioctl(sock_fd, if_name, cmd, buf);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("__issue_ioctl failed...!!!\n");
+ close(sock_fd);
+ break;
+ }
+
+ close(sock_fd);
+
+ ret_status = _mh_core_set_ip_address(SOFTAP_IF,
+ IP_ADDRESS_SOFTAP);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("_mh_core_set_ip_address of SOFTAP_IF is failed\n");
+ break;
+ }
+
+ DBG("Setting softap is OK\n");
+ ret_status = _mh_core_set_ip_address(WIFI_IF,
+ IP_ADDRESS_WIFI);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("_mh_core_set_ip_address of WIFI_IF is failed\n");
+ break;
+ }
+ break;
+
+ case MOBILE_AP_NL80211:
+ ret_status = _mh_core_set_ip_address(WIFI_IF,
+ IP_ADDRESS_SOFTAP);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("_mh_core_set_ip_address is failed\n");
+ break;
+ }
+
+ ret_status = __execute_hostapd(ssid, security, key, hide_mode);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("__execute_hostapd is failed\n");
+ break;
+ }
+
+ ret_status = __open_hostapd_intf(&hostapd_ctrl_fd, MH_CTRL_INTF);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("__open_hostapd_intf is failed\n");
+ __terminate_hostapd();
+ break;
+ }
+
+ ret_status = __open_hostapd_monitor(&hostapd_monitor_fd);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("__open_hostapd_monitor is failed\n");
+ __close_hostapd_intf(&hostapd_ctrl_fd);
+ __terminate_hostapd();
+ break;
+ }
+
+ break;
+
+ default:
+ DBG("Unknown driver interface : %d\n", drv_interface);
+ break;
+ }
+
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ snprintf(cmd, sizeof(cmd), "%s stop", WLAN_SCRIPT);
+ if (_execute_command(cmd)) {
+ ERR("execute script failed : %s\n", cmd);
+ }
+ }
+
+ return ret_status;
+}
+
+int _mh_core_disable_softap(void)
+{
+ char cmd[MAX_BUF_SIZE] = { 0 };
+ int ret_status = MOBILE_AP_ERROR_NONE;
+ mobile_ap_drv_interface_e drv_interface = MOBILE_AP_DRV_INTERFACE_NONE;
+
+ int sock_fd = 0;
+ char buf[MAX_BUF_SIZE] = { 0 };
+ char *if_name = WIFI_IF;
+
+ drv_interface = __get_drv_interface();
+
+ switch (drv_interface) {
+ case MOBILE_AP_WEXT:
+ if ((sock_fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
+ ERR("Failed to open socket...!!!\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ /* Stop broadcasting of BSS. */
+ snprintf(cmd, MAX_BUF_SIZE, "ASCII_CMD=AP_BSS_STOP");
+ ret_status = __issue_ioctl(sock_fd, if_name, cmd, buf);
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("__issue_ioctl failed...!!!\n");
+ close(sock_fd);
+ break;
+ }
+
+ close(sock_fd);
+ break;
+
+ case MOBILE_AP_NL80211:
+ ret_status = __close_hostapd_intf(&hostapd_ctrl_fd);
+ if (ret_status != MOBILE_AP_ERROR_NONE)
+ ERR("hostapd termination is failed\n");
+
+ ret_status = __close_hostapd_monitor(&hostapd_monitor_fd);
+ if (ret_status != MOBILE_AP_ERROR_NONE)
+ ERR("hostapd termination is failed\n");
+
+ ret_status = __terminate_hostapd();
+ if (ret_status != MOBILE_AP_ERROR_NONE) {
+ ERR("hostapd termination is failed\n");
+ }
+ break;
+
+ default:
+ DBG("Unknown driver interface : %d\n", drv_interface);
+ break;
+ }
+
+ snprintf(cmd, sizeof(cmd), "%s stop", WLAN_SCRIPT);
+ if (_execute_command(cmd)) {
+ ERR("execute script failed : %s\n", cmd);
+ ret_status = MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ return ret_status;
+}
+
+static int __get_device_info_by_wext(softap_device_info_t *di)
+{
+ int sock_fd = 0;
+ char *if_name = SOFTAP_IF;
+ char cmd[MAX_BUF_SIZE];
+ char buf[MAX_BUF_SIZE] = { 0 };
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ char *buf_ptr = NULL;
+ int i;
+
+ if ((sock_fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
+ ERR("Failed to open socket...!!!\n");
+ di->number = 0;
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ snprintf(cmd, MAX_BUF_SIZE, "AP_GET_STA_LIST");
+ ret = __issue_ioctl(sock_fd, if_name, cmd, buf);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__issue_ioctl failed...!!!\n");
+ di->number = 0;
+ close(sock_fd);
+ return ret;
+ }
+
+ buf_ptr = buf;
+
+ sscanf(buf_ptr, "%02x", &di->number);
+ DBG("connected station : %d\n", di->number);
+
+ buf_ptr += 2;
+ for (i = 0; i < di->number; i++) {
+ unsigned int l_bssid[MOBILE_AP_WIFI_BSSID_LEN];
+ sscanf(buf_ptr, "%02X%02X%02X%02X%02X%02X", &l_bssid[0],
+ &l_bssid[1], &l_bssid[2], &l_bssid[3],
+ &l_bssid[4], &l_bssid[5]);
+ snprintf(di->bssid[i], MOBILE_AP_STR_INFO_LEN,
+ "%02X:%02X:%02X:%02X:%02X:%02X",
+ l_bssid[0], l_bssid[1], l_bssid[2],
+ l_bssid[3], l_bssid[4], l_bssid[5]);
+
+ DBG("STA[%d] address[%s]\n", i, di->bssid[i]);
+
+ buf_ptr += 12;
+ }
+
+ close(sock_fd);
+
+ return ret;
+}
+
+static int __get_device_info_by_nl80211(softap_device_info_t *di)
+{
+ int ret = 0;
+ int no_of_sta = 0;
+ int buf_len = 0;
+ char req[HOSTAPD_REQ_MAX_LEN] = {0, };
+ char buf[MOBILE_AP_STR_INFO_LEN] = {0, };
+
+ buf_len = sizeof(buf);
+ g_strlcpy(req, "NUM_STA", sizeof(req));
+ ret = __send_hostapd_req(hostapd_ctrl_fd,
+ req, strlen(req), buf, &buf_len);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__send_hostapd_req is failed : %d\n", ret);
+ return ret;
+ }
+
+ DBG("The number of station : %s\n", buf);
+ if (atoi(buf) == 0) {
+ DBG("There is no station\n");
+ return MOBILE_AP_ERROR_NONE;
+ }
+
+ buf_len = sizeof(buf);
+ g_strlcpy(req, "STA-FIRST", sizeof(req));
+ ret = __send_hostapd_req(hostapd_ctrl_fd,
+ req, strlen(req), buf, &buf_len);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__send_hostapd_req is failed : %d\n", ret);
+ return ret;
+ }
+
+ do {
+ if (!strncmp(buf, "FAIL", 4)) {
+ ERR("FAIL is returned\n");
+ break;
+ }
+
+ if (buf[0] == '\0') {
+ ERR("NULL string\n");
+ break;
+ }
+
+ DBG("Station : %s\n", buf);
+ g_strlcpy(di->bssid[no_of_sta++], buf, MOBILE_AP_STR_INFO_LEN);
+
+ buf_len = sizeof(buf);
+ snprintf(req, sizeof(req), "STA-NEXT %s", buf);
+ ret = __send_hostapd_req(hostapd_ctrl_fd,
+ req, strlen(req), buf, &buf_len);
+ } while (ret == MOBILE_AP_ERROR_NONE);
+
+ di->number = no_of_sta;
+
+ return ret;
+}
+
+int _mh_core_get_device_info(softap_device_info_t *di)
+{
+ if (di == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ switch (__get_drv_interface()) {
+ case MOBILE_AP_WEXT:
+ ret = __get_device_info_by_wext(di);
+ break;
+
+ case MOBILE_AP_NL80211:
+ ret = __get_device_info_by_nl80211(di);
+ break;
+
+ default:
+ ERR("Unknown interface\n");
+ break;
+ }
+
+ return ret;
+}
+
+int _mh_core_execute_dhcp_server(void)
+{
+ char buf[DNSMASQ_CONF_LEN] = "";
+ char dns_server[MOBILE_AP_STR_INFO_LEN] = {0, };
+ FILE *fp = NULL;
+ pid_t pid;
+
+ if (__get_dns_server(dns_server, sizeof(dns_server))) {
+ ERR("Getting DNS server failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ fp = fopen(DNSMASQ_CONF_FILE, "w");
+ if (NULL == fp) {
+ ERR("Could not create the file.\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+ snprintf(buf, DNSMASQ_CONF_LEN, DNSMASQ_CONF, dns_server);
+ fputs(buf, fp);
+ fclose(fp);
+
+ pid = fork();
+ if (pid < 0) {
+ ERR("fork failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ if (pid == 0) {
+ if (execl("/usr/bin/dnsmasq", "/usr/bin/dnsmasq", "-d",
+ "-p", "0", "-C", DNSMASQ_CONF_FILE,
+ (char *)NULL)) {
+ ERR("execl failed\n");
+ }
+
+ ERR("Should not get here!");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ dnsmasq_pid = pid;
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _mh_core_terminate_dhcp_server(void)
+{
+ if (dnsmasq_pid == 0) {
+ DBG("There is no dnsmasq\n");
+ return MOBILE_AP_ERROR_NONE;
+ }
+
+ kill(dnsmasq_pid, SIGTERM);
+ waitpid(dnsmasq_pid, NULL, 0);
+ dnsmasq_pid = 0;
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _mh_core_enable_masquerade(const char *ext_if)
+{
+ int fd = -1;
+ char cmd[MAX_BUF_SIZE] = {0, };
+
+ fd = open(IP_FORWARD, O_WRONLY);
+ if (fd < 0) {
+ ERR("open failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ if (write(fd, "1", 1) != 1) {
+ ERR("write failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+ close(fd);
+
+ snprintf(cmd, sizeof(cmd), "%s -t nat -A POSTROUTING "MASQUERADE_RULE,
+ IPTABLES, ext_if);
+ if (_execute_command(cmd)) {
+ ERR("iptables failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ _add_data_usage_rule(WIFI_IF, ext_if);
+ _add_data_usage_rule(BT_IF_ALL, ext_if);
+ _add_data_usage_rule(USB_IF, ext_if);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _mh_core_disable_masquerade(const char *ext_if)
+{
+ int fd = -1;
+ char cmd[MAX_BUF_SIZE] = {0, };
+
+ fd = open(IP_FORWARD, O_WRONLY);
+ if (fd < 0) {
+ ERR("open failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ if (write(fd, "0", 1) != 1) {
+ ERR("write failed\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+ close(fd);
+
+ snprintf(cmd, sizeof(cmd), "%s -t nat -D POSTROUTING "MASQUERADE_RULE,
+ IPTABLES, ext_if);
+ if (_execute_command(cmd)) {
+ ERR("iptables failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ _del_data_usage_rule(WIFI_IF, ext_if);
+ _del_data_usage_rule(BT_IF_ALL, ext_if);
+ _del_data_usage_rule(USB_IF, ext_if);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+void _mh_core_add_data_to_array(GPtrArray *array, guint type, gchar *dev_name)
+{
+ GValue value = {0, {{0}}};
+
+ g_value_init(&value, DBUS_STRUCT_UINT_STRING);
+ g_value_take_boxed(&value,
+ dbus_g_type_specialized_construct(DBUS_STRUCT_UINT_STRING));
+ dbus_g_type_struct_set(&value, 0, type, 1, dev_name, G_MAXUINT);
+ g_ptr_array_add(array, g_value_get_boxed(&value));
+}
+
+int _mh_core_set_ip_address(const char *if_name, const in_addr_t ip)
+{
+ struct ifreq ifr;
+ struct sockaddr_in addr;
+ int sock_fd;
+
+ DBG("if_name : %s ip address : 0x%X\n", if_name, ip);
+
+ if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
+ ERR("socket open failed!!!\n");
+ perror("ioctl fail");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ g_strlcpy(ifr.ifr_name, if_name, IFNAMSIZ);
+
+ memset(&addr, 0, sizeof(struct sockaddr));
+ addr.sin_family = AF_INET;
+ addr.sin_port = 0;
+ addr.sin_addr.s_addr = htonl(ip);
+
+ memcpy(&ifr.ifr_addr, &addr, sizeof(struct sockaddr));
+ if (ioctl(sock_fd, SIOCSIFADDR, &ifr) < 0) {
+ ERR("ioctl failed...!!!\n");
+ perror("ioctl fail");
+ close(sock_fd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) < 0) {
+ ERR("ioctl failed...!!!\n");
+ perror("ioctl fail");
+ close(sock_fd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
+ if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) < 0) {
+ ERR("ioctl failed...!!!\n");
+ perror("ioctl fail");
+ close(sock_fd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ close(sock_fd);
+
+ return MOBILE_AP_ERROR_NONE;
+}
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <bluetooth.h>
+
+#include "mobileap_agent.h"
+#include "mobileap_common.h"
+#include "mobileap_bluetooth.h"
+
+typedef struct {
+ bt_device_info_s *info;
+ char *intf_name;
+ const in_addr_t intf_ip;
+} __bt_remote_device_s;
+
+static __bt_remote_device_s __bt_remote_devices[MOBILE_AP_MAX_BT_STA] = {
+ {NULL, NULL, IP_ADDRESS_BT_1},
+ {NULL, NULL, IP_ADDRESS_BT_2},
+ {NULL, NULL, IP_ADDRESS_BT_3},
+ {NULL, NULL, IP_ADDRESS_BT_4},
+ {NULL, NULL, IP_ADDRESS_BT_5},
+ {NULL, NULL, IP_ADDRESS_BT_6},
+ {NULL, NULL, IP_ADDRESS_BT_7}};
+
+static __bt_remote_device_s *__find_bt_remote(const char *mac)
+{
+ int i;
+
+ for (i = 0; i < MOBILE_AP_MAX_BT_STA; i++) {
+ if (__bt_remote_devices[i].info == NULL)
+ continue;
+
+ if (!g_ascii_strcasecmp(__bt_remote_devices[i].info->remote_address, mac))
+ break;
+ }
+
+ if (i == MOBILE_AP_MAX_BT_STA) {
+ ERR("Not found : %s\n", mac);
+ return NULL;
+ }
+
+ return &__bt_remote_devices[i];
+}
+
+static __bt_remote_device_s *__add_bt_remote(bt_device_info_s *info, const char *intf_name)
+{
+ int i;
+
+ for (i = 0; i < MOBILE_AP_MAX_BT_STA; i++) {
+ if (__bt_remote_devices[i].info == NULL)
+ break;
+ }
+
+ if (i == MOBILE_AP_MAX_BT_STA) {
+ ERR("Too many BT devices are connected\n");
+ return NULL;
+ }
+
+ __bt_remote_devices[i].intf_name = g_strdup(intf_name);
+ if (__bt_remote_devices[i].intf_name == NULL) {
+ ERR("Memory allocation failed\n");
+ return NULL;
+ }
+
+ __bt_remote_devices[i].info = info;
+
+ return &__bt_remote_devices[i];
+}
+
+static gboolean __del_bt_remote(const char *mac)
+{
+ int i;
+
+ for (i = 0; i < MOBILE_AP_MAX_BT_STA; i++) {
+ if (__bt_remote_devices[i].info == NULL)
+ continue;
+
+ if (!g_ascii_strcasecmp(__bt_remote_devices[i].info->remote_address, mac))
+ break;
+ }
+
+ if (i == MOBILE_AP_MAX_BT_STA) {
+ ERR("Not found : %s\n", mac);
+ return FALSE;
+ }
+
+ bt_adapter_free_device_info(__bt_remote_devices[i].info);
+ g_free(__bt_remote_devices[i].intf_name);
+
+ __bt_remote_devices[i].info = NULL;
+ __bt_remote_devices[i].intf_name = NULL;
+
+ return TRUE;
+}
+
+static void __del_bt_remote_all(void)
+{
+ int i;
+
+ for (i = 0; i < MOBILE_AP_MAX_BT_STA; i++) {
+ if (__bt_remote_devices[i].info) {
+ bt_adapter_free_device_info(__bt_remote_devices[i].info);
+ __bt_remote_devices[i].info = NULL;
+ }
+
+ if (__bt_remote_devices[i].intf_name) {
+ g_free(__bt_remote_devices[i].intf_name);
+ __bt_remote_devices[i].intf_name = NULL;
+ }
+ }
+
+ return;
+}
+
+static void __bt_nap_connection_changed(bool connected, const char *remote_address, const char *interface_name, void *user_data)
+{
+ if (remote_address == NULL || interface_name == NULL || user_data == NULL) {
+ ERR("Invalid param\n");
+ return;
+ }
+
+ __bt_remote_device_s *remote;
+ bt_device_info_s *info;
+ int ret;
+
+ DBG("Remote address : %s, Interface : %s, %s\n",
+ remote_address, interface_name,
+ connected ? "Connected" : "Disconnected");
+
+ if (connected) {
+ ret = bt_adapter_get_bonded_device_info(remote_address, &info);
+ if (ret != BT_ERROR_NONE) {
+ ERR("bt_adapter_get_bonded_device_info is failed : %d\n", ret);
+ return;
+ }
+
+ remote = __add_bt_remote(info, interface_name);
+ if (remote == NULL) {
+ ERR("__add_bt_remote is failed\n");
+ bt_adapter_free_device_info(info);
+ return;
+ }
+
+ ret = _mh_core_set_ip_address(interface_name, remote->intf_ip);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("Setting ip address error : %d\n", ret);
+ }
+ } else {
+ _remove_station_info(remote_address, _slist_find_station_by_mac);
+ if (__del_bt_remote(remote_address) == FALSE)
+ ERR("__del_bt_remote is failed\n");
+ }
+
+ return;
+}
+
+static mobile_ap_error_code_e __activate_bt_nap(MobileAPObject *obj)
+{
+ int bt_ret = BT_ERROR_NONE;
+ bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+
+ bt_ret = bt_adapter_get_visibility(&mode);
+ if (bt_ret != BT_ERROR_NONE)
+ ERR("bt_adapter_get_visibility is failed : %d\n", bt_ret);
+ else
+ DBG("Bluetooth is %s\n", mode !=
+ BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE ?
+ "visible" : "invisible");
+
+ bt_ret = bt_nap_set_connection_state_changed_cb(__bt_nap_connection_changed, (void *)obj);
+ if (bt_ret != BT_ERROR_NONE) {
+ ERR("bt_nap_set_connection_state_changed_cb is failed : %d\n", bt_ret);
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ bt_ret = bt_nap_activate();
+ if (bt_ret != BT_ERROR_NONE && bt_ret != BT_ERROR_ALREADY_DONE) {
+ bt_nap_unset_connection_state_changed_cb();
+ ERR("bt_nap_activate is failed : %d\n", bt_ret);
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static void __deactivate_bt_nap(void)
+{
+ int bt_ret;
+
+ bt_ret = bt_nap_deactivate();
+ if (bt_ret != BT_ERROR_NONE)
+ ERR("bt_nap_deactivate is failed : %d\n", bt_ret);
+
+ bt_ret = bt_nap_unset_connection_state_changed_cb();
+ if (bt_ret != BT_ERROR_NONE)
+ ERR("bt_nap_unset_connection_state_changed_cb is failed : %d\n", bt_ret);
+
+ return;
+}
+
+static void __bt_adapter_state_changed(int result, bt_adapter_state_e adapter_state, void *user_data)
+{
+ if (user_data == NULL) {
+ ERR("Invalid param\n");
+ return;
+ }
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_BT))
+ return;
+
+ int ret;
+ MobileAPObject *obj = (MobileAPObject *)user_data;
+ DBusGMethodInvocation *context = obj->bt_context;
+
+ obj->bt_context = NULL;
+ if (result != BT_ERROR_NONE) {
+ ERR("BT Adapter operation is failed : %d\n", result);
+ if (context) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ _mobileap_clear_state(MOBILE_AP_STATE_BT);
+ }
+ return;
+ }
+
+ DBG("BT Adapter is %s\n", adapter_state == BT_ADAPTER_ENABLED ?
+ "enabled" : "disabled");
+ if (adapter_state == BT_ADAPTER_DISABLED) {
+ _disable_bt_tethering(obj);
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_BT_TETHER_OFF,
+ SIGNAL_MSG_NOT_AVAIL_INTERFACE);
+ return;
+ }
+
+ ret = __activate_bt_nap(obj);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ bt_adapter_unset_state_changed_cb();
+ bt_deinitialize();
+ _deinit_tethering(obj);
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ _mobileap_clear_state(MOBILE_AP_STATE_BT);
+ return;
+ }
+
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_BT_TETHER_ON, NULL);
+ if (context)
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ return;
+}
+
+void _bt_get_remote_device_name(MobileAPObject *obj, const char *mac, char **name)
+{
+ if (obj == NULL || mac == NULL || name == NULL) {
+ ERR("Invalid param\n");
+ return;
+ }
+
+ __bt_remote_device_s *remote = NULL;
+
+ remote = __find_bt_remote(mac);
+ if (remote == NULL)
+ return;
+
+ *name = g_strdup(remote->info->remote_name);
+ if (*name == NULL) {
+ ERR("Memory allocation failed\n");
+ return;
+ }
+
+ return;
+}
+
+mobile_ap_error_code_e _disable_bt_tethering(MobileAPObject *obj)
+{
+ int bt_ret;
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_BT)) {
+ ERR("BT tethering has not been enabled\n");
+ return MOBILE_AP_ERROR_NOT_ENABLED;
+ }
+
+ __deactivate_bt_nap();
+
+ bt_ret = bt_adapter_unset_state_changed_cb();
+ if (bt_ret != BT_ERROR_NONE)
+ ERR("bt_adapter_unset_state_changed_cb is failed : %d\n", bt_ret);
+
+ bt_ret = bt_deinitialize();
+ if (bt_ret != BT_ERROR_NONE)
+ ERR("bt_deinitialize is failed : %d\n", bt_ret);
+
+ _remove_station_info_all(MOBILE_AP_TYPE_BT);
+ __del_bt_remote_all();
+
+ _deinit_tethering(obj);
+ _mobileap_clear_state(MOBILE_AP_STATE_BT);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+gboolean mobileap_enable_bt_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ int ret;
+ int bt_ret;
+ bt_adapter_state_e adapter_state = BT_ADAPTER_DISABLED;
+
+ DBG("+\n");
+
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+
+ if (_mobileap_is_enabled(MOBILE_AP_STATE_BT)) {
+ ERR("Bluetooth tethering is already enabled\n");
+ ret = MOBILE_AP_ERROR_ALREADY_ENABLED;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ if (obj->bt_context != NULL) {
+ ERR("Bluetooth tethering request is progressing\n");
+ ret = MOBILE_AP_ERROR_IN_PROGRESS;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ if (!_mobileap_set_state(MOBILE_AP_STATE_BT)) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ if (!_init_tethering(obj)) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ bt_ret = bt_initialize();
+ if (bt_ret != BT_ERROR_NONE) {
+ ERR("bt_initialize is failed : %d\n", bt_ret);
+ _deinit_tethering(obj);
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ bt_ret = bt_adapter_set_state_changed_cb(__bt_adapter_state_changed, (void *)obj);
+ if (bt_ret != BT_ERROR_NONE) {
+ ERR("bt_adapter_set_state_changed_cb is failed : %d\n", bt_ret);
+ bt_deinitialize();
+ _deinit_tethering(obj);
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ bt_ret = bt_adapter_get_state(&adapter_state);
+ if (bt_ret != BT_ERROR_NONE) {
+ ERR("bt_adapter_get_state is failed : %d\n", bt_ret);
+ bt_adapter_unset_state_changed_cb();
+ bt_deinitialize();
+ _deinit_tethering(obj);
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ if (adapter_state == BT_ADAPTER_DISABLED) {
+ bt_ret = bt_adapter_enable();
+ if (bt_ret != BT_ERROR_NONE) {
+ ERR("bt_adapter_enable is failed : %d\n", bt_ret);
+ bt_adapter_unset_state_changed_cb();
+ bt_deinitialize();
+ _deinit_tethering(obj);
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+ obj->bt_context = context;
+ return TRUE;
+ }
+
+ ret = __activate_bt_nap(obj);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ bt_adapter_unset_state_changed_cb();
+ bt_deinitialize();
+ _deinit_tethering(obj);
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_BT_TETHER_ON, NULL);
+ dbus_g_method_return(context, MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ return TRUE;
+
+FAIL:
+ _mobileap_clear_state(MOBILE_AP_STATE_BT);
+ dbus_g_method_return(context, MOBILE_AP_ENABLE_BT_TETHERING_CFM, ret);
+ return FALSE;
+}
+
+
+gboolean mobileap_disable_bt_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ mobile_ap_error_code_e ret;
+
+ DBG("+\n");
+
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = _disable_bt_tethering(obj);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ dbus_g_method_return(context, MOBILE_AP_DISABLE_BT_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_BT_TETHER_OFF, NULL);
+ dbus_g_method_return(context, MOBILE_AP_DISABLE_BT_TETHERING_CFM, ret);
+ return TRUE;
+}
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <glib.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "mobileap_notification.h"
+#include "mobileap_common.h"
+
+#define MOBILEAP_OBJECT_GET_CLASS(obj) \
+ (G_TYPE_INSTANCE_GET_CLASS ((obj), \
+ MOBILEAP_TYPE_OBJECT , MobileAPObjectClass))
+
+extern DBusConnection *mobileap_conn;
+
+static GSList *station_list = NULL;;
+
+gint _slist_find_station_by_interface(gconstpointer a, gconstpointer b)
+{
+ mobile_ap_station_info_t *si = (mobile_ap_station_info_t *)a;
+ mobile_ap_type_e interface = (mobile_ap_type_e)b;
+
+ return si->interface - interface;
+}
+
+gint _slist_find_station_by_mac(gconstpointer a, gconstpointer b)
+{
+ mobile_ap_station_info_t *si = (mobile_ap_station_info_t *)a;
+ const char *mac = (const char *)b;
+
+ return g_ascii_strcasecmp(si->mac, mac);
+}
+
+void _emit_mobileap_dbus_signal(MobileAPObject *obj,
+ mobile_ap_sig_e num, const gchar *message)
+{
+ MobileAPObjectClass *klass = MOBILEAP_OBJECT_GET_CLASS(obj);
+
+ DBG("Emitting signal id [%d], with message [%s]\n", num, message);
+ g_signal_emit(obj, klass->signals[num], 0, message);
+}
+
+void _send_dbus_station_info(const char *member, mobile_ap_station_info_t *info)
+{
+ if (mobileap_conn == NULL)
+ return;
+
+ if (member == NULL || info == NULL) {
+ ERR("Invalid param\n");
+ return;
+ }
+
+ DBusMessage *msg = NULL;
+ char *ip = info->ip;
+ char *mac = info->mac;
+ char *hostname = info->hostname;
+
+ msg = dbus_message_new_signal("/MobileAP",
+ "com.samsung.mobileap",
+ SIGNAL_NAME_DHCP_STATUS);
+ if (!msg) {
+ ERR("Unable to allocate D-Bus signal\n");
+ return;
+ }
+
+ if (!dbus_message_append_args(msg,
+ DBUS_TYPE_STRING, &member,
+ DBUS_TYPE_UINT32, &info->interface,
+ DBUS_TYPE_STRING, &ip,
+ DBUS_TYPE_STRING, &mac,
+ DBUS_TYPE_STRING, &hostname,
+ DBUS_TYPE_INVALID)) {
+ ERR("Event sending failed\n");
+ dbus_message_unref(msg);
+ return;
+ }
+
+ dbus_connection_send(mobileap_conn, msg, NULL);
+ dbus_message_unref(msg);
+
+ return;
+}
+
+
+void _update_station_count(int count)
+{
+ static int total_cnt = 0;
+ char str[MH_NOTI_STR_MAX] = {0, };
+ notification_h noti = NULL;
+
+ if (total_cnt == count) {
+ DBG("No need to update\n");
+ return;
+ }
+
+ DBG("Update the number of station : %d\n", count);
+ total_cnt = count;
+
+ if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_CONNECTED_DEVICE,
+ total_cnt) < 0) {
+ ERR("Error setting up vconf\n");
+ return;
+ }
+
+ _delete_notification();
+ if (total_cnt == 0)
+ return;
+
+ noti = _create_notification();
+ if (noti == NULL) {
+ ERR("_create_notification() is failed\n");
+ return;
+ }
+
+ _set_notification_app_launch(noti);
+
+ /* Currently notification bar cannot be updated.
+ * So it is always deleted and inserted.
+ */
+ snprintf(str, MH_NOTI_STR_MAX, MH_NOTI_STR, total_cnt);
+ _insert_notification(noti, str, MH_NOTI_TITLE, MH_NOTI_ICON_PATH);
+
+ return;
+}
+
+int _add_station_info(mobile_ap_station_info_t *info)
+{
+ if (info == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ guint count;
+ GSList *l = NULL;
+ mobile_ap_station_info_t *si = NULL;
+ int i = 0;
+
+ station_list = g_slist_append(station_list, info);
+ for (l = station_list; l != NULL; l = g_slist_next(l)) {
+ si = (mobile_ap_station_info_t *)l->data;
+ DBG("[%d] interface : %d\n", i, si->interface);
+ DBG("[%d] station MAC : %s\n", i, si->mac);
+ DBG("[%d] station Hostname : %s\n", i, si->hostname);
+ DBG("[%d] station IP : %s\n", i, si->ip);
+ i++;
+ }
+
+ count = g_slist_length(station_list);
+ _update_station_count(count);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _remove_station_info(gconstpointer data, GCompareFunc func)
+{
+ if (func == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ if (station_list == NULL) {
+ ERR("There is no station\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ GSList *l = NULL;
+ mobile_ap_station_info_t *si = NULL;
+ int count;
+
+ l = g_slist_find_custom(station_list, data, func);
+ if (!l) {
+ ERR("Not found\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ si = (mobile_ap_station_info_t *)l->data;
+ DBG("Remove station MAC : %s\n", si->mac);
+ station_list = g_slist_delete_link(station_list, l);
+ _send_dbus_station_info("DhcpLeaseDeleted", si);
+ g_free(si);
+
+ count = g_slist_length(station_list);
+ _update_station_count(count);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _remove_station_info_all(mobile_ap_type_e type)
+{
+ if (station_list == NULL) {
+ return MOBILE_AP_ERROR_NONE;
+ }
+
+ GSList *l = station_list;
+ GSList *temp_l = NULL;
+ mobile_ap_station_info_t *si = NULL;
+ int count;
+
+ while (l) {
+ si = (mobile_ap_station_info_t *)l->data;
+ DBG("interface : %d\n", si->interface);
+ if (si->interface != type) {
+ l = g_slist_next(l);
+ continue;
+ }
+
+ DBG("Remove station MAC : %s\n", si->mac);
+ _send_dbus_station_info("DhcpLeaseDeleted", si);
+ g_free(si);
+
+ temp_l = l;
+ l = g_slist_next(l);
+ station_list = g_slist_delete_link(station_list, temp_l);
+ }
+
+ count = g_slist_length(station_list);
+ _update_station_count(count);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _get_station_info(gconstpointer data, GCompareFunc func,
+ mobile_ap_station_info_t **si)
+{
+ if (func == NULL || si == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ if (station_list == NULL) {
+ ERR("There is no station\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ GSList *l = NULL;
+ mobile_ap_station_info_t *node = NULL;
+
+ l = g_slist_find_custom(station_list, data, func);
+ if (!l) {
+ ERR("Not found\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ node = l->data;
+ DBG("Found station : %s\n", node->mac);
+ *si = node;
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _get_station_count(int *count)
+{
+ if (count == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ *count = g_slist_length(station_list);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _station_info_foreach(GFunc func, void *user_data)
+{
+ if (func == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ g_slist_foreach(station_list, func, user_data);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _add_data_usage_rule(const char *src, const char *dest)
+{
+ if (src == NULL || src[0] == '\0' ||
+ dest == NULL || dest[0] == '\0' ||
+ g_strcmp0(src, dest) == 0) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ char cmd[MAX_BUF_SIZE] = {0, };
+
+ snprintf(cmd, sizeof(cmd), "%s -A FORWARD "FORWARD_RULE,
+ IPTABLES, src, dest);
+ DBG("ADD IPTABLES RULE : %s\n", cmd);
+ if (_execute_command(cmd)) {
+ ERR("iptables failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ snprintf(cmd, sizeof(cmd), "%s -A FORWARD "FORWARD_RULE,
+ IPTABLES, dest, src);
+ DBG("ADD IPTABLES RULE : %s\n", cmd);
+ if (_execute_command(cmd)) {
+ ERR("iptables failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _del_data_usage_rule(const char *src, const char *dest)
+{
+ if (src == NULL || src[0] == '\0' ||
+ dest == NULL || dest[0] == '\0' ||
+ g_strcmp0(src, dest) == 0) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ char cmd[MAX_BUF_SIZE] = {0, };
+
+ snprintf(cmd, sizeof(cmd), "%s -D FORWARD "FORWARD_RULE,
+ IPTABLES, src, dest);
+ DBG("REMOVE IPTABLES RULE : %s\n", cmd);
+ if (_execute_command(cmd)) {
+ ERR("iptables failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ snprintf(cmd, sizeof(cmd), "%s -D FORWARD "FORWARD_RULE,
+ IPTABLES, dest, src);
+ DBG("REMOVE IPTABLES RULE : %s\n", cmd);
+ if (_execute_command(cmd)) {
+ ERR("iptables failed : %s\n", cmd);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _get_data_usage(const char *src, const char *dest,
+ unsigned long long *tx, unsigned long long *rx)
+{
+ if (src == NULL || src[0] == '\0' ||
+ dest == NULL || dest[0] == '\0' ||
+ tx == NULL || rx == NULL) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ char cmd[MAX_BUF_SIZE] = {0, };
+ char buf[MAX_BUF_SIZE] = {0, };
+ FILE *fp = NULL;
+
+ /* Tx : Src. -> Dest. */
+ snprintf(cmd, sizeof(cmd),
+ "%s -L FORWARD -vx | %s \"%s[ ]*%s\" | %s '{ print $2 }' > %s",
+ IPTABLES, GREP, src, dest, AWK, DATA_USAGE_FILE);
+ DBG("GET DATA USAGE : %s\n", cmd);
+ if (system(cmd) < 0) {
+ ERR("\"cmd\" is failed\n");
+ }
+
+ /* Rx : Dest. -> Src. */
+ snprintf(cmd, sizeof(cmd),
+ "%s -L FORWARD -vx | %s \"%s[ ]*%s\" | %s '{ print $2 }' >> %s",
+ IPTABLES, GREP, dest, src, AWK, DATA_USAGE_FILE);
+ DBG("GET DATA USAGE : %s\n", cmd);
+ if (system(cmd) < 0) {
+ ERR("\"cmd\" is failed\n");
+ }
+
+ fp = fopen(DATA_USAGE_FILE, "r");
+ if (fp == NULL) {
+ ERR("%s open failed\n", DATA_USAGE_FILE);
+ ERR("%s\n", strerror(errno));
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ if (fgets(buf, sizeof(buf), fp) == NULL)
+ *tx = 0LL;
+ else
+ *tx = atoll(buf);
+ DBG("Tx(%s -> %s) : %llu\n", src, dest, *tx);
+
+ if (fgets(buf, sizeof(buf), fp) == NULL)
+ *rx = 0LL;
+ else
+ *rx = atoll(buf);
+ DBG("Rx(%s -> %s) : %llu\n", dest, src, *rx);
+
+ fclose(fp);
+ unlink(DATA_USAGE_FILE);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+int _execute_command(const char *cmd)
+{
+ if (cmd == NULL) {
+ ERR("Invalid param\n");
+ return EXIT_FAILURE;
+ }
+
+ int status = 0;
+ int exit_status = 0;
+ pid_t pid = 0;
+ gchar **args = NULL;
+
+ DBG("cmd : %s\n", cmd);
+
+ args = g_strsplit_set(cmd, " ", -1);
+ if (!args) {
+ ERR("g_strsplit_set failed\n");
+ return EXIT_FAILURE;
+ }
+
+ if ((pid = fork()) < 0) {
+ ERR("fork failed\n");
+ return EXIT_FAILURE;
+ }
+
+ if (!pid) {
+ if (execv(args[0], args)) {
+ ERR("execl failed\n");
+ }
+
+ ERR("Should never get here!\n");
+ return EXIT_FAILURE;
+ } else {
+ DBG("child pid : %d\n", pid);
+
+ /* Need to add timeout */
+ waitpid(pid, &status, 0);
+ g_strfreev(args);
+
+ if (WIFEXITED(status)) {
+ exit_status = WEXITSTATUS(status);
+ if (exit_status) {
+ ERR("child return : %d\n", exit_status);
+ return EXIT_FAILURE;
+ }
+ DBG("child terminated normally\n");
+ return EXIT_SUCCESS;
+ } else {
+ ERR("child is terminated without exit\n");
+ return EXIT_FAILURE;
+ }
+ }
+}
+
+int _get_tethering_type_from_ip(const char *ip, mobile_ap_type_e *type)
+{
+ if (ip == NULL || type == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ static gboolean is_init = FALSE;
+ static in_addr_t subnet_wifi;
+ static in_addr_t subnet_bt_min;
+ static in_addr_t subnet_bt_max;
+ static in_addr_t subnet_usb;
+
+ struct in_addr addr;
+ in_addr_t subnet;
+
+ if (inet_aton(ip, &addr) == 0) {
+ ERR("Address : %s is invalid\n", ip);
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+ subnet = inet_netof(addr);
+
+ if (is_init == FALSE) {
+ addr.s_addr = htonl(IP_ADDRESS_WIFI);
+ subnet_wifi = inet_netof(addr);
+
+ addr.s_addr = htonl(IP_ADDRESS_BT_1);
+ subnet_bt_min = inet_netof(addr);
+
+ addr.s_addr = htonl(IP_ADDRESS_BT_7);
+ subnet_bt_max = inet_netof(addr);
+
+ addr.s_addr = htonl(IP_ADDRESS_USB);
+ subnet_usb = inet_netof(addr);
+ is_init = TRUE;
+ }
+
+ if (subnet == subnet_wifi) {
+ *type = MOBILE_AP_TYPE_WIFI;
+ return MOBILE_AP_ERROR_NONE;
+ } else if (subnet >= subnet_bt_min && subnet <= subnet_bt_max) {
+ *type = MOBILE_AP_TYPE_BT;
+ return MOBILE_AP_ERROR_NONE;
+ } else if (subnet == subnet_usb) {
+ *type = MOBILE_AP_TYPE_USB;
+ return MOBILE_AP_ERROR_NONE;
+ }
+
+ ERR("Tethering type cannot be decided from %s\n", ip);
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+}
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "mobileap_agent.h"
+#include "mobileap_common.h"
+#include "mobileap_bluetooth.h"
+#include "mobileap_wifi.h"
+#include "mobileap_usb.h"
+
+
+static void __handle_flight_mode_changed_cb(keynode_t *key, void *data)
+{
+ if (key == NULL) {
+ ERR("Parameter is NULL\n");
+ return;
+ }
+
+ MobileAPObject *obj = (MobileAPObject *)data;
+ int vconf_key = 0;
+
+ if (_mobileap_is_disabled()) {
+ DBG("Tethering is not enabled\n");
+ return;
+ }
+
+ if (vconf_keynode_get_type(key) != VCONF_TYPE_BOOL) {
+ ERR("Invalid vconf key type\n");
+ return;
+ }
+
+ vconf_key = vconf_keynode_get_bool(key);
+ DBG("key = %s, value = %d(bool)\n",
+ vconf_keynode_get_name(key), vconf_key);
+
+ if (vconf_key == FALSE) {
+ DBG("Flight mode is turned off\n");
+ return;
+ }
+
+ DBG("Flight mode\n");
+ _disable_wifi_tethering(obj);
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_FLIGHT_MODE, NULL);
+
+ return;
+}
+
+
+static void __handle_device_name_changed_cb(keynode_t *key, void *data)
+{
+ if (key == NULL || data == NULL) {
+ ERR("Parameter is NULL\n");
+ return;
+ }
+
+ MobileAPObject *obj = (MobileAPObject *)data;
+ char *vconf_key = NULL;
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_WIFI)) {
+ DBG("Wi-Fi hotspot is not enabled\n");
+ return;
+ }
+
+ if (vconf_keynode_get_type(key) != VCONF_TYPE_STRING) {
+ ERR("Invalid vconf key type\n");
+ return;
+ }
+
+ vconf_key = vconf_keynode_get_str(key);
+ DBG("key = %s, value = %s(str)\n",
+ vconf_keynode_get_name(key), vconf_key);
+
+ if (g_strcmp0(vconf_key, obj->ssid) == 0) {
+ DBG("ssid is not changed\n");
+ } else {
+ DBG("ssid is changed\n");
+ _disable_wifi_tethering(obj);
+ }
+
+ return;
+}
+
+
+
+
+void _register_vconf_cb(void *user_data)
+{
+ if (user_data == NULL) {
+ ERR("Invalid param\n");
+ return;
+ }
+
+ vconf_reg_t vconf_reg[] = {
+ {VCONFKEY_SETAPPL_FLIGHT_MODE_BOOL,
+ __handle_flight_mode_changed_cb, NULL},
+ {VCONFKEY_SETAPPL_DEVICE_NAME_STR,
+ __handle_device_name_changed_cb, NULL},
+ {NULL, NULL, NULL}
+ };
+
+ int i = 0;
+ int ret = 0;
+
+ while (vconf_reg[i].key != NULL && vconf_reg[i].cb != NULL) {
+ DBG("Register [%d] : %s\n", i, vconf_reg[i].key);
+ ret = vconf_notify_key_changed(vconf_reg[i].key,
+ vconf_reg[i].cb, user_data);
+ if (ret != 0) {
+ ERR("vconf_notify_key_changed is failed : %d\n", ret);
+ }
+
+ if (vconf_reg[i].value) {
+ ret = vconf_get_int(vconf_reg[i].key,
+ vconf_reg[i].value);
+ if (ret != 0) {
+ ERR("vconf_get_int is failed : %d\n", ret);
+ }
+ }
+
+ i++;
+ }
+
+ return;
+}
+
+void _unregister_vconf_cb(void *user_data)
+{
+ if (user_data == NULL) {
+ ERR("Invalid param\n");
+ return;
+ }
+
+ vconf_reg_t vconf_reg[] = {
+ {VCONFKEY_SETAPPL_FLIGHT_MODE_BOOL,
+ __handle_flight_mode_changed_cb, NULL},
+ {VCONFKEY_SETAPPL_DEVICE_NAME_STR,
+ __handle_device_name_changed_cb, NULL},
+ {NULL, NULL, NULL}
+ };
+
+ int i = 0;
+ int ret = 0;
+
+ while (vconf_reg[i].key != NULL && vconf_reg[i].cb != NULL) {
+ DBG("Register [%d] : %s\n", i, vconf_reg[i].key);
+ ret = vconf_ignore_key_changed(vconf_reg[i].key,
+ vconf_reg[i].cb);
+ if (ret != 0) {
+ ERR("vconf_notify_key_changed is failed : %d\n", ret);
+ }
+
+ i++;
+ }
+
+ return;
+}
+
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <pmapi.h>
+#include <vconf.h>
+#include <net_connection.h>
+
+#include "mobileap_agent.h"
+#include "mobileap_handler.h"
+#include "mobileap_common.h"
+#include "mobileap_bluetooth.h"
+#include "mobileap_wifi.h"
+#include "mobileap_usb.h"
+#include "mobileap_network.h"
+
+GType mobileap_object_get_type(void);
+#define MOBILEAP_TYPE_OBJECT (mobileap_object_get_type())
+G_DEFINE_TYPE(MobileAPObject, mobileap_object, G_TYPE_OBJECT)
+
+GMainLoop *mainloop = NULL;
+int mobileap_state = MOBILE_AP_STATE_NONE;
+DBusConnection *mobileap_conn = NULL;
+
+gboolean mobileap_deinit(MobileAPObject *obj, GError **error);
+gboolean mobileap_disable(MobileAPObject *obj, DBusGMethodInvocation *context);
+gboolean mobileap_get_station_info(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+gboolean mobileap_get_data_packet_usage(MobileAPObject *obj,
+ DBusGMethodInvocation *context);
+#include "mobileap-server-stub.h"
+
+static void mobileap_object_init(MobileAPObject *obj)
+{
+ DBG("+\n");
+ g_assert(obj != NULL);
+
+ obj->bt_context = NULL;
+ obj->usb_context = NULL;
+ obj->bt_device = NULL;
+ obj->rx_bytes = 0;
+ obj->tx_bytes = 0;
+ obj->transfer_check_count = 0;
+}
+
+static void mobileap_object_finalize(GObject *obj)
+{
+ DBG("+\n");
+
+ G_OBJECT_CLASS(mobileap_object_parent_class)->finalize(obj);
+}
+
+static void mobileap_object_class_init(MobileAPObjectClass *klass)
+{
+ GObjectClass *object_class = (GObjectClass *)klass;
+ const gchar *signalNames[E_SIGNAL_MAX] = {
+ SIGNAL_NAME_NET_CLOSED,
+ SIGNAL_NAME_STA_CONNECT,
+ SIGNAL_NAME_STA_DISCONNECT,
+ SIGNAL_NAME_WIFI_TETHER_ON,
+ SIGNAL_NAME_WIFI_TETHER_OFF,
+ SIGNAL_NAME_USB_TETHER_ON,
+ SIGNAL_NAME_USB_TETHER_OFF,
+ SIGNAL_NAME_BT_TETHER_ON,
+ SIGNAL_NAME_BT_TETHER_OFF,
+ SIGNAL_NAME_NO_DATA_TIMEOUT,
+ SIGNAL_NAME_LOW_BATTERY_MODE,
+ SIGNAL_NAME_FLIGHT_MODE
+ };
+
+ int i = 0;
+
+ g_assert(klass != NULL);
+
+ object_class->finalize = mobileap_object_finalize;
+
+ DBG("Creating signals\n");
+
+ for (i = 0; i < E_SIGNAL_MAX; i++) {
+ guint signalId;
+
+ signalId = g_signal_new(signalNames[i],
+ G_OBJECT_CLASS_TYPE(klass),
+ G_SIGNAL_RUN_LAST,
+ 0, NULL, NULL,
+ g_cclosure_marshal_VOID__STRING,
+ G_TYPE_NONE, 1, G_TYPE_STRING);
+ klass->signals[i] = signalId;
+ }
+
+ DBG("Binding to GLib/D-Bus\n");
+
+ dbus_g_object_type_install_info(MOBILEAP_TYPE_OBJECT,
+ &dbus_glib_mobileap_object_info);
+}
+
+static void __add_station_info_to_array(gpointer data, gpointer user_data)
+{
+ mobile_ap_station_info_t *si = (mobile_ap_station_info_t *)data;
+ GPtrArray *array = (GPtrArray *)user_data;
+ GValue value = {0, {{0}}};
+
+ g_value_init(&value, DBUS_STRUCT_STATIONS);
+ g_value_take_boxed(&value,
+ dbus_g_type_specialized_construct(DBUS_STRUCT_STATIONS));
+ dbus_g_type_struct_set(&value, 0, si->interface, 1, si->ip,
+ 2, si->mac, 3, si->hostname, G_MAXUINT);
+ g_ptr_array_add(array, g_value_get_boxed(&value));
+}
+
+gboolean _mobileap_set_state(int state)
+{
+ int vconf_ret = 0;
+
+ DBG("Before mobileap_state : %d\n", mobileap_state);
+ mobileap_state |= state;
+ DBG("After mobileap_state : %d\n", mobileap_state);
+
+ vconf_ret = vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_MODE, mobileap_state);
+ if (vconf_ret != 0) {
+ ERR("vconf_set_int is failed : %d\n", vconf_ret);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+int _mobileap_is_disabled(void)
+{
+ return !mobileap_state;
+}
+
+int _mobileap_is_enabled(int state)
+{
+ return (mobileap_state & state) ? 1 : 0;
+}
+
+gboolean _mobileap_clear_state(int state)
+{
+ int vconf_ret = 0;
+
+ DBG("Before mobileap_state : %d\n", mobileap_state);
+ mobileap_state &= (~state);
+ DBG("After mobileap_state : %d\n", mobileap_state);
+
+ vconf_ret = vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_MODE, mobileap_state);
+ if (vconf_ret != 0) {
+ ERR("vconf_set_int is failed : %d\n", vconf_ret);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void __block_device_sleep(void)
+{
+ int ret = 0;
+
+ ret = pm_lock_state(LCD_OFF, STAY_CUR_STATE, 0);
+ if (ret < 0)
+ ERR("PM control [ERROR] result = %d\n", ret);
+ else
+ DBG("PM control [SUCCESS]\n");
+}
+
+static void __unblock_device_sleep(void)
+{
+ int ret = 0;
+
+ ret = pm_unlock_state(LCD_OFF, PM_SLEEP_MARGIN);
+ if (ret < 0)
+ ERR("PM control [ERROR] result = %d\n", ret);
+ else
+ DBG("PM control [SUCCESS]\n");
+}
+
+gboolean _init_tethering(MobileAPObject *obj)
+{
+ DBG("obj->init_count: %d\n", obj->init_count);
+
+ if (obj->init_count > 0) {
+ DBG("Already env. is initialized for tethering: %d\n",
+ obj->init_count);
+ obj->init_count++;
+ return TRUE;
+ }
+
+ obj->init_count++;
+
+ DBG("Set masquerading / Run DHCP\n");
+ __block_device_sleep();
+
+ _open_network();
+
+ _mh_core_execute_dhcp_server();
+
+ return TRUE;
+}
+
+gboolean _deinit_tethering(MobileAPObject *obj)
+{
+ DBG("obj->init_count: %d\n", obj->init_count);
+
+ if (obj->init_count > 1) {
+ DBG("Already deinitialized\n");
+ obj->init_count--;
+ return TRUE;
+ } else if (obj->init_count <= 0) {
+ ERR("Already deinitialized\n");
+ obj->init_count = 0;
+ return TRUE;
+ }
+
+ obj->init_count = 0;
+
+ DBG("Terminate DHCP / IPTABLES\n");
+ _mh_core_terminate_dhcp_server();
+ _close_network();
+ __unblock_device_sleep();
+
+ return TRUE;
+}
+
+
+gboolean mobileap_deinit(MobileAPObject *obj, GError **error)
+{
+ DBG("+\n");
+ g_assert(obj != NULL);
+
+ if (_mobileap_is_disabled()) {
+ DBG("Mobile AP is not activated, so we quit the mobileap-agent.\n");
+ g_main_loop_quit(mainloop);
+ }
+
+ return TRUE;
+}
+
+gboolean mobileap_disable(MobileAPObject *obj, DBusGMethodInvocation *context)
+{
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ if (_mobileap_is_disabled()) {
+ ERR("Mobile hotspot has not been enabled\n");
+ ret = MOBILE_AP_ERROR_NOT_ENABLED;
+ dbus_g_method_return(context, MOBILE_AP_DISABLE_CFM, ret);
+ return FALSE;
+ }
+
+ _disable_wifi_tethering(obj);
+ _disable_bt_tethering(obj);
+ _disable_usb_tethering(obj);
+
+ dbus_g_method_return(context, MOBILE_AP_DISABLE_CFM, ret);
+
+ return TRUE;
+}
+
+gboolean mobileap_get_station_info(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ DBG("+\n");
+
+ GPtrArray *array = g_ptr_array_new();
+
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ _station_info_foreach(__add_station_info_to_array, array);
+
+ dbus_g_method_return(context, MOBILE_AP_GET_STATION_INFO_CFM, array);
+ g_ptr_array_free(array, TRUE);
+
+ DBG("-\n");
+
+ return TRUE;
+}
+
+gboolean mobileap_get_data_packet_usage(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ char *if_name = NULL;
+ unsigned long long wifi_tx_bytes = 0;
+ unsigned long long wifi_rx_bytes = 0;
+ unsigned long long bt_tx_bytes = 0;
+ unsigned long long bt_rx_bytes = 0;
+ unsigned long long usb_tx_bytes = 0;
+ unsigned long long usb_rx_bytes = 0;
+ unsigned long long tx_bytes = 0;
+ unsigned long long rx_bytes = 0;
+
+ if (_get_network_interface_name(&if_name) == FALSE) {
+ ERR("No network interface\n");
+ dbus_g_method_return(context, MOBILE_AP_GET_DATA_PACKET_USAGE_CFM,
+ 0, 0);
+ return FALSE;
+ }
+
+ if (_mobileap_is_enabled(MOBILE_AP_STATE_WIFI))
+ _get_data_usage(WIFI_IF, if_name,
+ &wifi_tx_bytes, &wifi_rx_bytes);
+
+ if (_mobileap_is_enabled(MOBILE_AP_STATE_BT))
+ _get_data_usage(BT_IF_ALL, if_name,
+ &bt_tx_bytes, &bt_rx_bytes);
+
+ if (_mobileap_is_enabled(MOBILE_AP_STATE_USB))
+ _get_data_usage(USB_IF, if_name,
+ &usb_tx_bytes, &usb_rx_bytes);
+ free(if_name);
+
+ tx_bytes = wifi_tx_bytes + bt_tx_bytes + usb_tx_bytes;
+ rx_bytes = wifi_rx_bytes + bt_rx_bytes + usb_rx_bytes;
+
+ dbus_g_method_return(context, MOBILE_AP_GET_DATA_PACKET_USAGE_CFM,
+ tx_bytes, rx_bytes);
+
+ return TRUE;
+}
+
+
+static void __reset_interface(MobileAPObject *obj)
+{
+ obj->rx_bytes = 0;
+ obj->tx_bytes = 0;
+ obj->transfer_check_count = 0;
+}
+
+
+static gboolean __check_data_transfer_cb(gpointer data)
+{
+ MobileAPObject *obj = (MobileAPObject *)data;
+ GIOChannel *io = NULL;
+ gchar *line = NULL;
+
+ char *if_name = NULL;
+ gchar iface[IF_BUF_LEN] = {0, };
+ unsigned long long rx_bytes = 0;
+ unsigned long long tx_bytes = 0;
+
+ if (_mobileap_is_disabled()) {
+ ERR("Nothing is to be done.\n");
+ return TRUE;
+ }
+
+ if (_get_network_interface_name(&if_name) == FALSE)
+ return TRUE;
+
+ io = g_io_channel_new_file(PROC_NET_DEV, "r", NULL);
+ if (!io) {
+ ERR("g_io_channel_new_file failed\n");
+ return TRUE;
+ }
+
+ while (g_io_channel_read_line(io, &line, NULL, NULL, NULL) == G_IO_STATUS_NORMAL) {
+
+ line = g_strdelimit(line, ":", ' ');
+ sscanf(line, "%29s %19lld %*s %*s %*s %*s %*s %*s %*s %19lld %*s %*s %*s %*s %*s",
+ iface, &rx_bytes, &tx_bytes);
+
+ g_free(line);
+
+ if (g_ascii_strcasecmp(iface, if_name) == 0) {
+ break;
+ }
+ }
+
+ g_io_channel_unref(io);
+ free(if_name);
+
+ /*DBG("rx:%lld tx:%lld\n", rx_bytes, tx_bytes);*/
+ if (obj->rx_bytes < rx_bytes || obj->tx_bytes < tx_bytes) {
+ obj->rx_bytes = rx_bytes;
+ obj->tx_bytes = tx_bytes;
+ obj->transfer_check_count = 0;
+ } else {
+ obj->transfer_check_count++;
+
+ /* 30 minutes */
+ if (obj->transfer_check_count == MAX_TRANSFER_CHECK_COUNT) {
+ _emit_mobileap_dbus_signal(obj,
+ E_SIGNAL_NO_DATA_TIMEOUT, NULL);
+ __reset_interface(obj);
+ _disable_wifi_tethering(obj);
+ }
+ }
+
+ return TRUE;
+}
+
+
+static DBusHandlerResult __dnsmasq_signal_filter(DBusConnection *conn,
+ DBusMessage *msg, void *user_data)
+{
+ if (!user_data) {
+ ERR("Invalid param\n");
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ char *ip_addr = NULL;
+ char *mac = NULL;
+ char *name = NULL;
+ char *bt_remote_device_name = NULL;
+ DBusError error;
+ mobile_ap_type_e type = MOBILE_AP_TYPE_MAX;
+ MobileAPObject *obj = (MobileAPObject *)user_data;
+ mobile_ap_station_info_t *info = NULL;
+
+ dbus_error_init(&error);
+ if (dbus_message_is_signal(msg, DNSMASQ_DBUS_INTERFACE,
+ "DhcpConnected")) {
+ if (!dbus_message_get_args(msg, &error,
+ DBUS_TYPE_STRING, &ip_addr,
+ DBUS_TYPE_STRING, &mac,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID)) {
+ ERR("Cannot read message, cause: %s\n", error.message);
+ dbus_error_free(&error);
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ DBG("DhcpConnected signal : %s %s %s\n", ip_addr, mac, name);
+
+ if (_get_tethering_type_from_ip(ip_addr, &type) != MOBILE_AP_ERROR_NONE)
+ return DBUS_HANDLER_RESULT_HANDLED;
+
+ info = (mobile_ap_station_info_t *)malloc(sizeof(mobile_ap_station_info_t));
+ if (info == NULL) {
+ ERR("malloc failed\n");
+ return DBUS_HANDLER_RESULT_HANDLED;
+ }
+
+ info->interface = type;
+ g_strlcpy(info->ip, ip_addr, sizeof(info->ip));
+ g_strlcpy(info->mac, mac, sizeof(info->mac));
+ if (type == MOBILE_AP_TYPE_WIFI || type == MOBILE_AP_TYPE_USB) {
+ if (name[0] == '\0')
+ g_strlcpy(info->hostname,
+ MOBILE_AP_NAME_UNKNOWN,
+ sizeof(info->hostname));
+ else
+ g_strlcpy(info->hostname, name,
+ sizeof(info->hostname));
+ } else if (type == MOBILE_AP_TYPE_BT) {
+ _bt_get_remote_device_name(obj, mac, &bt_remote_device_name);
+ if (bt_remote_device_name == NULL)
+ g_strlcpy(info->hostname,
+ MOBILE_AP_NAME_UNKNOWN,
+ sizeof(info->hostname));
+ else {
+ g_strlcpy(info->hostname, bt_remote_device_name,
+ sizeof(info->hostname));
+ free(bt_remote_device_name);
+ }
+ }
+
+ _add_station_info(info);
+ _send_dbus_station_info("DhcpConnected", info);
+
+ return DBUS_HANDLER_RESULT_HANDLED;
+ } else if (dbus_message_is_signal(msg, DNSMASQ_DBUS_INTERFACE,
+ "DhcpLeaseDeleted")) {
+ if (!dbus_message_get_args(msg, &error,
+ DBUS_TYPE_STRING, &ip_addr,
+ DBUS_TYPE_STRING, &mac,
+ DBUS_TYPE_STRING, &name,
+ DBUS_TYPE_INVALID)) {
+ ERR("Cannot read message, cause: %s\n", error.message);
+ dbus_error_free(&error);
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+ }
+
+ DBG("DhcpLeaseDeleted signal : %s %s %s\n", ip_addr, mac, name);
+
+ _remove_station_info(mac, _slist_find_station_by_mac);
+
+ return DBUS_HANDLER_RESULT_HANDLED;
+ }
+
+ return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
+}
+
+int main(int argc, char **argv)
+{
+ MobileAPObject *mobileap_obj = NULL;
+ DBusError dbus_error;
+ char *rule = "type='signal',interface='"DNSMASQ_DBUS_INTERFACE"'";
+ DBusGConnection *mobileap_bus = NULL;
+ DBusGProxy *mobileap_bus_proxy = NULL;
+ guint result = 0;
+ GError *error = NULL;
+ int mobileap_vconf_key = VCONFKEY_MOBILE_HOTSPOT_MODE_NONE;
+
+ g_type_init();
+
+ if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &mobileap_vconf_key)) {
+ ERR("vconf_get_int FAIL\n");
+ mobileap_state = MOBILE_AP_STATE_NONE;
+ } else {
+ ERR("vconf_get_int OK(mobileap_vconf_key value is %d)\n",
+ mobileap_vconf_key);
+ mobileap_state = mobileap_vconf_key;
+ }
+
+ mainloop = g_main_loop_new(NULL, FALSE);
+ if (mainloop == NULL) {
+ ERR("Couldn't create GMainLoop\n");
+ goto failure;
+ }
+
+ mobileap_bus = dbus_g_bus_get(DBUS_BUS_SYSTEM, &error);
+ if (error != NULL) {
+ ERR("Couldn't connect to system bus[%s]\n", error->message);
+ goto failure;
+ }
+
+ mobileap_conn = dbus_g_connection_get_connection(mobileap_bus);
+
+ DBG("Registering the well-known name (%s)\n", SOFTAP_SERVICE_NAME);
+
+ mobileap_bus_proxy = dbus_g_proxy_new_for_name(mobileap_bus,
+ DBUS_SERVICE_DBUS, DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
+ if (mobileap_bus_proxy == NULL) {
+ ERR("Failed to get a proxy for D-Bus\n");
+ goto failure;
+ }
+
+ if (!dbus_g_proxy_call(mobileap_bus_proxy,
+ "RequestName",
+ &error,
+ G_TYPE_STRING,
+ SOFTAP_SERVICE_NAME,
+ G_TYPE_UINT, 0, G_TYPE_INVALID, G_TYPE_UINT, &result, G_TYPE_INVALID)) {
+ ERR("D-Bus.RequestName RPC failed[%s]\n", error->message);
+ goto failure;
+ }
+
+ if (result != 1) {
+ ERR("Failed to get the primary well-known name.\n");
+ goto failure;
+ }
+
+ g_object_unref(mobileap_bus_proxy);
+ mobileap_bus_proxy = NULL;
+
+ mobileap_obj = g_object_new(MOBILEAP_TYPE_OBJECT, NULL);
+ if (mobileap_obj == NULL) {
+ ERR("Failed to create one MobileAP instance.\n");
+ goto failure;
+ }
+
+ /* Registering it on the D-Bus */
+ dbus_g_connection_register_g_object(mobileap_bus,
+ SOFTAP_SERVICE_OBJECT_PATH, G_OBJECT(mobileap_obj));
+
+ DBG("Ready to serve requests.\n");
+
+ _init_network(NULL);
+ _register_wifi_station_handler();
+ _register_vconf_cb((void *)mobileap_obj);
+
+ /* check tx/rx every 10 seconds */
+ g_timeout_add(10000, __check_data_transfer_cb, mobileap_obj);
+
+ dbus_error_init(&dbus_error);
+ dbus_bus_add_match(mobileap_conn, rule, &dbus_error);
+ if (dbus_error_is_set(&dbus_error)) {
+ ERR("Cannot add D-BUS match rule, cause: %s", dbus_error.message);
+ dbus_error_free(&dbus_error);
+ goto failure;
+ }
+
+ DBG("Listening to D-BUS signals from dnsmasq");
+ dbus_connection_add_filter(mobileap_conn, __dnsmasq_signal_filter, mobileap_obj, NULL);
+
+ g_main_loop_run(mainloop);
+
+ _unregister_vconf_cb((void *)mobileap_obj);
+ _deinit_network();
+
+ failure:
+ ERR("Terminate the mobileap-agent\n");
+
+ if (mobileap_bus)
+ dbus_g_connection_unref(mobileap_bus);
+ if (mobileap_bus_proxy)
+ g_object_unref(mobileap_bus_proxy);
+ if (mobileap_obj)
+ g_object_unref(mobileap_obj);
+
+ return 0;
+}
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdlib.h>
+
+#include "mobileap_agent.h"
+#include "mobileap_network.h"
+
+static connection_h connection = NULL;
+static connection_profile_h cprof = NULL;
+
+static void __print_profile(connection_profile_h profile)
+{
+#define __check_connection_return(conn_ret) \
+ do { \
+ if (conn_ret != CONNECTION_ERROR_NONE) \
+ ERR("connection API fail : 0x%X\n", conn_ret); \
+ } while(0)
+
+ if (profile == NULL)
+ return;
+
+ int conn_ret;
+ bool roaming;
+ char *apn;
+ char *user_name;
+ char *password;
+ char *home_url;
+ connection_cellular_network_type_e network_type;
+ connection_cellular_service_type_e service_type;
+ connection_cellular_auth_type_e auth_type;
+
+ conn_ret = connection_profile_get_cellular_network_type(profile, &network_type);
+ __check_connection_return(conn_ret);
+ DBG("Network type : %d\n", network_type);
+
+ conn_ret = connection_profile_get_cellular_service_type(profile, &service_type);
+ __check_connection_return(conn_ret);
+ DBG("Service type : %d\n", service_type);
+
+ conn_ret = connection_profile_get_cellular_apn(profile, &apn);
+ __check_connection_return(conn_ret);
+ DBG("APN : %s\n", apn);
+ free(apn);
+
+ conn_ret = connection_profile_get_cellular_auth_info(profile, &auth_type,
+ &user_name, &password);
+ __check_connection_return(conn_ret);
+ DBG("Auth type : %d\n", auth_type);
+ DBG("User name : %s\n", user_name);
+ DBG("Password : %s\n", password);
+ free(user_name);
+ free(password);
+
+ conn_ret = connection_profile_get_cellular_home_url(profile, &home_url);
+ __check_connection_return(conn_ret);
+ DBG("Home url : %s\n", home_url);
+ free(home_url);
+
+ conn_ret = connection_profile_is_cellular_roaming(profile, &roaming);
+ __check_connection_return(conn_ret);
+ DBG("Roaming : %d\n", roaming);
+
+#undef __check_connection_return
+ return;
+}
+
+static void __connection_opened_cb(connection_error_e result, void *user_data)
+{
+ if (cprof == NULL) {
+ ERR("Current profile is not set\n");
+ return;
+ }
+
+ if (result != CONNECTION_ERROR_NONE) {
+ ERR("connection open is failed : 0x%X\n", result);
+ connection_profile_destroy(cprof);
+ cprof = NULL;
+ return;
+ }
+
+ if (_mobileap_is_disabled()) {
+ _close_network();
+ return;
+ }
+
+ if (_set_masquerade() == FALSE) {
+ ERR("_set_masquerade is failed\n");
+ _close_network();
+ return;
+ }
+
+ return;
+}
+
+static void __connection_closed_cb(connection_error_e result, void *user_data)
+{
+ if (result != CONNECTION_ERROR_NONE)
+ ERR("Connection close is failed : 0x%X\n", result);
+ else
+ DBG("Connection is closed\n");
+
+ connection_profile_destroy(cprof);
+ cprof = NULL;
+
+ return;
+}
+
+static gboolean __get_connected_prof(connection_profile_h *r_prof, connection_profile_type_e *r_net_type)
+{
+ int conn_ret;
+ connection_profile_h profile = NULL;
+ connection_profile_type_e net_type = CONNECTION_PROFILE_TYPE_CELLULAR;
+
+ conn_ret = connection_get_current_profile(connection, &profile);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_get_current_profile is failed : %d\n", conn_ret);
+ return FALSE;
+ }
+
+ conn_ret = connection_profile_get_type(profile, &net_type);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_profile_get_type is failed : 0x%X\n", conn_ret);
+ connection_profile_destroy(profile);
+ return FALSE;
+ }
+
+ *r_prof = profile;
+ *r_net_type = net_type;
+
+ return TRUE;
+}
+
+static gboolean __is_tethering_cellular_prof(connection_profile_h profile)
+{
+ int conn_ret;
+ connection_cellular_service_type_e svc_type;
+
+ conn_ret = connection_profile_get_cellular_service_type(profile, &svc_type);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_profile_get_cellular_service_type is failed : 0x%X\n", conn_ret);
+ return FALSE;
+ }
+
+ if (svc_type != CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING)
+ return FALSE;
+
+ return TRUE;
+}
+
+static gboolean __get_tethering_cellular_prof(connection_profile_h *profile, gboolean *is_connected)
+{
+ int conn_ret;
+ connection_profile_state_e pstat = CONNECTION_PROFILE_STATE_DISCONNECTED;
+
+ conn_ret = connection_get_default_cellular_service_profile(connection,
+ CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING, profile);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("There is no tethering profile : 0x%X\n", conn_ret);
+ return FALSE;
+ }
+
+ conn_ret = connection_profile_get_state(*profile, &pstat);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_profile_get_state is failed : 0x%X\n", conn_ret);
+ connection_profile_destroy(*profile);
+ return FALSE;
+ }
+
+ if (pstat != CONNECTION_PROFILE_STATE_CONNECTED)
+ *is_connected = FALSE;
+ else
+ *is_connected = TRUE;
+
+ return TRUE;
+}
+
+static gboolean __get_network_prof(connection_profile_h *r_prof, gboolean *is_connected)
+{
+ connection_profile_h profile;
+ connection_profile_h tether_prof;
+ connection_profile_type_e net_type = CONNECTION_PROFILE_TYPE_CELLULAR;
+
+ if (__get_connected_prof(&profile, &net_type) != TRUE) {
+ ERR("There is no available network\n");
+ return FALSE;
+ }
+
+ if (net_type == CONNECTION_PROFILE_TYPE_CELLULAR) {
+ if (__is_tethering_cellular_prof(profile) == TRUE)
+ goto DONE;
+
+ if (__get_tethering_cellular_prof(&tether_prof, is_connected) == FALSE) {
+ DBG("There is no tethering service cellular\n");
+ goto DONE;
+ }
+ connection_profile_destroy(profile);
+
+ *r_prof = tether_prof;
+ return TRUE;
+ }
+
+DONE:
+ *r_prof = profile;
+ *is_connected = TRUE;
+ return TRUE;
+}
+
+static void __connection_type_changed_cb(connection_type_e type, void *user_data)
+{
+ if (_mobileap_is_disabled()) {
+ DBG("Tethering is not enabled\n");
+ return;
+ }
+
+ DBG("Changed connection type is %s\n",
+ type == CONNECTION_TYPE_DISCONNECTED ? "DISCONNECTED" :
+ type == CONNECTION_TYPE_WIFI ? "Wi-FI" :
+ type == CONNECTION_TYPE_CELLULAR ? "Cellular" :
+ type == CONNECTION_TYPE_ETHERNET ? "Ethernet" :
+ "Unknown");
+
+ _close_network();
+ if (type == CONNECTION_TYPE_DISCONNECTED)
+ return;
+
+ _open_network();
+ return;
+}
+
+gboolean _get_network_interface_name(char **if_name)
+{
+ int conn_ret = 0;
+
+ if (cprof == NULL)
+ return FALSE;
+
+ conn_ret = connection_profile_get_network_interface_name(cprof, if_name);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_profile_get_network_interface_name is failed : 0x%X\n", conn_ret);
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean _set_masquerade(void)
+{
+ char *if_name = NULL;
+
+ if (_get_network_interface_name(&if_name) == FALSE) {
+ ERR("_get_network_interface_name is failed\n");
+ return FALSE;
+ }
+ DBG("Network interface : %s\n", if_name);
+
+ _mh_core_enable_masquerade(if_name);
+ free(if_name);
+
+ return TRUE;
+}
+
+gboolean _unset_masquerade(void)
+{
+ char *if_name = NULL;
+
+ if (_get_network_interface_name(&if_name) == FALSE) {
+ ERR("_get_network_interface_name is failed\n");
+ return FALSE;
+ }
+ DBG("Network interface : %s\n", if_name);
+
+ _mh_core_disable_masquerade(if_name);
+ free(if_name);
+
+ return TRUE;
+}
+
+gboolean _open_network(void)
+{
+ connection_profile_h profile = NULL;
+ gboolean is_connected = FALSE;
+ int conn_ret;
+
+ if (__get_network_prof(&profile, &is_connected) == FALSE) {
+ ERR("__get_network_prof is failed\n");
+ return FALSE;
+ }
+ cprof = profile;
+
+ if (is_connected == FALSE) {
+ conn_ret = connection_open_profile(connection, cprof,
+ __connection_opened_cb, NULL);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_open_profile is failed : 0x%X\n", conn_ret);
+ connection_profile_destroy(cprof);
+ cprof = NULL;
+ return FALSE;
+ }
+
+ return TRUE;
+ }
+
+ if (_set_masquerade() == FALSE) {
+ ERR("_set_masquerade is failed\n");
+ _close_network();
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean _close_network(void)
+{
+ int conn_ret;
+
+ if (cprof == NULL)
+ return TRUE;
+
+ if (_unset_masquerade() == FALSE)
+ ERR("_unset_masquerade is failed\n");
+
+ if (__is_tethering_cellular_prof(cprof) == TRUE) {
+ conn_ret = connection_close_profile(connection, cprof,
+ __connection_closed_cb, NULL);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_close_profile is failed : 0x%X\n", conn_ret);
+ return FALSE;
+ }
+
+ return TRUE;
+ }
+
+ connection_profile_destroy(cprof);
+ cprof = NULL;
+
+ return TRUE;
+}
+
+gboolean _init_network(void *user_data)
+{
+ int conn_ret;
+
+ conn_ret = connection_create(&connection);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_create is failed : 0x%X\n", conn_ret);
+ return FALSE;
+ }
+
+ conn_ret = connection_set_type_changed_cb(connection,
+ __connection_type_changed_cb, user_data);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_set_type_changed cb is failed : 0x%X\n", conn_ret);
+ connection_destroy(connection);
+ connection = NULL;
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+gboolean _deinit_network(void)
+{
+ int conn_ret;
+
+ if (connection == NULL) {
+ ERR("Connection handle is not initialized\n");
+ return TRUE;
+ }
+
+ conn_ret = connection_unset_type_changed_cb(connection);
+ if (conn_ret != CONNECTION_ERROR_NONE) {
+ ERR("connection_unset_type_changed_cb is failed : %d\n", conn_ret);
+ }
+
+ connection_destroy(connection);
+ connection = NULL;
+
+ return TRUE;
+}
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <stdio.h>
+#include <string.h>
+#include <notification.h>
+
+#include "mobileap_agent.h"
+
+
+#define NOTI_PRIV_ID 0
+
+notification_h _create_notification(void)
+{
+ DBG("+\n");
+ notification_h noti = NULL;
+ notification_error_e ret = NOTIFICATION_ERROR_NONE;
+
+ noti = notification_new(NOTIFICATION_TYPE_NOTI, -1, NOTI_PRIV_ID);
+ if (!noti) {
+ ERR("Fail to notification_new [%d]\n", ret);
+ return NULL;
+ }
+
+ ret = notification_set_property(noti,
+ NOTIFICATION_PROP_DISABLE_AUTO_DELETE | NOTIFICATION_PROP_VOLATILE_DISPLAY);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_set_property [%d]\n", ret);
+ return NULL;
+ }
+
+ DBG("-\n");
+ return noti;
+}
+
+int _insert_notification(notification_h noti,
+ char *title,
+ char *content,
+ char *icon_path)
+{
+ DBG("+\n");
+ notification_error_e ret;
+
+ if (!noti)
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+
+ DBG("Insert noti : %d \n", noti);
+
+ ret = notification_set_image(noti, NOTIFICATION_IMAGE_TYPE_ICON, icon_path);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_set_image [%d]\n", ret);
+ goto error;
+ }
+
+ ret = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_TITLE,
+ title, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_set_text [%d]\n", ret);
+ goto error;
+ }
+
+ ret = notification_set_text(noti, NOTIFICATION_TEXT_TYPE_CONTENT,
+ content, NULL, NOTIFICATION_VARIABLE_TYPE_NONE);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_set_text [%d]\n", ret);
+ goto error;
+ }
+
+ ret = notification_insert(noti, NULL);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_insert [%d]\n", ret);
+ goto error;
+ }
+
+ ret = notification_free(noti);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_free [%d]\n", ret);
+ goto error;
+ }
+
+ DBG("-\n");
+ return ret;
+
+error:
+ return MOBILE_AP_ERROR_INTERNAL;
+}
+
+int _delete_notification(void)
+{
+ DBG("+\n");
+ notification_error_e ret;
+
+ ret = notification_delete_all_by_type(NULL, NOTIFICATION_TYPE_NOTI);
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_delete_all_by_type [%d]\n", ret);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ DBG("-\n");
+ return MOBILE_AP_ERROR_NONE;
+}
+
+
+int _set_notification_app_launch(notification_h noti)
+{
+ DBG("+\n");
+ notification_error_e ret;
+
+ if (!noti)
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+
+ ret = notification_set_application(noti, "org.tizen.tethering");
+ if (ret != NOTIFICATION_ERROR_NONE) {
+ ERR("Fail to notification_set_application [%d]\n", ret);
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ DBG("-\n");
+ return MOBILE_AP_ERROR_NONE;
+}
+
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "mobileap_agent.h"
+#include "mobileap_common.h"
+#include "mobileap_usb.h"
+
+
+static void __handle_usb_disconnect_cb(keynode_t *key, void *data)
+{
+ if (key == NULL || data == NULL) {
+ ERR("Parameter is NULL\n");
+ return;
+ }
+
+ int vconf_key = 0;
+ MobileAPObject *obj = (MobileAPObject *)data;
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_USB)) {
+ ERR("USB tethering is not enabled\n");
+ return;
+ }
+
+ if (vconf_keynode_get_type(key) != VCONF_TYPE_INT) {
+ ERR("Invalid vconf key type\n");
+ return;
+ }
+
+ vconf_key = vconf_keynode_get_int(key);
+ DBG("key = %s, value = %d(int)\n",
+ vconf_keynode_get_name(key), vconf_key);
+
+ if (vconf_key != VCONFKEY_SYSMAN_USB_DISCONNECTED) {
+ return;
+ }
+
+ DBG("USB tethering will be disabled\n");
+
+ _disable_usb_tethering(obj);
+
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_USB_TETHER_OFF,
+ SIGNAL_MSG_NOT_AVAIL_INTERFACE);
+
+ return;
+}
+
+
+
+static void __handle_usb_mode_change(keynode_t *key, void *data)
+{
+ if (key == NULL) {
+ ERR("Parameter is NULL\n");
+ return;
+ }
+
+ MobileAPObject *obj = (MobileAPObject *)data;
+ int vconf_key = 0;
+ int is_usb_enabled = FALSE;
+ unsigned int cfm = 0;
+
+ if (vconf_keynode_get_type(key) != VCONF_TYPE_INT) {
+ ERR("Invalid vconf key\n");
+ return;
+ }
+
+ vconf_key = vconf_keynode_get_int(key);
+ DBG("key = %s, value = %d(int)\n",
+ vconf_keynode_get_name(key), vconf_key);
+
+ is_usb_enabled = _mobileap_is_enabled(MOBILE_AP_STATE_USB);
+ DBG("is_usb_enabled : %d\n", is_usb_enabled);
+
+ if (is_usb_enabled) {
+ if (vconf_key != SETTING_USB_TETHERING_MODE) {
+ DBG("Is progressing for usb mode change\n");
+ return;
+ }
+ DBG("USB tethering is enabled\n");
+ cfm = MOBILE_AP_ENABLE_USB_TETHERING_CFM;
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_USB_TETHER_ON, NULL);
+ } else {
+ if (vconf_key == SETTING_USB_TETHERING_MODE) {
+ DBG("Is progressing for usb mode change\n");
+ return;
+ }
+ DBG("USB tethering is disabled\n");
+ cfm = MOBILE_AP_DISABLE_USB_TETHERING_CFM;
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_USB_TETHER_OFF, NULL);
+ }
+
+ vconf_ignore_key_changed(VCONFKEY_SETAPPL_USB_MODE_INT,
+ __handle_usb_mode_change);
+
+ DBG("cfm : %d\n", cfm);
+ dbus_g_method_return(obj->usb_context, cfm, MOBILE_AP_ERROR_NONE);
+ obj->usb_context = NULL;
+}
+
+
+mobile_ap_error_code_e _disable_usb_tethering(MobileAPObject *obj)
+{
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_USB)) {
+ ERR("USB tethering has not been enabled\n");
+ ret = MOBILE_AP_ERROR_NOT_ENABLED;
+ return ret;
+ }
+
+ _deinit_tethering(obj);
+
+ if (_remove_station_info_all(MOBILE_AP_TYPE_USB) != MOBILE_AP_ERROR_NONE) {
+ ERR("_remove_station_info_all is failed. Ignore it\n");
+ }
+
+ vconf_ignore_key_changed(VCONFKEY_SYSMAN_USB_STATUS,
+ __handle_usb_disconnect_cb);
+
+ _mobileap_clear_state(MOBILE_AP_STATE_USB);
+
+ DBG("_disable_usb_tethering is done\n");
+
+ return ret;
+}
+
+
+
+gboolean mobileap_enable_usb_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ int vconf_ret;
+ int usb_conn = VCONFKEY_SYSMAN_USB_DISCONNECTED;
+ int usb_mode = SETTING_USB_NONE_MODE;
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ DBG("+\n");
+
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+
+ if (_mobileap_is_enabled(MOBILE_AP_STATE_USB)) {
+ ERR("USB tethering is already enabled\n");
+ ret = MOBILE_AP_ERROR_ALREADY_ENABLED;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ vconf_ret = vconf_get_int(VCONFKEY_SYSMAN_USB_STATUS, &usb_conn);
+ if (vconf_ret != 0) {
+ ERR("Error getting vconf\n");
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ if (usb_conn != VCONFKEY_SYSMAN_USB_AVAILABLE) {
+ ERR("USB is not connected\n");
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ if (obj->usb_context) {
+ ERR("USB request is progressing\n");
+ ret = MOBILE_AP_ERROR_IN_PROGRESS;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ if (!_mobileap_set_state(MOBILE_AP_STATE_USB)) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ if (!_init_tethering(obj)) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ vconf_ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usb_mode);
+ if (vconf_ret != 0) {
+ ERR("Error getting vconf\n");
+ _deinit_tethering(obj);
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ vconf_notify_key_changed(VCONFKEY_SYSMAN_USB_STATUS,
+ __handle_usb_disconnect_cb, obj);
+
+ if (usb_mode == SETTING_USB_TETHERING_MODE) {
+ DBG("Don't need to wait for usb-setting\n");
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ } else {
+ obj->usb_context = context;
+ vconf_notify_key_changed(VCONFKEY_SETAPPL_USB_MODE_INT,
+ __handle_usb_mode_change, (void *)obj);
+ }
+
+ DBG("-\n");
+
+ return TRUE;
+
+FAIL:
+ _mobileap_clear_state(MOBILE_AP_STATE_USB);
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ return FALSE;
+}
+
+
+
+gboolean mobileap_disable_usb_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+ int usb_mode = SETTING_USB_NONE_MODE;
+ int vconf_ret = 0;
+
+ DBG("+\n");
+
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ if (obj->usb_context) {
+ ERR("USB request is progressing\n");
+ ret = MOBILE_AP_ERROR_IN_PROGRESS;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_USB_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ ret = _disable_usb_tethering(obj);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ dbus_g_method_return(context,
+ MOBILE_AP_DISABLE_USB_TETHERING_CFM,
+ ret);
+ return FALSE;
+ }
+
+ vconf_ret = vconf_get_int(VCONFKEY_SETAPPL_USB_MODE_INT, &usb_mode);
+ if (vconf_ret != 0) {
+ ERR("Error getting vconf : %d\n", vconf_ret);
+ }
+
+ if (usb_mode != SETTING_USB_TETHERING_MODE) {
+ DBG("Don't need to wait for usb-setting\n");
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_USB_TETHER_ON, NULL);
+ dbus_g_method_return(context,
+ MOBILE_AP_DISABLE_USB_TETHERING_CFM,
+ MOBILE_AP_ERROR_NONE);
+ } else {
+ obj->usb_context = context;
+ vconf_notify_key_changed(VCONFKEY_SETAPPL_USB_MODE_INT,
+ __handle_usb_mode_change, (void *)obj);
+ }
+
+ DBG("-\n");
+ return TRUE;
+}
+
+static void __add_usb_station_info_to_array(GPtrArray *array, mobile_ap_station_info_t *node)
+{
+ GValue value = {0, {{0}}};
+
+ g_value_init(&value, DBUS_STRUCT_STATION);
+ g_value_take_boxed(&value,
+ dbus_g_type_specialized_construct(DBUS_STRUCT_STATION));
+ dbus_g_type_struct_set(&value, 0, node->ip, 1, node->mac,
+ 2, node->hostname, G_MAXUINT);
+ g_ptr_array_add(array, g_value_get_boxed(&value));
+}
+
+gboolean mobileap_get_usb_station_info(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ GPtrArray *array = g_ptr_array_new();
+ mobile_ap_station_info_t *node = NULL;
+
+ if (_get_station_info((gconstpointer)MOBILE_AP_TYPE_USB,
+ _slist_find_station_by_interface,
+ &node) != MOBILE_AP_ERROR_NONE) {
+ DBG("There is no USB station\n");
+ dbus_g_method_return(context, array);
+ g_ptr_array_free(array, TRUE);
+ return TRUE;
+ }
+
+ __add_usb_station_info_to_array(array, node);
+ dbus_g_method_return(context, array);
+ g_ptr_array_free(array, TRUE);
+
+ return TRUE;
+}
+
+gboolean mobileap_get_usb_interface_info(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ GPtrArray *array = g_ptr_array_new();
+ GValue value = {0, {{0}}};
+ struct in_addr addr;
+
+ addr.s_addr = htonl(IP_ADDRESS_USB);
+
+ g_value_init(&value, DBUS_STRUCT_INTERFACE);
+ g_value_take_boxed(&value,
+ dbus_g_type_specialized_construct(DBUS_STRUCT_INTERFACE));
+ dbus_g_type_struct_set(&value, 0, USB_IF, 1, inet_ntoa(addr),
+ 2, inet_ntoa(addr), 3, IP_SUBNET_MASK, G_MAXUINT);
+
+ g_ptr_array_add(array, g_value_get_boxed(&value));
+ dbus_g_method_return(context, array);
+ g_ptr_array_free(array, TRUE);
+
+ return TRUE;
+}
--- /dev/null
+/*
+ * mobileap-agent
+ *
+ * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
+ *
+ * Contact: Hocheol Seo <hocheol.seo@samsung.com>,
+ * Injun Yang <injun.yang@samsung.com>,
+ * Seungyoun Ju <sy39.ju@samsung.com>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dbus/dbus.h>
+#include <dbus/dbus-glib.h>
+#include <dbus/dbus-glib-lowlevel.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ss_manager.h>
+
+#include "mobileap_agent.h"
+#include "mobileap_common.h"
+#include "mobileap_wifi.h"
+
+static int __generate_initial_passphrase(char *passphrase_buf);
+static mobile_ap_error_code_e __get_hide_mode(int *hide_mode);
+static mobile_ap_error_code_e __set_hide_mode(const int hide_mode);
+static mobile_ap_error_code_e __get_ssid(char *ssid, unsigned int size);
+static mobile_ap_error_code_e __get_security_type(char *security_type, unsigned int len);
+static mobile_ap_error_code_e __set_security_type(const char *security_type);
+static mobile_ap_error_code_e __get_passphrase(char *passphrase, unsigned int size, unsigned int *passphrase_len);
+static mobile_ap_error_code_e __set_passphrase(const char *passphrase, const unsigned int size);
+static gboolean __send_station_event_cb(gpointer data);
+static void __handle_station_signal(int sig);
+static mobile_ap_error_code_e __update_wifi_data(MobileAPObject *obj);
+
+static int __generate_initial_passphrase(char *passphrase_buf)
+{
+ DBG("+\n");
+
+ guint32 rand_int;
+ int index;
+
+ for (index = 0; index < MOBILE_AP_WIFI_KEY_MIN_LEN; index++) {
+ rand_int = g_random_int_range('a', 'z');
+ passphrase_buf[index] = rand_int;
+ }
+ passphrase_buf[index] = '\0';
+
+ return index;
+}
+
+static mobile_ap_error_code_e __get_hide_mode(int *hide_mode)
+{
+ if (hide_mode == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, hide_mode) < 0) {
+ ERR("vconf_get_int is failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_error_code_e __set_hide_mode(const int hide_mode)
+{
+ if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_HIDE, hide_mode) < 0) {
+ ERR("vconf_set_int is failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_error_code_e __get_ssid(char *ssid, unsigned int size)
+{
+ if (ssid == NULL)
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+
+ char *ptr = NULL;
+ char *ptr_tmp = NULL;
+
+ ptr = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
+ if (ptr == NULL)
+ return MOBILE_AP_ERROR_RESOURCE;
+
+ if (!g_utf8_validate(ptr, -1, (const char **)&ptr_tmp))
+ *ptr_tmp = '\0';
+
+ g_strlcpy(ssid, ptr, size);
+ free(ptr);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_error_code_e __get_security_type(char *security_type, unsigned int len)
+{
+ if (security_type == NULL)
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+
+ char *type_str = NULL;
+ softap_security_type_e type;
+
+ if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, (int *)&type) < 0) {
+ ERR("vconf_get_int is failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ switch (type) {
+ case SOFTAP_SECURITY_TYPE_OPEN:
+ type_str = SOFTAP_SECURITY_TYPE_OPEN_STR;
+ break;
+
+ case SOFTAP_SECURITY_TYPE_WPA2_PSK:
+ type_str = SOFTAP_SECURITY_TYPE_WPA2_PSK_STR;
+ break;
+
+ default:
+ ERR("Invalid data\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ g_strlcpy(security_type, type_str, len);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_error_code_e __set_security_type(const char *security_type)
+{
+ if (security_type == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ softap_security_type_e type;
+
+ if (!strcmp(security_type, SOFTAP_SECURITY_TYPE_OPEN_STR)) {
+ type = SOFTAP_SECURITY_TYPE_OPEN;
+ } else if (!strcmp(security_type, SOFTAP_SECURITY_TYPE_WPA2_PSK_STR)) {
+ type = SOFTAP_SECURITY_TYPE_WPA2_PSK;
+ } else {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ if (vconf_set_int(VCONFKEY_MOBILE_HOTSPOT_SECURITY, type) < 0) {
+ ERR("vconf_set_int is failed\n");
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_error_code_e __get_passphrase(char *passphrase,
+ unsigned int size, unsigned int *passphrase_len)
+{
+ if (passphrase == NULL || passphrase_len == NULL) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ int ret = 0;
+ ssm_file_info_t sfi;
+
+ ret = ssm_getinfo(SOFTAP_PASSPHRASE_PATH, &sfi,
+ SSM_FLAG_SECRET_OPERATION, NULL);
+ if (ret == -SS_FILE_OPEN_ERROR) {
+ *passphrase_len = __generate_initial_passphrase(passphrase);
+
+ ret = __set_passphrase(passphrase, *passphrase_len);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ memset(passphrase, 0x00, size);
+ *passphrase_len = 0;
+ return ret;
+ }
+
+ ret = ssm_getinfo(SOFTAP_PASSPHRASE_PATH, &sfi,
+ SSM_FLAG_SECRET_OPERATION, NULL);
+ if (ret < 0) {
+ ERR("ssm_getinfo is failed : %d\n", ret);
+ memset(passphrase, 0x00, size);
+ *passphrase_len = 0;
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+ } else if (ret < 0) {
+ ERR("ssm_getinfo is failed : %d\n", ret);
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ memset(passphrase, 0x00, size);
+ ret = ssm_read(SOFTAP_PASSPHRASE_PATH, passphrase, sfi.originSize,
+ passphrase_len, SSM_FLAG_SECRET_OPERATION, NULL);
+ if (ret < 0) {
+ ERR("ssm_read is failed : %d\n", ret);
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static mobile_ap_error_code_e __set_passphrase(const char *passphrase, const unsigned int size)
+{
+ if (size < MOBILE_AP_WIFI_KEY_MIN_LEN || size > MOBILE_AP_WIFI_KEY_MAX_LEN ||
+ passphrase == NULL) {
+ ERR("Invalid parameter\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ int ret = 0;
+
+ ret = ssm_write_buffer((char *)passphrase, size, SOFTAP_PASSPHRASE_PATH,
+ SSM_FLAG_SECRET_OPERATION, NULL);
+ if (ret < 0) {
+ ERR("ssm_write_buffer is failed : %d\n", ret);
+ return MOBILE_AP_ERROR_RESOURCE;
+ }
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+static gboolean __send_station_event_cb(gpointer data)
+{
+ int sig = GPOINTER_TO_INT(data);
+ mobile_ap_station_info_t *si = NULL;
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_WIFI)) {
+ return FALSE;
+ }
+
+ if (sig == SIGUSR1) {
+ DBG("STA connected(%d)\n", sig);
+ /* STA connection is handled in the dnsmasq signal handler */
+ } else if (sig == SIGUSR2) {
+ DBG("STA disconnected(%d)\n", sig);
+
+ /* Temporarily care only one station.
+ * Driver team should be support detail information */
+ if (_get_station_info(MOBILE_AP_TYPE_WIFI,
+ _slist_find_station_by_interface,
+ &si) != MOBILE_AP_ERROR_NONE) {
+ return FALSE;
+ }
+ _remove_station_info(si->mac, _slist_find_station_by_mac);
+ }
+
+ return FALSE;
+}
+
+static void __handle_station_signal(int sig)
+{
+ g_idle_add(__send_station_event_cb, GINT_TO_POINTER(sig));
+ return;
+}
+
+void _register_wifi_station_handler(void)
+{
+ struct sigaction sa;
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_handler = __handle_station_signal;
+ sigaction(SIGUSR1, &sa, NULL);
+ sigaction(SIGUSR2, &sa, NULL);
+}
+
+void _add_wifi_device_to_array(softap_device_info_t *di, GPtrArray *array)
+{
+ int i = 0;
+ GIOChannel *io = NULL;
+ gchar *line = NULL;
+ gchar *device_name = NULL;
+ gchar ip_addr[MOBILE_AP_STR_INFO_LEN] = {0, };
+ gchar mac_addr[MOBILE_AP_STR_INFO_LEN] = {0, };
+ gchar name[MOBILE_AP_STR_HOSTNAME_LEN] = {0, };
+ gchar expire[MOBILE_AP_STR_INFO_LEN] = {0, };
+ gchar extra[MOBILE_AP_STR_INFO_LEN] = {0, };
+
+ int found = 0;
+
+ for (i = 0; i < di->number; i++)
+ DBG("bssid[%d]:%s\n", i, di->bssid[i]);
+
+ DBG("Number of connected device:%d\n", di->number);
+
+ io = g_io_channel_new_file(DNSMASQ_LEASES_FILE, "r", NULL);
+
+ while (g_io_channel_read_line(io, &line, NULL, NULL, NULL) ==
+ G_IO_STATUS_NORMAL) {
+ sscanf(line, "%19s %19s %19s %19s %19s", expire, mac_addr,
+ ip_addr, name, extra);
+ DBG("mac_addr:%s ip_addr:%s name:%s expire:%s\n", mac_addr,
+ ip_addr, name, expire);
+
+ for (i = 0; i < di->number; i++) {
+ if (g_ascii_strcasecmp(di->bssid[i], mac_addr) == 0) {
+ if (!strcmp(name, "*"))
+ device_name = MOBILE_AP_NAME_UNKNOWN;
+ else
+ device_name = name;
+
+ _mh_core_add_data_to_array(array, MOBILE_AP_TYPE_WIFI,
+ device_name);
+
+ found++;
+
+ break;
+ }
+ }
+
+ g_free(line);
+ }
+ g_io_channel_unref(io);
+
+ /* Set the name UNKNOWN unless we got the name. */
+ for (i = found; i < di->number; i++) {
+ _mh_core_add_data_to_array(array, MOBILE_AP_TYPE_WIFI,
+ MOBILE_AP_NAME_UNKNOWN);
+ }
+}
+
+mobile_ap_error_code_e _disable_wifi_tethering(MobileAPObject *obj)
+{
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ if (!_mobileap_is_enabled(MOBILE_AP_STATE_WIFI)) {
+ ERR("Wi-Fi tethering has not been activated\n");
+ ret = MOBILE_AP_ERROR_NOT_ENABLED;
+ return ret;
+ }
+
+ if (_remove_station_info_all(MOBILE_AP_TYPE_WIFI) !=
+ MOBILE_AP_ERROR_NONE) {
+ ERR("_remove_station_info_all is failed. Ignore it.\n");
+ }
+
+ ret = _mh_core_disable_softap();
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("_mh_core_disable_softap is failed : %d\n", ret);
+ return ret;
+ }
+
+ _deinit_tethering(obj);
+ _mobileap_clear_state(MOBILE_AP_STATE_WIFI);
+
+ DBG("_disable_wifi_tethering is done\n");
+
+ return ret;
+}
+
+static mobile_ap_error_code_e __update_wifi_data(MobileAPObject *obj)
+{
+ if (obj == NULL) {
+ ERR("Invalid param\n");
+ return MOBILE_AP_ERROR_INVALID_PARAM;
+ }
+
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+ unsigned int read_len = 0;
+
+ ret = __get_ssid(obj->ssid, sizeof(obj->ssid));
+ if (ret != MOBILE_AP_ERROR_NONE)
+ return ret;
+
+ ret = __get_security_type(obj->security_type, sizeof(obj->security_type));
+ if (ret != MOBILE_AP_ERROR_NONE)
+ return ret;
+
+ ret = __get_hide_mode(&obj->hide_mode);
+ if (ret != MOBILE_AP_ERROR_NONE)
+ return ret;
+
+ if (strcmp(obj->security_type, SOFTAP_SECURITY_TYPE_OPEN_STR) == 0) {
+ g_strlcpy(obj->key, "00000000", sizeof(obj->key));
+ } else if (strcmp(obj->security_type, SOFTAP_SECURITY_TYPE_WPA2_PSK_STR) == 0) {
+ ret = __get_passphrase(obj->key, sizeof(obj->key), &read_len);
+ if (ret != MOBILE_AP_ERROR_NONE)
+ return ret;
+ } else {
+ ERR("Unknown security type\n");
+ return MOBILE_AP_ERROR_INTERNAL;
+ }
+
+ DBG("ssid : %s security type : %s hide mode : %d\n",
+ obj->ssid, obj->security_type, obj->hide_mode);
+
+ return MOBILE_AP_ERROR_NONE;
+}
+
+gboolean mobileap_enable_wifi_tethering(MobileAPObject *obj, gchar *ssid,
+ gchar *key, gint hide_mode, DBusGMethodInvocation *context)
+{
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+
+ if (_mobileap_is_enabled(MOBILE_AP_STATE_WIFI)) {
+ ERR("Wi-Fi tethering is already enabled\n");
+ ret = MOBILE_AP_ERROR_ALREADY_ENABLED;
+ dbus_g_method_return(context,
+ MOBILE_AP_ENABLE_WIFI_TETHERING_CFM, ret);
+ return FALSE;
+ }
+
+ /* Update global state */
+ if (!_mobileap_set_state(MOBILE_AP_STATE_WIFI)) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ /* Update Wi-Fi hotspot data to common object */
+ ret = __update_wifi_data(obj);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ goto FAIL;
+ }
+
+ /* Initialize tethering */
+ if (!_init_tethering(obj)) {
+ ret = MOBILE_AP_ERROR_RESOURCE;
+ goto FAIL;
+ }
+
+ /* Upload driver */
+ ret = _mh_core_enable_softap(obj->ssid, obj->security_type,
+ obj->key, obj->hide_mode);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ _deinit_tethering(obj);
+ goto FAIL;
+ }
+
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_WIFI_TETHER_ON, NULL);
+ dbus_g_method_return(context, MOBILE_AP_ENABLE_WIFI_TETHERING_CFM, ret);
+
+ return TRUE;
+
+FAIL:
+ _mobileap_clear_state(MOBILE_AP_STATE_WIFI);
+ dbus_g_method_return(context, MOBILE_AP_ENABLE_WIFI_TETHERING_CFM, ret);
+
+ return FALSE;
+}
+
+gboolean mobileap_disable_wifi_tethering(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ int ret = MOBILE_AP_ERROR_NONE;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = _disable_wifi_tethering(obj);
+
+ _emit_mobileap_dbus_signal(obj, E_SIGNAL_WIFI_TETHER_OFF, NULL);
+ dbus_g_method_return(context, MOBILE_AP_DISABLE_WIFI_TETHERING_CFM, ret);
+
+ if (ret != MOBILE_AP_ERROR_NONE)
+ return FALSE;
+ else
+ return TRUE;
+}
+
+gboolean mobileap_get_wifi_tethering_hide_mode(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+ int hide_mode = 0;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __get_hide_mode(&hide_mode);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__get_hide_mode is failed : %d\n", ret);
+ }
+
+ dbus_g_method_return(context, hide_mode);
+
+ return TRUE;
+}
+
+gboolean mobileap_set_wifi_tethering_hide_mode(MobileAPObject *obj,
+ gint hide_mode, DBusGMethodInvocation *context)
+{
+ int ret = 0;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __set_hide_mode(hide_mode);
+ if (ret < 0) {
+ ERR("__set_hide_mode is failed : %d\n", ret);
+ }
+
+ dbus_g_method_return(context);
+
+ return TRUE;
+}
+
+gboolean mobileap_get_wifi_tethering_ssid(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+ char ssid[MOBILE_AP_WIFI_SSID_MAX_LEN + 1] = {0, };
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __get_ssid(ssid, sizeof(ssid));
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__get_ssid is failed : %d\n", ret);
+ }
+
+ dbus_g_method_return(context, ssid);
+
+ return TRUE;
+
+}
+
+gboolean mobileap_get_wifi_tethering_security_type(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+ char security_type[SECURITY_TYPE_LEN] = {0, };
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __get_security_type(security_type, sizeof(security_type));
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__get_security_type is failed : %d\n", ret);
+ }
+
+ dbus_g_method_return(context, security_type);
+
+ return TRUE;
+}
+
+gboolean mobileap_set_wifi_tethering_security_type(MobileAPObject *obj,
+ gchar *security_type, DBusGMethodInvocation *context)
+{
+ int ret = 0;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __set_security_type(security_type);
+ if (ret < 0) {
+ ERR("__set_security_type is failed: %d\n", ret);
+ }
+
+ dbus_g_method_return(context);
+
+ return TRUE;
+}
+
+gboolean mobileap_get_wifi_tethering_passphrase(MobileAPObject *obj,
+ DBusGMethodInvocation *context)
+{
+ int ret = MOBILE_AP_ERROR_NONE;
+ char passphrase[MOBILE_AP_WIFI_KEY_MAX_LEN + 1] = {0, };
+ unsigned int len = 0;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __get_passphrase(passphrase, sizeof(passphrase), &len);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ len = 0;
+ ERR("__get_password is failed : %d\n", ret);
+ }
+
+ dbus_g_method_return(context, passphrase, len);
+
+ return TRUE;
+}
+
+gboolean mobileap_set_wifi_tethering_passphrase(MobileAPObject *obj,
+ gchar *passphrase, guint len, DBusGMethodInvocation *context)
+{
+ mobile_ap_error_code_e ret = MOBILE_AP_ERROR_NONE;
+
+ DBG("+\n");
+ g_assert(obj != NULL);
+ g_assert(context != NULL);
+
+ ret = __set_passphrase(passphrase, len);
+ if (ret != MOBILE_AP_ERROR_NONE) {
+ ERR("__set_passphrase is failed : %d\n", ret);
+ }
+
+ dbus_g_method_return(context);
+
+ return TRUE;
+}