--- /dev/null
+Dongwook Lee <dwmax.lee@samsung.com>
+Sungsik Jang <sungsik.jang@samsung.com>
+Gibyoung Kim <lastkgb.kim@samsung.com>
\ No newline at end of file
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(wifi-direct-manager C)
+
+#SET(PREFIX $(CMAKE_INSTALL_PREFIX))
+SET(prefix "/usr")
+SET(EXEC_PREFIX "\${prefix}")
+SET(LIBDIR "\${prefix}/lib")
+SET(INCLUDEDIR "\${prefix}/include")
+
+ADD_SUBDIRECTORY(src)
+ADD_SUBDIRECTORY(plugin/wpasupplicant)
--- /dev/null
+Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.\r
+\r
+ Apache License\r
+ Version 2.0, January 2004\r
+ http://www.apache.org/licenses/\r
+\r
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION\r
+\r
+ 1. Definitions.\r
+\r
+ "License" shall mean the terms and conditions for use, reproduction,\r
+ and distribution as defined by Sections 1 through 9 of this document.\r
+\r
+ "Licensor" shall mean the copyright owner or entity authorized by\r
+ the copyright owner that is granting the License.\r
+\r
+ "Legal Entity" shall mean the union of the acting entity and all\r
+ other entities that control, are controlled by, or are under common\r
+ control with that entity. For the purposes of this definition,\r
+ "control" means (i) the power, direct or indirect, to cause the\r
+ direction or management of such entity, whether by contract or\r
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the\r
+ outstanding shares, or (iii) beneficial ownership of such entity.\r
+\r
+ "You" (or "Your") shall mean an individual or Legal Entity\r
+ exercising permissions granted by this License.\r
+\r
+ "Source" form shall mean the preferred form for making modifications,\r
+ including but not limited to software source code, documentation\r
+ source, and configuration files.\r
+\r
+ "Object" form shall mean any form resulting from mechanical\r
+ transformation or translation of a Source form, including but\r
+ not limited to compiled object code, generated documentation,\r
+ and conversions to other media types.\r
+\r
+ "Work" shall mean the work of authorship, whether in Source or\r
+ Object form, made available under the License, as indicated by a\r
+ copyright notice that is included in or attached to the work\r
+ (an example is provided in the Appendix below).\r
+\r
+ "Derivative Works" shall mean any work, whether in Source or Object\r
+ form, that is based on (or derived from) the Work and for which the\r
+ editorial revisions, annotations, elaborations, or other modifications\r
+ represent, as a whole, an original work of authorship. For the purposes\r
+ of this License, Derivative Works shall not include works that remain\r
+ separable from, or merely link (or bind by name) to the interfaces of,\r
+ the Work and Derivative Works thereof.\r
+\r
+ "Contribution" shall mean any work of authorship, including\r
+ the original version of the Work and any modifications or additions\r
+ to that Work or Derivative Works thereof, that is intentionally\r
+ submitted to Licensor for inclusion in the Work by the copyright owner\r
+ or by an individual or Legal Entity authorized to submit on behalf of\r
+ the copyright owner. For the purposes of this definition, "submitted"\r
+ means any form of electronic, verbal, or written communication sent\r
+ to the Licensor or its representatives, including but not limited to\r
+ communication on electronic mailing lists, source code control systems,\r
+ and issue tracking systems that are managed by, or on behalf of, the\r
+ Licensor for the purpose of discussing and improving the Work, but\r
+ excluding communication that is conspicuously marked or otherwise\r
+ designated in writing by the copyright owner as "Not a Contribution."\r
+\r
+ "Contributor" shall mean Licensor and any individual or Legal Entity\r
+ on behalf of whom a Contribution has been received by Licensor and\r
+ subsequently incorporated within the Work.\r
+\r
+ 2. Grant of Copyright License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ copyright license to reproduce, prepare Derivative Works of,\r
+ publicly display, publicly perform, sublicense, and distribute the\r
+ Work and such Derivative Works in Source or Object form.\r
+\r
+ 3. Grant of Patent License. Subject to the terms and conditions of\r
+ this License, each Contributor hereby grants to You a perpetual,\r
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable\r
+ (except as stated in this section) patent license to make, have made,\r
+ use, offer to sell, sell, import, and otherwise transfer the Work,\r
+ where such license applies only to those patent claims licensable\r
+ by such Contributor that are necessarily infringed by their\r
+ Contribution(s) alone or by combination of their Contribution(s)\r
+ with the Work to which such Contribution(s) was submitted. If You\r
+ institute patent litigation against any entity (including a\r
+ cross-claim or counterclaim in a lawsuit) alleging that the Work\r
+ or a Contribution incorporated within the Work constitutes direct\r
+ or contributory patent infringement, then any patent licenses\r
+ granted to You under this License for that Work shall terminate\r
+ as of the date such litigation is filed.\r
+\r
+ 4. Redistribution. You may reproduce and distribute copies of the\r
+ Work or Derivative Works thereof in any medium, with or without\r
+ modifications, and in Source or Object form, provided that You\r
+ meet the following conditions:\r
+\r
+ (a) You must give any other recipients of the Work or\r
+ Derivative Works a copy of this License; and\r
+\r
+ (b) You must cause any modified files to carry prominent notices\r
+ stating that You changed the files; and\r
+\r
+ (c) You must retain, in the Source form of any Derivative Works\r
+ that You distribute, all copyright, patent, trademark, and\r
+ attribution notices from the Source form of the Work,\r
+ excluding those notices that do not pertain to any part of\r
+ the Derivative Works; and\r
+\r
+ (d) If the Work includes a "NOTICE" text file as part of its\r
+ distribution, then any Derivative Works that You distribute must\r
+ include a readable copy of the attribution notices contained\r
+ within such NOTICE file, excluding those notices that do not\r
+ pertain to any part of the Derivative Works, in at least one\r
+ of the following places: within a NOTICE text file distributed\r
+ as part of the Derivative Works; within the Source form or\r
+ documentation, if provided along with the Derivative Works; or,\r
+ within a display generated by the Derivative Works, if and\r
+ wherever such third-party notices normally appear. The contents\r
+ of the NOTICE file are for informational purposes only and\r
+ do not modify the License. You may add Your own attribution\r
+ notices within Derivative Works that You distribute, alongside\r
+ or as an addendum to the NOTICE text from the Work, provided\r
+ that such additional attribution notices cannot be construed\r
+ as modifying the License.\r
+\r
+ You may add Your own copyright statement to Your modifications and\r
+ may provide additional or different license terms and conditions\r
+ for use, reproduction, or distribution of Your modifications, or\r
+ for any such Derivative Works as a whole, provided Your use,\r
+ reproduction, and distribution of the Work otherwise complies with\r
+ the conditions stated in this License.\r
+\r
+ 5. Submission of Contributions. Unless You explicitly state otherwise,\r
+ any Contribution intentionally submitted for inclusion in the Work\r
+ by You to the Licensor shall be under the terms and conditions of\r
+ this License, without any additional terms or conditions.\r
+ Notwithstanding the above, nothing herein shall supersede or modify\r
+ the terms of any separate license agreement you may have executed\r
+ with Licensor regarding such Contributions.\r
+\r
+ 6. Trademarks. This License does not grant permission to use the trade\r
+ names, trademarks, service marks, or product names of the Licensor,\r
+ except as required for reasonable and customary use in describing the\r
+ origin of the Work and reproducing the content of the NOTICE file.\r
+\r
+ 7. Disclaimer of Warranty. Unless required by applicable law or\r
+ agreed to in writing, Licensor provides the Work (and each\r
+ Contributor provides its Contributions) on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or\r
+ implied, including, without limitation, any warranties or conditions\r
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A\r
+ PARTICULAR PURPOSE. You are solely responsible for determining the\r
+ appropriateness of using or redistributing the Work and assume any\r
+ risks associated with Your exercise of permissions under this License.\r
+\r
+ 8. Limitation of Liability. In no event and under no legal theory,\r
+ whether in tort (including negligence), contract, or otherwise,\r
+ unless required by applicable law (such as deliberate and grossly\r
+ negligent acts) or agreed to in writing, shall any Contributor be\r
+ liable to You for damages, including any direct, indirect, special,\r
+ incidental, or consequential damages of any character arising as a\r
+ result of this License or out of the use or inability to use the\r
+ Work (including but not limited to damages for loss of goodwill,\r
+ work stoppage, computer failure or malfunction, or any and all\r
+ other commercial damages or losses), even if such Contributor\r
+ has been advised of the possibility of such damages.\r
+\r
+ 9. Accepting Warranty or Additional Liability. While redistributing\r
+ the Work or Derivative Works thereof, You may choose to offer,\r
+ and charge a fee for, acceptance of support, warranty, indemnity,\r
+ or other liability obligations and/or rights consistent with this\r
+ License. However, in accepting such obligations, You may act only\r
+ on Your own behalf and on Your sole responsibility, not on behalf\r
+ of any other Contributor, and only if You agree to indemnify,\r
+ defend, and hold each Contributor harmless for any liability\r
+ incurred by, or claims asserted against, such Contributor by reason\r
+ of your accepting any such warranty or additional liability.\r
+\r
+ END OF TERMS AND CONDITIONS\r
+\r
+ APPENDIX: How to apply the Apache License to your work.\r
+\r
+ To apply the Apache License to your work, attach the following\r
+ boilerplate notice, with the fields enclosed by brackets "[]"\r
+ replaced with your own identifying information. (Don't include\r
+ the brackets!) The text should be enclosed in the appropriate\r
+ comment syntax for the file format. We also recommend that a\r
+ file or class name and description of purpose be included on the\r
+ same "printed page" as the copyright notice for easier\r
+ identification within third-party archives.\r
+\r
+ Copyright [yyyy] [name of copyright owner]\r
+\r
+ Licensed under the Apache License, Version 2.0 (the "License");\r
+ you may not use this file except in compliance with the License.\r
+ You may obtain a copy of the License at\r
+\r
+ http://www.apache.org/licenses/LICENSE-2.0\r
+\r
+ Unless required by applicable law or agreed to in writing, software\r
+ distributed under the License is distributed on an "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
+ See the License for the specific language governing permissions and\r
+ limitations under the License.
\ No newline at end of file
--- /dev/null
+wifi-direct-manager (0.4.0) precise; urgency=low
+
+ * Initial Update
+ * Git : framework/connectivity/wifi-direct-manager
+ * Tag : wifi-direct-manager_0.4.0
+
+ -- Gibyoung Kim <lastkgb.kim@samsung.com> Fri, 23 Nov 2012 21:35:21 +0900
+
--- /dev/null
+Source: wifi-direct-manager
+Section: net
+Priority: extra
+Maintainer: Dongwook Lee <dwmax.lee@samsung.com>, Sungsik Jang <sungsik.jang@samsung.com>
+Uploaders: Dongwook Lee <dwmax.lee@samsung.com> Sungsik Jang <sungsik.jang@samsung.com>, Taeksu Shin <taeksu.shin@samsung.com>
+Build-Depends: debhelper (>= 5), libwifi-direct-dev, autotools-dev, libslp-setting-dev, libglib2.0-dev, dlog-dev, libdbus-glib-1-dev, capi-appfw-application-dev
+Standards-Version: 3.7.2
+
+Package: wifi-direct-manager
+Section: net
+Architecture: any
+Depends: ${shlibs:Depends}, libslp-setting-0, libglib2.0-0
+Description: Wi-Fi Direct manager
+
+Package: wifi-direct-plugin-broadcom
+Section: net
+Architecture: any
+Depends: ${shlibs:Depends}
+Description: Wi-Fi Direct plugin for Broadcom
+
+Package: wifi-direct-plugin-wpasupplicant
+Section: net
+Architecture: any
+Depends: ${shlibs:Depends}
+Description: Wi-Fi Direct plugin for wpa supplicant
+
--- /dev/null
+This is wifi-direct-manager, written and maintained by Dongwook Lee<dwmax.lee@samsung.com>
+
+on Tue Jan 5 14:01:02 IST 2010.
+
+The original source can always be found at:
+
+Copyright Holder: Dongwook Lee
+
+License:
+ Samsung
+
+/*
+ * SLP2.0
+ * Copyright (c) 2008 Samsung Electronics, Inc.
+ * All rights reserved.
+ *
+ * This software is a confidential and proprietary information
+ * of Samsung Electronics, Inc. ("Confidential Information"). You
+ * shall not disclose such Confidential Information and shall use
+ * it only in accordance with the terms of the license agreement
+ * you entered into with Samsung Electronics.
+ */
--- /dev/null
+#!/usr/bin/make -f
+# -*- makefile -*-
+# Sample debian/rules that uses debhelper.
+# This file was originally written by Joey Hess and Craig Small.
+# As a special exception, when this file is copied by dh-make into a
+# dh-make output file, you may use that output file without restriction.
+# This special exception was added by Craig Small in version 0.37 of dh-make.
+
+# Uncomment this to turn on verbose mode.
+#export DH_VERBOSE=1
+
+CFLAGS ?= -Wall -g
+CXXFLAGS ?= -Wall -g
+LDFLAGS ?=
+PREFIX ?= /usr
+DATADIR ?= /opt
+
+ifneq (,$(findstring noopt,$(DEB_BUILD_OPTIONS)))
+ CFLAGS += -O0
+ CXXFLAGS += -O0
+else
+ CFLAGS += -O2
+ CXXFLAGS += -O2
+endif
+
+CFLAGS += -DX1SETTING -D_DLOG_UTIL
+#LDFLAGS += -Wl,--rpath=$(PREFIX)/lib -Wl,--as-needed
+LDFLAGS += -Wl,--rpath=$(PREFIX)/lib
+
+
+configure: configure-stamp
+configure-stamp:
+ dh_testdir
+ # Add here commands to configure the package.
+ CFLAGS="$(CFLAGS)" CXXFLAGS="$(CXXFLAGS)" LDFLAGS="$(LDFLAGS)" cmake . -DCMAKE_INSTALL_PREFIX=$(PREFIX)
+
+ touch configure-stamp
+
+build: build-stamp
+
+build-stamp: configure-stamp
+ dh_testdir
+
+ # Add here commands to compile the package.
+ $(MAKE) -j5
+
+ dpkg-architecture
+ echo "deb-arch = ${DEB_BUILD_ARCH}"
+
+ cp debian/wifi-direct-manager.install.in.${DEB_BUILD_ARCH} debian/wifi-direct-manager.install.in
+ cp debian/wifi-direct-plugin-broadcom.install.in.${DEB_BUILD_ARCH} debian/wifi-direct-plugin-broadcom.install.in
+
+ for f in `find $(CURDIR)/debian/ -name "*.in"`; do \
+ cat $$f > $${f%.in}; \
+ sed -i -e "s#@PREFIX@#$(PREFIX)#g" $${f%.in}; \
+ sed -i -e "s#@DATADIR@#$(DATADIR)#g" $${f%.in}; \
+ done
+
+
+ touch $@
+
+clean:
+ dh_testdir
+ dh_testroot
+ rm -f build-stamp configure-stamp
+
+ # Add here commands to clean up after the build process.
+ -$(MAKE) clean
+ rm -rf CMakeCache.txt
+ rm -rf CMakeFiles
+ rm -rf cmake_install.cmake
+ rm -rf Makefile
+ rm -rf install_manifest.txt
+
+ rm -rf src/CMakeCache.txt
+ rm -rf src/CMakeFiles
+ rm -rf src/cmake_install.cmake
+ rm -rf src/install_manifest.txt
+ rm -rf src/Makefile
+
+ rm -rf plugin/broadcom/CMakeCache.txt
+ rm -rf plugin/broadcom/CMakeFiles
+ rm -rf plugin/boradcom/cmake_install.cmake
+ rm -rf plugin/broadcom/install_manifest.txt
+ rm -rf plugin/broadcom/Makefile
+
+ rm -rf plugin/wpasupplicant/CMakeCache.txt
+ rm -rf plugin/wpasupplicant/CMakeFiles
+ rm -rf plugin/wpasupplicant/cmake_install.cmake
+ rm -rf plugin/wpasupplicant/install_manifest.txt
+ rm -rf plugin/wpasupplicant/Makefile
+
+ for f in `find $(CURDIR)/debian/ -name "*.in"`; do \
+ rm -f $${f%.in}; \
+ done
+
+ dh_clean
+
+install: build
+ dh_testdir
+ dh_testroot
+ dh_clean -k
+ dh_installdirs
+
+ # Add here commands to install the package into debian/wavplayer.
+ $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install
+
+# Build architecture-independent files here.
+binary-indep: build install
+# We have nothing to do by default.
+
+# Build architecture-dependent files here.
+binary-arch: build install
+ dh_testdir
+ dh_testroot
+ dh_installchangelogs
+ dh_installdocs
+ dh_installexamples
+ dh_install --sourcedir=debian/tmp
+# dh_installmenu
+# dh_installdebconf
+# dh_installlogrotate
+# dh_installemacsen
+# dh_installpam
+# dh_installmime
+# dh_python
+# dh_installinit
+# dh_installcron
+# dh_installinfo
+ dh_installman
+ dh_link
+# dh_strip --dbg-package=
+ dh_compress
+ dh_fixperms
+# dh_perl
+ dh_makeshlibs
+ dh_installdeb
+ dh_shlibdeps
+ dh_gencontrol
+ dh_md5sums
+ dh_builddeb
+
+binary: binary-indep binary-arch
+.PHONY: build clean binary-indep binary-arch binary install configure
--- /dev/null
+@PREFIX@/bin/wfd-manager
+@PREFIX@/etc/wifi-direct/dhcpd.p2p.conf
+@PREFIX@/etc/wifi-direct/dhcpd.wl0.conf
+@PREFIX@/etc/wifi-direct/dhcpd.eth.conf
+@PREFIX@/etc/wifi-direct/udhcp_script.non-autoip
+@PREFIX@/etc/wifi-direct/p2p_suppl.conf
+@PREFIX@/bin/dhcpd-notify.sh
+@PREFIX@/bin/wifi-direct-server.sh
+@PREFIX@/bin/wifi-direct-dhcp.sh
--- /dev/null
+@PREFIX@/bin/wfd-manager
+@PREFIX@/etc/wifi-direct/dhcpd.p2p.conf
+@PREFIX@/etc/wifi-direct/dhcpd.wl0.conf
+@PREFIX@/etc/wifi-direct/dhcpd.eth.conf
+@PREFIX@/etc/wifi-direct/udhcp_script.non-autoip
+@PREFIX@/etc/wifi-direct/p2p_suppl.conf
+@PREFIX@/bin/dhcpd-notify.sh
+@PREFIX@/bin/wifi-direct-server.sh
+@PREFIX@/bin/wifi-direct-dhcp.sh
--- /dev/null
+#!/bin/sh
+#
+
+chmod 644 /usr/etc/wifi-direct/dhcpd.p2p.conf
+chmod 644 /usr/etc/wifi-direct/dhcpd.wl0.conf
+chmod 644 /usr/etc/wifi-direct/dhcpd.eth.conf
+chmod 755 /usr/bin/dhcpd-notify.sh
+chmod 755 /usr/etc/wifi-direct/udhcp_script.non-autoip
+chmod 755 /usr/bin/wifi-direct-server.sh
+chmod 755 /usr/bin/wifi-direct-dhcp.sh
+
+/usr/bin/vconftool set -t int memory/wifi_direct/state 0 -u 5000 -i
+/usr/bin/vconftool set -t int memory/private/wifi_direct_manager/dhcp_ip_lease 0 -i
+/usr/bin/vconftool set -t string memory/private/wifi_direct_manager/dhcpc_server_ip 0.0.0.0 -i
+sync
+
--- /dev/null
+@PREFIX@/lib/wifi-direct-plugin-broadcom.so
+@PREFIX@/lib/libbcmp2p.so
+@PREFIX@/lib/libbcmp2papp.so
+@PREFIX@/lib/libwpscli.so
+#@PREFIX@/lib/libbcmcrypto.so
+@PREFIX@/lib/libbcmp2psig.so
--- /dev/null
+@PREFIX@/lib/wifi-direct-plugin-broadcom.so
--- /dev/null
+@PREFIX@/lib/wifi-direct-plugin-wpasupplicant.so
--- /dev/null
+#!/bin/sh
+# Dump DHCP lease data: MAC IP Time
+dumpleases | awk '$1!="Mac" {print $1, $2, $3}' > /tmp/dhcp-client-table
+
+#Update vconf value to notify wifi-direct
+vconftool set -t int memory/private/wifi_direct_manager/dhcp_ip_lease 1 -f
+#cat /tmp/dhcp-client-table
--- /dev/null
+start 192.168.49.20 #default: 192.168.0.20
+end 192.168.49.40 #default: 192.168.0.254
+interface wlan0 #default: wlan0
+max_leases 20 #default: 254
+notify_file /usr/bin/dhcpd-notify.sh
+
+option subnet 255.255.255.0
+option router 192.168.49.1
+option lease 864000 # 10 days of seconds
--- /dev/null
+start 192.168.49.20 #default: 192.168.0.20
+end 192.168.49.40 #default: 192.168.0.254
+interface p2p-wlan0-0 #default: wlan0
+max_leases 20 #default: 254
+notify_file /usr/bin/dhcpd-notify.sh
+
+
+option subnet 255.255.255.0
+option router 192.168.49.1
+option lease 864000 # 10 days of seconds
--- /dev/null
+start 192.168.49.20 #default: 192.168.0.20
+end 192.168.49.40 #default: 192.168.0.254
+interface wl0.1 #default: wlan0
+max_leases 20 #default: 254
+notify_file /usr/bin/dhcpd-notify.sh
+
+
+option subnet 255.255.255.0
+option router 192.168.49.1
+option lease 864000 # 10 days of seconds
--- /dev/null
+#!/bin/sh
+
+start()
+{
+ HARDWARE_MODEL=`grep Hardware /proc/cpuinfo | awk "{print \\$3}"`
+ /bin/echo "Hardware Model=${HARDWARE_MODEL}"
+
+ case $HARDWARE_MODEL in
+ "SLP_PQ") /bin/echo "This is PQ"
+ /usr/sbin/p2p_supplicant -t -B -ddd -Dnl80211 -g/var/run/p2p_global -f/var/log/p2p_supplicant.log
+ ;;
+ "U1SLP" | "U1HD") /bin/echo "This is U1SLP"
+ /usr/sbin/p2p_supplicant -t -B -ddd -Dwext -f/var/log/p2p_supplicant.log
+ ;;
+ "SLP7_C210") /bin/echo "This is C210"
+ /usr/sbin/p2p_supplicant -t -B -ddd -Dwext -f/var/log/p2p_supplicant.log
+ ;;
+ "SLP10_C210")
+ /usr/sbin/p2p_supplicant -t -B -ddd -Dwext -f/var/log/p2p_supplicant.log
+ ;;
+ *)
+ /usr/sbin/p2p_supplicant -t -B -ddd -Dnl80211 -g/var/run/p2p_global -f/var/log/p2p_supplicant.log
+ ;;
+ esac
+}
+
+stop()
+{
+ killall p2p_supplicant
+}
+
+case $1 in
+"start")
+start
+;;
+"stop")
+stop
+;;
+*)
+/bin/echo p2p_supp.sh [start] [stop]
+exit 1
+;;
+esac
--- /dev/null
+##### p2p_supplicant configuration file template #####
+update_config=1
+ctrl_interface=/var/run/p2p_supplicant
+eapol_version=1
+ap_scan=1
+p2p_listen_reg_class=81
+p2p_listen_channel=1
+p2p_oper_reg_class=115
+p2p_oper_channel=48
+device_name=TizenProxima
+device_type=10-0050F204-5
+config_methods=push_button
+driver_param='use_p2p_group_interface=1'
\ No newline at end of file
--- /dev/null
+#!/bin/sh
+
+# udhcpc script edited by Tim Riker <Tim@Rikers.org>
+
+[ -z "$1" ] && echo "Error: should be called from udhcpc" && exit 1
+
+RESOLV_CONF="/etc/resolv.conf"
+TEMP_DHCP_FILE="/tmp/udhcpc_dyn.tmp"
+UDHCPC_LOG="/tmp/udhcpc_log"
+
+env > /tmp/test_env
+
+[ -n "$broadcast" ] && BROADCAST="broadcast $broadcast"
+[ -n "$subnet" ] && NETMASK="netmask $subnet"
+
+case "$1" in
+ deconfig)
+ /sbin/ifconfig $interface 0.0.0.0
+ ;;
+
+ renew|bound)
+ /sbin/ifconfig $interface $ip $BROADCAST $NETMASK up
+ echo "$interface $ip $BROADCAST $NETMASK" >> $UDHCPC_LOG
+# if [ -n "$router" ] ; then
+# echo "deleting routers" >> $UDHCPC_LOG
+# while route del default gw 0.0.0.0 dev $interface 2>/dev/null ; do
+# :
+# done
+#
+# for i in $router ; do
+# echo "router $i" >> $UDHCPC_LOG
+# route add default gw $i dev $interface
+# done
+# fi
+
+ echo -n > $RESOLV_CONF
+ [ -n "$domain" ] && echo search $domain >> $RESOLV_CONF
+ for i in $dns ; do
+ echo "adding dns $i" >> $UDHCPC_LOG
+ echo nameserver $i >> $RESOLV_CONF
+ done
+ echo serveraddr $serverid >> $TEMP_DHCP_FILE
+ echo leasetime $lease >> $TEMP_DHCP_FILE
+
+ if [ -n $router ]; then
+ for i in $router ; do
+# Take the first router
+ echo "route $i"
+ local_gateway=$i
+ break
+ done
+ fi
+ if [ -z $subnet ]; then
+ subnet="255.255.255.0"
+ fi
+ if [ -z $local_gateway ]; then
+ local_gateway="0.0.0.0"
+ fi
+
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_ifname ${interface} -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_local_ip ${ip} -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_subnet_mask ${subnet} -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_gateway ${local_gateway} -f
+ vconftool set -t string memory/private/wifi_direct_manager/dhcpc_server_ip ${serverid} -f
+
+ echo $i >> $TEMP_DHCP_FILE
+ ;;
+esac
+
+exit 0
--- /dev/null
+#!/bin/sh
+INTERFACE_PREFIX="p2p"
+TARGET="REDWOOD"
+DEFAULT_IP="192.168.49.1"
+
+val=`uname -a | grep PQ | wc -l`
+if [ "${val}" -eq "1" ]; then
+ TARGET="PQ"
+fi
+
+val=`uname -a | grep U1HD | wc -l`
+if [ "${val}" -eq "1" ]; then
+ INTERFACE_PREFIX="wl0"
+ TARGET="U1HD"
+fi
+
+val=`uname -a | grep U1SLP | wc -l`
+if [ "${val}" -eq "1" ]; then
+ INTERFACE_PREFIX="wl0"
+ TARGET="U1SLP"
+fi
+
+val=`uname -a | grep i686 | wc -l`
+if [ "${val}" -eq "1" ]; then
+ INTERFACE_PREFIX="eth"
+ TARGET="EMUL"
+fi
+
+interface=`ifconfig|grep ^${INTERFACE_PREFIX}|cut -d" " -f1`
+echo "Target is ${TARGET} and interface ${INTERFACE_PREFIX}: ${interface}."
+
+start_dhcp_server()
+{
+ if [ "X${interface}" == "X" ]; then
+ echo "interface(${INTERFACE_PREFIX}) is not up"
+ return 0
+ fi
+
+ ifconfig ${interface} ${DEFAULT_IP} up
+ udhcpd /usr/etc/wifi-direct/dhcpd.${INTERFACE_PREFIX}.conf -f &
+
+ route=`cat /usr/etc/wifi-direct/dhcpd.${INTERFACE_PREFIX}.conf | grep router | awk '{print $3}'`
+ if [ -z $route ]; then
+ route="192.168.49.1"
+ fi
+ subnet=`cat /usr/etc/wifi-direct/dhcpd.${INTERFACE_PREFIX}.conf | grep subnet | awk '{print $3}'`
+
+ if [ -z $subnet ]; then
+ subnet="255.255.255.0"
+ fi
+
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_ifname ${interface} -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_local_ip ${DEFAULT_IP} -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_subnet_mask ${subnet} -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_gateway ${route} -f
+}
+
+start_dhcp_client()
+{
+ if [ "X${interface}" == "X" ]; then
+ echo "interface(${INTERFACE_PREFIX}) is not up"
+ return 0
+ fi
+ /usr/bin/udhcpc -i $interface -s /usr/etc/wifi-direct/udhcp_script.non-autoip &
+}
+
+
+stop_dhcp()
+{
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_ifname "" -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_local_ip "" -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_subnet_mask "" -f
+ vconftool set -t string memory/private/wifi_direct_manager/p2p_gateway "" -f
+
+ killall udhcpc
+ killall udhcpd
+# ifconfig ${interface} 0.0.0.0
+}
+
+is_running()
+{
+ program=$1
+ run=`ps -eo comm|grep ${program}`
+ if [ "X${run}" == "X" ]; then
+ echo "${program} is not running"
+ else
+ echo "${program} is already running"
+ fi
+}
+
+status_dhcp()
+{
+ is_running udhcpc
+ is_running udhcpd
+}
+
+
+case $1 in
+"server")
+stop_dhcp
+start_dhcp_server
+;;
+"client")
+stop_dhcp
+start_dhcp_client
+;;
+"stop")
+stop_dhcp
+;;
+"status")
+status_dhcp
+;;
+*)
+/bin/echo wifi-direct-dhcp.sh [server] [client] [stop] [status]
+exit 1
+;;
+esac
+
--- /dev/null
+#!/bin/sh
+program="wfd-manager"
+target=`ps -eo comm|grep ${program}`
+
+start_wifi_direct()
+{
+ if [ "X${target}" == "X" ]; then
+ echo "${program} is not running"
+ echo "Launching ${program}"
+ TIZEN_DEBUG_LEVEL=1 /usr/bin/${program}&
+ sleep 1
+ else
+ echo "${program} is already running"
+ fi
+}
+
+stop_wifi_direct()
+{
+ if [ "X${target}" == "X" ]; then
+ echo "${program} is not running"
+ else
+ echo "${program} is running.. Killing it"
+ killall ${program}
+ fi
+}
+
+status_wifi_direct()
+{
+ if [ "X${target}" == "X" ]; then
+ echo "${program} is not running"
+ else
+ echo "${program} is already running"
+ fi
+}
+
+case $1 in
+"start")
+start_wifi_direct
+;;
+"stop")
+stop_wifi_direct
+;;
+"status")
+status_wifi_direct
+;;
+*)
+/bin/echo wifi-direct-server.sh [start] [stop] [status]
+exit 1
+;;
+esac
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#ifndef __WIFI_DIRECT_OEM_H_
+#define __WIFI_DIRECT_OEM_H_
+
+#include "wifi-direct.h"
+#include "wifi-direct-internal.h"
+#include "wifi-direct-event-handler.h"
+
+
+int wfd_oem_init(wfd_oem_event_cb event_callback);
+int wfd_oem_destroy(void);
+int wfd_oem_activate(void);
+int wfd_oem_deactivate(void);
+int wfd_oem_connect(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config);
+int wfd_ws_wps_pbc_start(void);
+int wfd_oem_disconnect(void);
+int wfd_oem_disconnect_sta(unsigned char mac_addr[6]);
+bool wfd_oem_is_discovery_enabled(void);
+int wfd_oem_start_discovery(bool listen_only, int timeout);
+int wfd_oem_cancel_discovery(void);
+int wfd_oem_get_discovery_result(wfd_discovery_entry_s ** peer_list, int* peer_num);
+int wfd_oem_get_peer_info(unsigned char *mac_addr, wfd_discovery_entry_s **peer);
+int wfd_oem_send_provision_discovery_request(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go);
+int wfd_oem_send_invite_request(unsigned char dev_mac_addr[6]);
+int wfd_oem_create_group(char* ssid);
+int wfd_oem_cancel_group(void);
+int wfd_oem_activate_pushbutton(void);
+char* wfd_oem_get_default_interface_name(void);
+bool wfd_oem_dhcpc_get_ip_address(char *ipaddr_buf, int len, int is_IPv6);
+char* wfd_oem_get_ip(void);
+int wfd_oem_set_ssid(char* ssid);
+bool wfd_oem_is_groupowner(void);
+bool wfd_oem_is_groupclient(void);
+int wfd_oem_get_ssid(char* ssid, int len);
+char* wfd_oem_get_ip(void);
+int wfd_oem_set_wps_pin(char* pin);
+int wfd_oem_get_wps_pin(char* wps_pin, int len);
+int wfd_oem_generate_wps_pin(void);
+int wfd_oem_set_wpa_passphrase(char* wpa_key);
+int wfd_oem_get_supported_wps_mode(void);
+int wfd_oem_get_connected_peers_info(wfd_connected_peer_info_s ** peer_list, int* peer_num);
+int wfd_oem_get_connected_peers_count(int* peer_num);
+int wfd_oem_set_oem_loglevel(int is_increase);
+int wfd_oem_get_go_intent(int* intent);
+int wfd_oem_set_go_intent(int intent);
+int wfd_oem_set_device_type(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat);
+int wfd_oem_get_device_mac_address(unsigned char* device_mac);
+int wfd_oem_get_disassoc_sta_mac(unsigned char mac_addr[6]);
+int wfd_oem_get_assoc_sta_mac(unsigned char mac_addr[6]);
+int wfd_oem_get_requestor_mac(unsigned char mac_addr[6]);
+int wfd_oem_get_operating_channel(void);
+int wfd_oem_get_persistent_group_info(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num);
+int wfd_oem_remove_persistent_group(wfd_persistent_group_info_s * persistent_group);
+
+struct wfd_oem_operations {
+ int (*wfd_oem_init)(wfd_oem_event_cb event_callback);
+ int (*wfd_oem_destroy)(void);
+ int (*wfd_oem_activate)(void);
+ int (*wfd_oem_deactivate)(void);
+ int (*wfd_oem_connect)(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config);
+ int (*wfd_oem_wps_pbc_start)(void);
+ int (*wfd_oem_disconnect)(void);
+ int (*wfd_oem_disconnect_sta)(unsigned char mac_addr[6]);
+ bool (*wfd_oem_is_discovery_enabled)(void);
+ int (*wfd_oem_start_discovery)(bool listen_only, int timeout);
+ int (*wfd_oem_cancel_discovery)(void);
+ int (*wfd_oem_get_discovery_result)(wfd_discovery_entry_s ** peer_list, int* peer_num);
+ int (*wfd_oem_get_peer_info)(unsigned char *mac_addr, wfd_discovery_entry_s **peer);
+ int (*wfd_oem_send_provision_discovery_request)(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go);
+ int (*wfd_oem_send_invite_request)(unsigned char dev_mac_addr[6]);
+ int (*wfd_oem_create_group)(char* ssid);
+ int (*wfd_oem_cancel_group)(void);
+ int (*wfd_oem_activate_pushbutton)(void);
+ char* (*wfd_oem_get_default_interface_name)(void);
+ bool (*wfd_oem_dhcpc_get_ip_address)(char *ipaddr_buf, int len, int is_IPv6);
+ char* (*wfd_oem_get_ip)(void);
+ int (*wfd_oem_set_ssid)(char* ssid);
+ bool (*wfd_oem_is_groupowner)(void);
+ bool (*wfd_oem_is_groupclient)(void);
+ int (*wfd_oem_get_ssid)(char* ssid, int len);
+ int (*wfd_oem_set_wps_pin)(char* pin);
+ int (*wfd_oem_get_wps_pin)(char* wps_pin, int len);
+ int (*wfd_oem_generate_wps_pin)(void);
+ int (*wfd_oem_set_wpa_passphrase)(char* wpa_key);
+ int (*wfd_oem_get_supported_wps_mode)(void);
+ int (*wfd_oem_get_connected_peers_info)(wfd_connected_peer_info_s ** peer_list, int* peer_num);
+ int (*wfd_oem_get_connected_peers_count)(int* peer_num);
+ int (*wfd_oem_set_oem_loglevel)(int is_increase);
+ int (*wfd_oem_get_go_intent)(int* intent);
+ int (*wfd_oem_set_go_intent)(int intent);
+ int (*wfd_oem_set_device_type)(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat);
+ int (*wfd_oem_get_device_mac_address)(unsigned char* device_mac);
+ int (*wfd_oem_get_disassoc_sta_mac)(unsigned char* mac_addr);
+ int (*wfd_oem_get_assoc_sta_mac)(unsigned char* mac_addr);
+ int (*wfd_oem_get_requestor_mac)(unsigned char* mac_addr);
+ int (*wfd_oem_get_operating_channel)(void);
+ int (*wfd_oem_get_persistent_group_info)(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num);
+ int (*wfd_oem_remove_persistent_group)(wfd_persistent_group_info_s * persistent_group);
+
+};
+
+extern unsigned char g_incomming_peer_mac_address[6];
+extern char g_incomming_peer_ssid[32 + 1];
+extern struct wfd_oem_operations *g_ops;
+
+
+int plugin_load(struct wfd_oem_operations **ops);
+
+#endif //__WIFI_DIRECT_OEM_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "wifi-direct-oem.h"
+#include "wifi-direct-utils.h"
+
+unsigned char g_incomming_peer_mac_address[6];
+char g_incomming_peer_ssid[32 + 1];
+struct wfd_oem_operations *g_ops;
+
+int wfd_oem_init(wfd_oem_event_cb event_callback)
+{
+ if (NULL == g_ops->wfd_oem_init)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_init is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_init(event_callback));
+}
+
+int wfd_oem_destroy()
+{
+ if (NULL == g_ops->wfd_oem_destroy)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_destroy is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_destroy());
+}
+
+int wfd_oem_activate()
+{
+ if (NULL == g_ops->wfd_oem_activate)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_activate is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_activate());
+}
+
+int wfd_oem_deactivate()
+{
+ if (NULL == g_ops->wfd_oem_deactivate)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_deactivate is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_deactivate());
+}
+
+
+int wfd_oem_connect(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config)
+{
+ if (NULL == g_ops->wfd_oem_connect)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_connect is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_connect(mac_addr, wps_config));
+}
+
+int wfd_oem_wps_pbc_start()
+{
+ if (NULL == g_ops->wfd_oem_wps_pbc_start)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_wps_pbc_start is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_wps_pbc_start());
+}
+
+int wfd_oem_disconnect()
+{
+ if (NULL == g_ops->wfd_oem_disconnect)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_disconnect is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_disconnect());
+}
+
+
+int wfd_oem_disconnect_sta(unsigned char mac_addr[6])
+{
+ if (NULL == g_ops->wfd_oem_disconnect_sta)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_disconnect_sta is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_disconnect_sta(mac_addr));
+}
+
+bool wfd_oem_is_discovery_enabled()
+{
+ if (NULL == g_ops->wfd_oem_is_discovery_enabled)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_is_discovery_enabled is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_is_discovery_enabled());
+}
+
+int wfd_oem_start_discovery(bool listen_only, int timeout)
+{
+ if (NULL == g_ops->wfd_oem_start_discovery)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_start_discovery is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_start_discovery(listen_only, timeout));
+}
+
+int wfd_oem_cancel_discovery()
+{
+ if (NULL == g_ops->wfd_oem_cancel_discovery)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_cancel_discovery is NULL!!\n");
+ return false;
+ }
+
+ wfd_timer_discovery_cancel();
+
+ return (g_ops->wfd_oem_cancel_discovery());
+}
+
+int wfd_oem_get_discovery_result(wfd_discovery_entry_s ** peer_list, int* peer_num)
+{
+ if (NULL == g_ops->wfd_oem_get_discovery_result)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_discovery_result is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_discovery_result(peer_list, peer_num));
+}
+
+int wfd_oem_get_peer_info(unsigned char *mac_addr, wfd_discovery_entry_s **peer)
+{
+ if (NULL == g_ops->wfd_oem_get_peer_info)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_peer_info is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_peer_info(mac_addr, peer));
+}
+
+int wfd_oem_send_provision_discovery_request(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go)
+{
+ if (NULL == g_ops->wfd_oem_send_provision_discovery_request)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_send_provision_discovery_request is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_send_provision_discovery_request(mac_addr, config_method, is_peer_go));
+}
+
+int wfd_oem_send_invite_request(unsigned char dev_mac_addr[6])
+{
+ if (NULL == g_ops->wfd_oem_send_invite_request)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_send_invite_request is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_send_invite_request(dev_mac_addr));
+}
+
+
+int wfd_oem_create_group(char* ssid)
+{
+ if (NULL == g_ops->wfd_oem_create_group)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_create_group is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_create_group(ssid));
+}
+
+int wfd_oem_cancel_group()
+{
+ if (NULL == g_ops->wfd_oem_cancel_group)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_cancel_group is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_cancel_group());
+}
+
+int wfd_oem_activate_pushbutton()
+{
+ if (NULL == g_ops->wfd_oem_activate_pushbutton)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_activate_pushbutton is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_activate_pushbutton());
+}
+
+bool wfd_oem_is_groupowner()
+{
+ if (NULL == g_ops->wfd_oem_is_groupowner)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_is_groupowner is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_is_groupowner());
+}
+
+bool wfd_oem_is_groupclient()
+{
+ if (NULL == g_ops->wfd_oem_is_groupclient)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_is_groupclient is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_is_groupclient());
+}
+
+#if 0
+int wfd_oem_get_link_status()
+{
+ if (NULL == g_ops->wfd_oem_get_link_status)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_link_status is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_link_status());
+}
+#endif
+
+int wfd_oem_get_ssid(char* ssid, int len)
+{
+ if (NULL == g_ops->wfd_oem_get_ssid)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_ssid is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_ssid(ssid, len));
+}
+
+bool wfd_oem_dhcpc_get_ip_address(char *ipaddr_buf, int len, int is_IPv6)
+{
+ if (NULL == g_ops->wfd_oem_dhcpc_get_ip_address)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_dhcpc_get_ip_address is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_dhcpc_get_ip_address(ipaddr_buf, len, is_IPv6));
+}
+
+
+char* wfd_oem_get_default_interface_name()
+{
+ if (NULL == g_ops->wfd_oem_get_default_interface_name)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_default_interface_name is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_default_interface_name());
+}
+
+char* wfd_oem_get_ip()
+{
+ if (NULL == g_ops->wfd_oem_get_ip)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_ip is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_ip());
+}
+
+int wfd_oem_set_wps_pin(char* pin)
+{
+ if (NULL == g_ops->wfd_oem_set_wps_pin)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_set_wps_pin is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_set_wps_pin(pin));
+}
+
+int wfd_oem_get_wps_pin(char* wps_pin, int len)
+{
+ if (NULL == g_ops->wfd_oem_get_wps_pin)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_wps_pin is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_wps_pin(wps_pin, len));
+}
+
+int wfd_oem_generate_wps_pin()
+{
+ if (NULL == g_ops->wfd_oem_generate_wps_pin)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_generate_wps_pin is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_generate_wps_pin());
+}
+
+
+int wfd_oem_set_ssid(char* ssid)
+{
+ if (NULL == g_ops->wfd_oem_set_ssid)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_set_ssid is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_set_ssid(ssid));
+}
+
+int wfd_oem_set_wpa_passphrase(char* wpa_key)
+{
+ if (NULL == g_ops->wfd_oem_set_wpa_passphrase)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_set_wpa_passphrase is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_set_wpa_passphrase(wpa_key));
+}
+
+int wfd_oem_get_supported_wps_mode()
+{
+ if (NULL == g_ops->wfd_oem_get_supported_wps_mode)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_supported_wps_mode is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_supported_wps_mode());
+}
+
+int wfd_oem_get_connected_peers_count(int* peer_num)
+{
+ if (NULL == g_ops->wfd_oem_get_connected_peers_count)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_connected_peers_count is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_connected_peers_count(peer_num));
+}
+
+
+int wfd_oem_get_connected_peers_info(wfd_connected_peer_info_s ** peer_list, int* peer_num)
+{
+ if (NULL == g_ops->wfd_oem_get_connected_peers_info)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_connected_peers_info is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_connected_peers_info(peer_list, peer_num));
+}
+
+
+int wfd_oem_get_go_intent(int* intent)
+{
+ if (NULL == g_ops->wfd_oem_get_go_intent)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_go_intent is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_go_intent(intent));
+}
+
+
+int wfd_oem_set_go_intent(int intent)
+{
+ if (NULL == g_ops->wfd_oem_set_go_intent)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_set_go_intent is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_set_go_intent(intent));
+}
+
+
+int wfd_oem_set_device_type(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat)
+{
+ if (NULL == g_ops->wfd_oem_set_device_type)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_set_device_type is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_set_device_type(primary_cat, sub_cat));
+}
+
+
+int wfd_oem_get_device_mac_address(unsigned char* device_mac)
+{
+ if (NULL == g_ops->wfd_oem_get_device_mac_address)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_device_mac_address is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_device_mac_address(device_mac));
+}
+
+int wfd_oem_set_oem_loglevel(int is_increase)
+{
+ if (NULL == g_ops->wfd_oem_set_oem_loglevel)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_set_oem_loglevel is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_set_oem_loglevel(is_increase));
+}
+
+int wfd_oem_get_disassoc_sta_mac(unsigned char *mac_addr)
+{
+ if (NULL == g_ops->wfd_oem_get_disassoc_sta_mac)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_disassoc_sta_mac is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_disassoc_sta_mac(mac_addr));
+}
+
+int wfd_oem_get_assoc_sta_mac(unsigned char *mac_addr)
+{
+ if (NULL == g_ops->wfd_oem_get_assoc_sta_mac)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_assoc_sta_mac is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_assoc_sta_mac(mac_addr));
+}
+
+int wfd_oem_get_requestor_mac(unsigned char *mac_addr)
+{
+ if (NULL == g_ops->wfd_oem_get_requestor_mac)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_requestor_mac is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_requestor_mac(mac_addr));
+}
+
+int wfd_oem_get_operating_channel()
+{
+ if (NULL == g_ops->wfd_oem_get_operating_channel)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_operating_channel is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_operating_channel());
+}
+
+int wfd_oem_get_persistent_group_info(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num)
+{
+ if (NULL == g_ops->wfd_oem_get_persistent_group_info)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_get_persistent_group_info is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_get_persistent_group_info(persistent_group_list, persistent_group_num));
+}
+
+int wfd_oem_remove_persistent_group(wfd_persistent_group_info_s *persistent_group)
+{
+ if (NULL == g_ops->wfd_oem_remove_persistent_group)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "g_ops->wfd_oem_remove_persistent_group is NULL!!\n");
+ return false;
+ }
+
+ return (g_ops->wfd_oem_remove_persistent_group(persistent_group));
+
+}
--- /dev/null
+Name: wifi-direct-manager
+Summary: Wi-Fi Direct manger
+Version: 0.4.0
+Release: 1
+Group: TO_BE_FILLED
+License: Samsung Proprietary License
+Source0: %{name}-%{version}.tar.gz
+Requires(post): /usr/bin/vconftool
+BuildRequires: pkgconfig(wifi-direct)
+BuildRequires: pkgconfig(dbus-glib-1)
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(vconf)
+BuildRequires: pkgconfig(capi-appfw-application)
+BuildRequires: cmake
+
+
+#%define debug_package %{nil}
+
+%description
+Wi-Fi Direct manager
+
+%package -n wifi-direct-plugin-wpasupplicant
+Summary: wifi drect plugin for wpa supplicant
+Group: TO_BE_FILLED
+Requires: %{name} = %{version}-%{release}
+
+%description -n wifi-direct-plugin-wpasupplicant
+wifi drect plugin for wpa supplicant
+
+
+%prep
+%setup -q
+
+%ifarch %{arm}
+export ARCH=arm
+%else
+export ARCH=i586
+%endif
+
+%build
+
+cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix}
+make %{?jobs:-j%jobs}
+
+%install
+rm -rf %{buildroot}
+%make_install
+%__strip %{buildroot}%{_libdir}/wifi-direct-plugin-wpasupplicant.so
+%__strip %{buildroot}%{_bindir}/wfd-manager
+
+mkdir -p %{buildroot}/usr/share/license
+cp %{_builddir}/%{buildsubdir}/LICENSE %{buildroot}/usr/share/license/%{name}
+cp %{_builddir}/%{buildsubdir}/LICENSE %{buildroot}/usr/share/license/wifi-direct-plugin-wpasupplicant
+
+%post
+chmod 644 /usr/etc/wifi-direct/dhcpd.p2p.conf
+chmod 644 /usr/etc/wifi-direct/dhcpd.wl0.conf
+chmod 644 /usr/etc/wifi-direct/dhcpd.eth.conf
+chmod 755 /usr/bin/dhcpd-notify.sh
+chmod 755 /usr/etc/wifi-direct/udhcp_script.non-autoip
+chmod 755 /usr/bin/wifi-direct-server.sh
+chmod 755 /usr/bin/wifi-direct-dhcp.sh
+chmod 755 /usr/sbin/p2p_supp.sh
+
+vconftool set -t int memory/wifi_direct/state 0 -u 5000 -i
+vconftool set -t int memory/private/wifi_direct_manager/dhcp_ip_lease 0 -i
+vconftool set -t string memory/private/wifi_direct_manager/dhcpc_server_ip 0.0.0.0 -i
+
+%postun
+
+%files
+%manifest wifi-direct-manager.manifest
+%defattr(-,root,root,-)
+%{_bindir}/wfd-manager
+/usr/etc/wifi-direct/dhcpd.p2p.conf
+/usr/etc/wifi-direct/dhcpd.wl0.conf
+/usr/etc/wifi-direct/dhcpd.eth.conf
+/usr/etc/wifi-direct/udhcp_script.non-autoip
+/usr/etc/wifi-direct/p2p_suppl.conf
+%{_bindir}/dhcpd-notify.sh
+%{_bindir}/wifi-direct-server.sh
+%{_bindir}/wifi-direct-dhcp.sh
+%{_sbindir}/p2p_supp.sh
+%attr(755,-,-) %{_bindir}/dhcpd-notify.sh
+%attr(755,-,-) %{_bindir}/wifi-direct-server.sh
+%attr(755,-,-) %{_bindir}/wifi-direct-dhcp.sh
+%attr(755,-,-) /usr/etc/wifi-direct/udhcp_script.non-autoip
+%attr(755,-,-) %{_sbindir}/p2p_supp.sh
+/usr/share/license/%{name}
+
+%files -n wifi-direct-plugin-wpasupplicant
+%manifest wifi-direct-plugin-wpasupplicant.manifest
+%defattr(-,root,root,-)
+%{_libdir}/wifi-direct-plugin-wpasupplicant.so
+/usr/share/license/wifi-direct-plugin-wpasupplicant
+%attr(755,-,-) %{_sbindir}/p2p_supplicant
+
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(wifi-direct-plugin-wpasupplicant C)
+
+# Set required packages
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED wifi-direct vconf glib-2.0 dbus-1 dbus-glib-1 gthread-2.0 dlog)
+
+FOREACH(flag ${pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag} -g -DVITA_FEATURE")
+ENDFOREACH(flag)
+
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/include
+ ${CMAKE_SOURCE_DIR}/oem/include
+ ${CMAKE_SOURCE_DIR}/src/include)
+
+SET(CMAKE_C_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CFLAGS} -Wall")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2")
+
+ADD_DEFINITIONS("-DPREFIX=\"${PREFIX}\"")
+
+
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+IF("${ARCH}" MATCHES "^arm.*")
+
+ SET(SRCS
+ src/wifi-direct-plugin.c
+ )
+
+ MESSAGE("Build for Target")
+
+ # library build
+ ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS})
+ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS})
+ #SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION 0.1.0)
+ SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES PREFIX "" OUTPUT_NAME ${PROJECT_NAME})
+
+ # install
+ INSTALL(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION lib)
+
+ELSE()
+
+ SET(SRCS
+ src/wifi-direct-plugin-emul.c
+ )
+
+ MESSAGE("Build for Emulator")
+
+ # library build
+ ADD_LIBRARY(${PROJECT_NAME} SHARED ${SRCS})
+ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS})
+ #SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES SOVERSION 0.1.0)
+ SET_TARGET_PROPERTIES(${PROJECT_NAME} PROPERTIES PREFIX "" OUTPUT_NAME ${PROJECT_NAME})
+
+ # install
+ INSTALL(TARGETS ${PROJECT_NAME} LIBRARY DESTINATION lib)
+
+ENDIF()
+
--- /dev/null
+
+#ifndef __WFD_WPA_SUPPLICANT_H_
+#define __WFD_WPA_SUPPLICANT_H_
+
+#include <stdio.h>
+#include <stdbool.h>
+#include <string.h>
+#include <net/ethernet.h>
+
+#define DEFAULT_IF_NAME "p2p-wlan0-0"
+#define DEFAULT_IF_NAME_LEN 12
+//#define DEFAULT_SSID_NAME "BcmDevice00"
+//#define DEFAULT_DISCOVERY_TMO_SECS 3600
+//#define DEFAULT_CONNECT_TMO_SECS 60
+//#define DISCOVERY_MAX_PEERS 64
+#define DEFAULT_IP_LOG_PATH "/tmp/udhcpc_log"
+#define DEFAULT_SERVER_IP "192.168.16.1"
+#define FREQUENCY_2G "freq=2"
+#define MAX_PEER_NUM 10
+#define MAX_PERSISTENT_GROUP_NUM 20
+
+#define BIT(n) 1<<(n-1)
+
+/* Device Capability bitmap */
+#define DEVICE_CAPAB_SERVICE_DISCOVERY BIT(1)
+#define DEVICE_CAPAB_CLIENT_DISCOVERABILITY BIT(2)
+#define DEVICE_CAPAB_CONCURRENT_OPER BIT(3)
+#define DEVICE_CAPAB_INFRA_MANAGED BIT(4)
+#define DEVICE_CAPAB_DEVICE_LIMIT BIT(5)
+#define DEVICE_CAPAB_INVITATION_PROCEDURE BIT(6)
+
+/* Group Capability bitmap */
+#define GROUP_CAPAB_GROUP_OWNER BIT(1)
+#define GROUP_CAPAB_PERSISTENT_GROUP BIT(2)
+#define GROUP_CAPAB_GROUP_LIMIT BIT(3)
+#define GROUP_CAPAB_INTRA_BSS_DIST BIT(4)
+#define GROUP_CAPAB_CROSS_CONN BIT(5)
+#define GROUP_CAPAB_PERSISTENT_RECONN BIT(6)
+#define GROUP_CAPAB_GROUP_FORMATION BIT(7)
+
+/* WPS config methods supported */
+#define WPS_CONFIG_DISPLAY BIT(4) //0x0008;
+#define WPS_CONFIG_PUSHBUTTON BIT(8) //0x0080;
+#define WPS_CONFIG_KEYPAD BIT(9) //0x0100;
+
+#define WIFI_ALLIANCE_OUI "0050F204" // wifi direct spec Annex B.2
+
+typedef void (*wfd_noti_cb) (int event_type);
+
+#define CMD_INTERFACE "INTERFACES"
+#define CMD_INTERFACE_ADD "INTERFACE_ADD"
+#define CMD_INTERFACE_REMOVE "INTERFACE_REMOVE"
+#define CMD_ATTACH "ATTACH"
+#define CMD_DETACH "DETACH"
+#define CMD_START_DISCOVER "P2P_FIND"
+#define CMD_START_LISTEN "P2P_LISTEN"
+#define CMD_CANCEL_DISCOVER "P2P_STOP_FIND"
+#define CMD_FLUSH "P2P_FLUSH"
+#define CMD_GET_FIRST_DISCOVERED_PEER "P2P_PEER FIRST"
+#define CMD_GET_NEXT_DISCOVERED_PEER "P2P_PEER NEXT-"
+#define CMD_SEND_PROVISION_DISCOVERY_REQ "P2P_PROV_DISC"
+#define CMD_SEND_INVITE_REQ "P2P_INVITE"
+#define CMD_CREATE_GROUP "P2P_GROUP_ADD"
+#define CMD_CONNECT "P2P_CONNECT"
+#define CMD_WPS_PUSHBUTTON_START "WPS_PBC"
+#define CMD_GET_PEER_INFO "P2P_PEER"
+#define CMD_SET_PARAM "SET"
+#define CMD_GET_PARAM "GET"
+#define CMD_STATUS "STATUS"
+#define CMD_STATUS_P2P "STATUS P2P"
+#define CMD_LOG_LEVEL "LOG_LEVEL"
+#define CMD_GROUP_REMOVE "P2P_GROUP_REMOVE"
+#define CMD_QUIT "QUIT"
+#define CMD_TERMINATE "TERMINATE"
+#define CMD_GET_LIST_NETWORKS "LIST_NETWORKS"
+#define CMD_REMOVE_NETWORK "REMOVE_NETWORK"
+
+
+/*----- Miracast -----*/
+#define CMD_WFD_SET "WFD_SET"
+
+
+typedef enum
+{
+ WS_PEER_INFO_AGE,
+ WS_PEER_INFO_LISTEN_FREQ,
+ WS_PEER_INFO_LEVEL,
+ WS_PEER_INFO_WPS_METHOD,
+ WS_PEER_INFO_INTERFACE_ADDR,
+ WS_PEER_INFO_MEMBER_IN_GO_DEV,
+ WS_PEER_INFO_MEMBER_IN_GO_IFACE,
+ WS_PEER_INFO_PRI_DEV_TYPE,
+ WS_PEER_INFO_DEVICE_NAME,
+ WS_PEER_INFO_MANUFACTURER,
+ WS_PEER_INFO_MODEL_NAME,
+ WS_PEER_INFO_MODEL_NUMBER,
+ WS_PEER_INFO_SERIAL_NUMBER,
+ WS_PEER_INFO_CONFIG_METHODS,
+ WS_PEER_INFO_DEV_CAPAB,
+ WS_PEER_INFO_GROUP_CAPAB,
+ WS_PEER_INFO_GO_NEG_REQ_SENT,
+ WS_PEER_INFO_GO_STATE,
+ WS_PEER_INFO_DIALOG_TOKEN,
+ WS_PEER_INFO_INTENDED_ADDR,
+ WS_PEER_INFO_COUNTRY,
+ WS_PEER_INFO_OPER_FREQ,
+ WS_PEER_INFO_REQ_CONFIG_METHODS,
+ WS_PEER_INFO_FLAGS,
+ WS_PEER_INFO_STATUS,
+ WS_PEER_INFO_WAIT_COUNT,
+ WS_PEER_INFO_INVITATION_REQS,
+ WS_PEER_INFO_OPER_SSID,
+
+/*----- Miracast -----*/
+ WS_PEER_INFO_IS_WFD_DEVICE,
+
+ WS_PEER_INFO_NONE
+} ws_field_id_e;
+
+typedef struct
+{
+ char* item_str;
+ ws_field_id_e item_id;
+} ws_field_id_s;
+
+ws_field_id_s g_ws_field_info[] =
+{
+ {"age", WS_PEER_INFO_AGE},
+ {"listen_freq", WS_PEER_INFO_LISTEN_FREQ},
+ {"level", WS_PEER_INFO_LEVEL},
+ {"wps_method", WS_PEER_INFO_WPS_METHOD},
+ {"interface_addr", WS_PEER_INFO_INTERFACE_ADDR},
+ {"member_in_go_dev", WS_PEER_INFO_MEMBER_IN_GO_DEV},
+ {"member_in_go_iface", WS_PEER_INFO_MEMBER_IN_GO_IFACE},
+ {"pri_dev_type", WS_PEER_INFO_PRI_DEV_TYPE},
+ {"device_name", WS_PEER_INFO_DEVICE_NAME},
+ {"manufacturer", WS_PEER_INFO_MANUFACTURER},
+ {"model_name", WS_PEER_INFO_MODEL_NAME},
+ {"model_number", WS_PEER_INFO_MODEL_NUMBER},
+ {"serial_number", WS_PEER_INFO_SERIAL_NUMBER},
+ {"config_methods", WS_PEER_INFO_CONFIG_METHODS},
+ {"dev_capab", WS_PEER_INFO_DEV_CAPAB},
+ {"group_capab", WS_PEER_INFO_GROUP_CAPAB},
+ {"go_neg_req_sent", WS_PEER_INFO_GO_NEG_REQ_SENT},
+ {"go_state", WS_PEER_INFO_GO_STATE},
+ {"dialog_token", WS_PEER_INFO_DIALOG_TOKEN},
+ {"intended_addr", WS_PEER_INFO_INTENDED_ADDR},
+ {"country", WS_PEER_INFO_COUNTRY},
+ {"oper_freq", WS_PEER_INFO_OPER_FREQ},
+ {"req_config_methods", WS_PEER_INFO_REQ_CONFIG_METHODS},
+ {"flags", WS_PEER_INFO_FLAGS},
+ {"status", WS_PEER_INFO_STATUS},
+ {"wait_count", WS_PEER_INFO_WAIT_COUNT},
+ {"invitation_reqs", WS_PEER_INFO_INVITATION_REQS},
+ {"oper_ssid", WS_PEER_INFO_OPER_SSID},
+
+/*----- Miracast -----*/
+ {"is_wfd_device", WS_PEER_INFO_IS_WFD_DEVICE},
+
+ {"", WS_PEER_INFO_NONE}
+};
+
+typedef struct
+{
+ char mac[18];
+ int age;
+ int listen_freq;
+ int level;
+ char wps_method[32];
+ char interface_addr[18];
+ char member_in_go_dev[18];
+ char member_in_go_iface[18];
+ char pri_dev_type[18];
+ char device_name[64];
+ char manufacturer[64];
+ char model_name[64];
+ char model_number[64];
+ char serial_number[64];
+ unsigned int config_methods;
+ unsigned int dev_capab;
+ unsigned int group_capab;
+ unsigned int go_neg_req_sent;
+ char go_state[32];
+ int dialog_token;
+ char intended_addr[18];
+ char country[8];
+ unsigned int oper_freq;
+ unsigned int req_config_methods;
+ char flags[128];
+ char status[16];
+ int wait_count;
+ int invitation_reqs;
+ char oper_ssid[64];
+
+/*----- Miracast -----*/
+ int is_wfd_device;
+ } ws_discovered_peer_info_s;
+
+typedef struct
+{
+ int network_id;
+ char ssid[64];
+ char bssid[18];
+ char flags[32];
+ } ws_network_info_s;
+
+
+/** Event notification code */
+typedef enum {
+ WS_EVENT_NONE = 0,
+
+ WS_EVENT_DISCOVER_FOUND_PEER,
+
+ WS_EVENT_PROVISION_DISCOVERY_RESPONSE,
+ WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY,
+ WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD,
+ WS_EVENT_PROVISION_DISCOVERY_PBC_REQ,
+ WS_EVENT_PROVISION_DISCOVERY_DISPLAY,
+ WS_EVENT_PROVISION_DISCOVERY_KEYPAD,
+
+ WS_EVENT_GROUP_STARTED,
+ WS_EVENT_GROUP_REMOVED,
+
+ WS_EVENT_CONNECTED,
+ WS_EVENT_STA_CONNECTED,
+
+ WS_EVENT_DISCONNECTED,
+ WS_EVENT_STA_DISCONNECTED,
+
+ WS_EVENT_INVITATION_REQ,
+ WS_EVENT_INVITATION_RSP,
+
+ WS_EVENT_TERMINATING,
+
+} ws_event_id_e;
+
+
+typedef struct
+{
+ char* str;
+ ws_event_id_e id;
+} ws_event_id_s;
+
+ws_event_id_s g_ws_event_info[] =
+{
+ // discovery
+ {"P2P-DEVICE-FOUND", WS_EVENT_DISCOVER_FOUND_PEER},
+
+ // provision discovery
+ {"P2P-PROV-DISC-PBC-RESP", WS_EVENT_PROVISION_DISCOVERY_RESPONSE},
+ {"P2P-PROV-DISC-PBC-REQ", WS_EVENT_PROVISION_DISCOVERY_PBC_REQ},
+ {"P2P-PROV-DISC-SHOW-PIN", WS_EVENT_PROVISION_DISCOVERY_DISPLAY},
+ {"P2P-PROV-DISC-ENTER-PIN", WS_EVENT_PROVISION_DISCOVERY_KEYPAD},
+
+ // connection
+ {"P2P-GROUP-STARTED", WS_EVENT_GROUP_STARTED},
+ {"P2P-GROUP-REMOVED", WS_EVENT_GROUP_REMOVED},
+
+ {"CTRL-EVENT-CONNECTED", WS_EVENT_CONNECTED},
+ {"AP-STA-CONNECTED", WS_EVENT_STA_CONNECTED},
+ {"CTRL-EVENT-DISCONNECTED", WS_EVENT_DISCONNECTED},
+ {"AP-STA-DISCONNECTED", WS_EVENT_STA_DISCONNECTED},
+
+ // invite
+ {"P2P-INVITATION-RECEIVED", WS_EVENT_INVITATION_REQ},
+ {"P2P-INVITATION-RESULT", WS_EVENT_INVITATION_RSP},
+
+
+ {"CTRL-EVENT-TERMINATING", WS_EVENT_TERMINATING},
+
+ {"", WS_EVENT_NONE}
+};
+
+typedef struct
+{
+ ws_event_id_e id;
+ char peer_mac_address[18];
+ char peer_intf_mac_address[18];
+ char peer_ssid[32];
+} ws_event_s;
+
+typedef struct
+{
+ char* freq;
+ int channel;
+} ws_op_channel_s;
+
+ws_op_channel_s g_ws_op_channel_info[] =
+{
+ /* 2 GHz */
+ {"2412", 1}, {"2417", 2}, {"2422", 3}, {"2427", 4}, {"2432", 5},
+ {"2437", 6}, {"2442", 7}, {"2447", 8}, {"2452", 9}, {"2457", 10},
+ {"2462", 11}, {"2467", 12}, {"2472", 13}, {"2484", 14},
+
+ /* 5 GHz */
+ {"5180", 36}, {"5190", 38}, {"5200", 40}, {"5210", 42}, {"5220", 44},
+ {"5230", 46}, {"5240", 48}, {"5260", 52}, {"5280", 56}, {"5300", 60},
+ {"5320", 64}, {"5500", 100}, {"5520", 104}, {"5540", 108}, {"5560", 112},
+ {"5580", 116}, {"5600", 120}, {"5620", 124}, {"5640", 128}, {"5660", 132},
+ {"5680", 136}, {"5700", 140}, {"5745", 149}, {"5765", 153}, {"5785", 157},
+ {"5805", 161}, {"5825", 165},
+
+ {"", 0}
+};
+
+
+int wfd_ws_init(wfd_oem_event_cb event_callback);
+int wfd_ws_destroy();
+int wfd_ws_activate();
+int wfd_ws_deactivate();
+int wfd_ws_connect(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config);
+int wfd_ws_disconnect();
+int wfd_ws_disconnect_sta(unsigned char mac_addr[6]);
+bool wfd_ws_is_discovery_enabled();
+int wfd_ws_start_discovery(bool listen_only, int timeout);
+int wfd_ws_cancel_discovery();
+int wfd_ws_get_discovery_result(wfd_discovery_entry_s ** peer_list, int* peer_num);
+int wfd_ws_get_peer_info(unsigned char *mac_addr, wfd_discovery_entry_s **peer);
+int wfd_ws_send_provision_discovery_request(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go);
+int wfd_ws_send_invite_request(unsigned char dev_mac_addr[6]);
+int wfd_ws_create_group(char* ssid);
+int wfd_ws_cancel_group();
+int wfd_ws_activate_pushbutton();
+bool wfd_ws_is_groupowner();
+bool wfd_ws_is_groupclient();
+int wfd_ws_get_ssid(char* ssid, int len);
+char* wfd_ws_get_default_interface_name();
+bool wfd_ws_dhcpc_get_ip_address(char *ipaddr_buf, int len, int is_IPv6);
+char* wfd_ws_get_ip();
+int wfd_ws_set_wps_pin(char* pin);
+int wfd_ws_get_wps_pin(char* wps_pin, int len);
+int wfd_ws_generate_wps_pin();
+int wfd_ws_set_ssid(char* ssid);
+int wfd_ws_set_wpa_passphrase(char* wpa_key);
+int wfd_ws_get_supported_wps_mode();
+int wfd_ws_get_connected_peers_count(int* peer_num);
+int wfd_ws_get_connected_peers_info(wfd_connected_peer_info_s ** peer_list, int* peer_num);
+int wfd_ws_get_go_intent();
+int wfd_ws_set_go_intent(int go_intent);
+int wfd_ws_set_device_type(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat);
+int wfd_ws_get_device_mac_address(unsigned char* device_mac);
+int wfd_ws_set_oem_loglevel(int is_increase);
+int wfd_ws_get_assoc_sta_mac(unsigned char *mac_addr);
+int wfd_ws_get_disassoc_sta_mac(unsigned char *mac_addr);
+int wfd_ws_get_requestor_mac(unsigned char *mac_addr);
+int wfd_ws_get_operating_channel(void);
+bool wfd_ws_flush();
+int wfd_ws_dsp_init(void);
+int wfd_ws_get_persistent_group_info(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num);
+int wfd_ws_remove_persistent_group(wfd_persistent_group_info_s *persistent_group);
+
+#endif /** __WFD_WPA_SUPPLICANT_H_ */
+
--- /dev/null
+/**
+ * Copyright (c) 2000~2008 Samsung Electronics, Inc.
+ * All rights reserved.
+ *
+ * This software is a confidential and proprietary information
+ * of Samsung Electronics, Inc. ("Confidential Information"). You
+ * shall not disclose such Confidential Information and shall use
+ * it only in accordance with the terms of the license agreement
+ * you entered into with Samsung Electronics.
+ */
+/**
+ * This file implements wifi direct oem functions.
+ *
+ * @file wifi-direct-oem.c
+ * @author Misun Kim (ms0123.kim@samsung.com)
+ * @author Dongwook Lee (ms0123.kim@samsung.com)
+ * @version 0.1
+ */
+
+#include <stdlib.h>
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "wifi-direct-utils.h"
+#include "wifi-direct-oem.h"
+#include "wifi-direct-service.h"
+#include "wifi-direct-wpasupplicant.h"
+
+
+unsigned char g_incomming_peer_mac_address[6] = {0,};
+char g_incomming_peer_ssid[32 + 1] = {0,};
+
+
+static struct wfd_oem_operations supplicant_ops =
+{
+ .wfd_oem_init = wfd_ws_init,
+ .wfd_oem_destroy = wfd_ws_destroy,
+ .wfd_oem_activate = wfd_ws_activate,
+ .wfd_oem_deactivate = wfd_ws_deactivate,
+ .wfd_oem_connect = wfd_ws_connect,
+ .wfd_oem_disconnect = wfd_ws_disconnect,
+ .wfd_oem_disconnect_sta = wfd_ws_disconnect_sta,
+ .wfd_oem_start_discovery = wfd_ws_start_discovery,
+ .wfd_oem_cancel_discovery = wfd_ws_cancel_discovery,
+ .wfd_oem_get_discovery_result = wfd_ws_get_discovery_result,
+ .wfd_oem_get_peer_info = wfd_ws_get_peer_info,
+ .wfd_oem_send_provision_discovery_request = wfd_ws_send_provision_discovery_request,
+ .wfd_oem_create_group = wfd_ws_create_group,
+ .wfd_oem_cancel_group = wfd_ws_cancel_group,
+ .wfd_oem_activate_pushbutton = wfd_ws_activate_pushbutton,
+ .wfd_oem_get_default_interface_name = wfd_ws_get_default_interface_name,
+ .wfd_oem_dhcpc_get_ip_address = wfd_ws_dhcpc_get_ip_address,
+ .wfd_oem_get_ip = wfd_ws_get_ip,
+ .wfd_oem_set_ssid = wfd_ws_set_ssid,
+ .wfd_oem_is_groupowner = wfd_ws_is_groupowner,
+ .wfd_oem_get_ssid = wfd_ws_get_ssid,
+ .wfd_oem_set_wps_pin = wfd_ws_set_wps_pin,
+ .wfd_oem_get_wps_pin = wfd_ws_get_wps_pin,
+ .wfd_oem_generate_wps_pin = wfd_ws_generate_wps_pin,
+ .wfd_oem_set_wpa_passphrase = wfd_ws_set_wpa_passphrase,
+ .wfd_oem_get_supported_wps_mode = wfd_ws_get_supported_wps_mode,
+ .wfd_oem_get_connected_peers_info = wfd_ws_get_connected_peers_info,
+ .wfd_oem_get_connected_peers_count = wfd_ws_get_connected_peers_count,
+ .wfd_oem_set_oem_loglevel = wfd_ws_set_oem_loglevel,
+ .wfd_oem_get_go_intent = wfd_ws_get_go_intent,
+ .wfd_oem_set_go_intent = wfd_ws_set_go_intent,
+ .wfd_oem_get_device_mac_address = wfd_ws_get_device_mac_address,
+ .wfd_oem_get_disassoc_sta_mac = wfd_ws_get_disassoc_sta_mac,
+ .wfd_oem_get_assoc_sta_mac = wfd_ws_get_assoc_sta_mac,
+ .wfd_oem_get_requestor_mac = wfd_ws_get_requestor_mac,
+ .wfd_oem_get_operating_channel = wfd_ws_get_operating_channel,
+ .wfd_oem_get_persistent_group_info = wfd_ws_get_persistent_group_info,
+ .wfd_oem_remove_persistent_group = wfd_ws_remove_persistent_group,
+};
+
+
+#if 1 // Threadsafe event handling.
+
+void __wfd_ws_callback(wfd_event_t event)
+{
+
+}
+
+#else
+
+void __wfd_oem_callback(wfd_event_t event_type)
+{
+ if (g_oem_event_callback != NULL)
+ g_oem_event_callback(event_type);
+}
+
+#endif
+
+int wfd_ws_init(wfd_oem_event_cb event_callback)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_destroy()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ // Do nothing upto now...
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+}
+
+int wfd_ws_activate()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_deactivate()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_connect(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_disconnect()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_disconnect_sta(unsigned char mac_addr[6])
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+bool wfd_ws_is_discovery_enabled()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_start_discovery(bool listen_only, int timeout)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_cancel_discovery()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_discovery_result(wfd_discovery_entry_s ** peer_list, int* peer_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+
+}
+
+int wfd_ws_get_peer_info(unsigned char *mac_addr, wfd_discovery_entry_s **peer)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_send_provision_discovery_request(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_create_group(char* ssid)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_cancel_group()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_activate_pushbutton()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+bool wfd_ws_is_groupowner()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+bool wfd_ws_is_groupclient()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_ssid(char* ssid, int len)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+
+}
+
+bool wfd_ws_dhcpc_get_ip_address(char *ipaddr_buf, int len, int is_IPv6)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+char* wfd_ws_get_ip()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+
+}
+
+int wfd_ws_set_wps_pin(char* pin)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_wps_pin(char* wps_pin, int len)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_generate_wps_pin()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_set_ssid(char* ssid)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_set_wpa_passphrase(char* wpa_key)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_supported_wps_mode()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_connected_peers_count(int* peer_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_get_connected_peers_info(wfd_connected_peer_info_s ** peer_list, int* peer_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_get_go_intent(int* intent)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_set_go_intent(int go_intent)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_set_device_type(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_get_device_mac_address(unsigned char* device_mac)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_set_oem_loglevel(int is_increase)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+
+int wfd_ws_get_assoc_sta_mac(unsigned char mac_addr[6])
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+int wfd_ws_get_disassoc_sta_mac(unsigned char mac_addr[6])
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_requestor_mac(unsigned char mac_addr[6])
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_operating_channel()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_get_persistent_group_info(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
+int wfd_ws_remove_persistent_group(wfd_persistent_group_info_s *persistent_group)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ return false;
+}
+
--- /dev/null
+/**
+ * Copyright (c) 2000~2008 Samsung Electronics, Inc.
+ * All rights reserved.
+ *
+ * This software is a confidential and proprietary information
+ * of Samsung Electronics, Inc. ("Confidential Information"). You
+ * shall not disclose such Confidential Information and shall use
+ * it only in accordance with the terms of the license agreement
+ * you entered into with Samsung Electronics.
+ */
+/**
+ * This file implements wifi direct oem functions.
+ *
+ * @file wifi-direct-oem.c
+ * @author Sungsik Jang <sungsik.jang@samsung.com>
+ * @author Dongwook Lee <dwmax.lee@samsung.com>
+ * @version 0.1
+ */
+
+#include <stdlib.h>
+#include <stdbool.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#include <sys/un.h>
+#include <sys/poll.h>
+#include <net/if.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <sys/ioctl.h>
+
+#include "wifi-direct-utils.h"
+#include "wifi-direct-oem.h"
+#include "wifi-direct-service.h"
+#include "wifi-direct-wpasupplicant.h"
+
+#define MAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
+#define MACSTR "%02x:%02x:%02x:%02x:%02x:%02x"
+
+int g_global_sockfd;
+int g_control_sockfd;
+int g_monitor_sockfd;
+int g_source_id;
+
+static char g_local_interface_ip_address[20];
+static wfd_noti_cb g_noti_cb;
+wfd_oem_event_cb g_oem_event_callback;
+int g_oem_pipe[2];
+GList *g_conn_peer_addr;
+static unsigned char g_assoc_sta_mac[6];
+static unsigned char g_disassoc_sta_mac[6];
+
+static struct wfd_oem_operations supplicant_ops =
+{
+ .wfd_oem_init = wfd_ws_init,
+ .wfd_oem_destroy = wfd_ws_destroy,
+ .wfd_oem_activate = wfd_ws_activate,
+ .wfd_oem_deactivate = wfd_ws_deactivate,
+ .wfd_oem_connect = wfd_ws_connect,
+ .wfd_oem_wps_pbc_start = wfd_ws_wps_pbc_start,
+ .wfd_oem_disconnect = wfd_ws_disconnect,
+ .wfd_oem_disconnect_sta = wfd_ws_disconnect_sta,
+ .wfd_oem_is_discovery_enabled = wfd_ws_is_discovery_enabled,
+ .wfd_oem_start_discovery = wfd_ws_start_discovery,
+ .wfd_oem_cancel_discovery = wfd_ws_cancel_discovery,
+ .wfd_oem_get_discovery_result = wfd_ws_get_discovery_result,
+ .wfd_oem_get_peer_info = wfd_ws_get_peer_info,
+ .wfd_oem_send_provision_discovery_request = wfd_ws_send_provision_discovery_request,
+ .wfd_oem_send_invite_request = wfd_ws_send_invite_request,
+ .wfd_oem_create_group = wfd_ws_create_group,
+ .wfd_oem_cancel_group = wfd_ws_cancel_group,
+ .wfd_oem_activate_pushbutton = wfd_ws_activate_pushbutton,
+ .wfd_oem_get_default_interface_name = wfd_ws_get_default_interface_name,
+ .wfd_oem_dhcpc_get_ip_address = wfd_ws_dhcpc_get_ip_address,
+ .wfd_oem_get_ip = wfd_ws_get_ip,
+ .wfd_oem_set_ssid = wfd_ws_set_ssid,
+ .wfd_oem_is_groupowner = wfd_ws_is_groupowner,
+ .wfd_oem_get_ssid = wfd_ws_get_ssid,
+ .wfd_oem_set_wps_pin = wfd_ws_set_wps_pin,
+ .wfd_oem_get_wps_pin = wfd_ws_get_wps_pin,
+ .wfd_oem_generate_wps_pin = wfd_ws_generate_wps_pin,
+ .wfd_oem_set_wpa_passphrase = wfd_ws_set_wpa_passphrase,
+ .wfd_oem_get_supported_wps_mode = wfd_ws_get_supported_wps_mode,
+ .wfd_oem_get_connected_peers_info = wfd_ws_get_connected_peers_info,
+ .wfd_oem_get_connected_peers_count = wfd_ws_get_connected_peers_count,
+ .wfd_oem_set_oem_loglevel = wfd_ws_set_oem_loglevel,
+ .wfd_oem_get_go_intent = wfd_ws_get_go_intent,
+ .wfd_oem_set_go_intent = wfd_ws_set_go_intent,
+ .wfd_oem_set_device_type = wfd_ws_set_device_type,
+ .wfd_oem_get_device_mac_address = wfd_ws_get_device_mac_address,
+ .wfd_oem_get_disassoc_sta_mac = wfd_ws_get_disassoc_sta_mac,
+ .wfd_oem_get_assoc_sta_mac = wfd_ws_get_assoc_sta_mac,
+ .wfd_oem_get_requestor_mac = wfd_ws_get_requestor_mac,
+ .wfd_oem_get_operating_channel = wfd_ws_get_operating_channel,
+ .wfd_oem_get_persistent_group_info = wfd_ws_get_persistent_group_info,
+ .wfd_oem_remove_persistent_group = wfd_ws_remove_persistent_group,
+};
+
+int wfd_plugin_load( struct wfd_oem_operations **ops)
+{
+ *ops = &supplicant_ops;
+
+ return true;
+}
+
+static gboolean __wfd_oem_thread_safe_event_handler_cb(GIOChannel* source, GIOCondition condition, gpointer data)
+{
+ wfd_event_t event;
+ int n = 0;
+
+ // Read header part
+ n = read(g_oem_pipe[0], &event, sizeof(event));
+ if (n < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "pipe read error, Error=[%s]\n",strerror(errno));
+ return 0; // false
+ }
+
+ if (g_oem_event_callback != NULL)
+ g_oem_event_callback(event);
+
+ return true;
+}
+
+int __send_wpa_request(int sockfd, char *cmd, char *reply, size_t reply_buf_len)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ int result = 0;
+ size_t cmd_len;
+
+ int pollret = 0;
+ struct pollfd pollfd;
+ int timeout = 6000; /** for 6.0 sec */
+
+ if (sockfd <=0 )
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR,"Invalid argument sfd=[%d]\n", sockfd);
+ return false;
+ }
+
+ if(cmd == NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR,"Invalid argument. Command is NULL\n");
+ return false;
+ }
+ cmd_len = strlen(cmd);
+ WFD_SERVER_LOG(WFD_LOG_HIGH,"cmd [%s] cmd_len[%d]\n", cmd, cmd_len);
+
+ result = write(sockfd, cmd, cmd_len);
+ if ( result < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Send cmd failed: [%d]\n", result);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ for (;;)
+ {
+ pollfd.fd = sockfd;
+ pollfd.events = POLLIN | POLLERR | POLLHUP;
+ pollret = poll(&pollfd, 1, timeout);
+
+ if (pollret == 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "POLLing timeout. Nothing to read.\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+ }
+ else if (pollret < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR,"Polling error [%d]\n", pollret);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ else
+ {
+ if (pollfd.revents == POLLIN)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW,"POLLIN \n");
+ result = read(sockfd, (char *) reply, reply_buf_len);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW,"sockfd %d retval %d\n", sockfd, result);
+ WFD_SERVER_LOG(WFD_LOG_LOW,"reply[%s]\n", reply);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! reading data, error [%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ break;
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW,"POLL EVENT=%d ignored\n", pollfd.revents);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ }
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return result;
+}
+
+
+int __create_ctrl_intf(char *ctrl_intf_name, char *path)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ struct sockaddr_un servAddr;
+ struct sockaddr_un localAddr;
+ char local_path[32] = {0, };
+ int sockfd = 0;
+ int len = 0;
+ int ret = 0;
+
+ snprintf(local_path, sizeof(local_path), "/tmp/%s", ctrl_intf_name);
+ unlink(local_path);
+
+ errno = 0;
+ if ((sockfd = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! creating sync socket. Error = [%s].\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "Created socket [%d]\n", sockfd);
+
+ memset(&servAddr, 0, sizeof(servAddr));
+ servAddr.sun_family = AF_UNIX;
+ strcpy(servAddr.sun_path, path);
+ len = sizeof(servAddr.sun_family) + strlen(path);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Connecting to server socket to register socket [%d]\n", sockfd);
+
+ memset(&localAddr, 0, sizeof(localAddr));
+ localAddr.sun_family = AF_UNIX;
+ strcpy(localAddr.sun_path, local_path);
+
+ if (bind(sockfd, (struct sockaddr*)&localAddr, sizeof(localAddr)) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! bind(). Error = [%s]. Try again..\n", strerror(errno));
+
+ unlink(localAddr.sun_path);
+ if (bind(sockfd, (struct sockaddr*)&localAddr, sizeof(localAddr)) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! bind(). Error = [%s]. Give up..\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+ }
+
+ errno = 0;
+ if ((ret = connect(sockfd, (struct sockaddr *) &servAddr, sizeof(servAddr))) < 0)
+ {
+
+ if (unlink(path) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "unlink[ctrl_iface], Error=[%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ if (bind(sockfd, (struct sockaddr*)&servAddr, sizeof(servAddr)) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "bind[PF_UNIX], Error=[%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "Successfully replaced leftover ctrl_iface socket [%s]\n", path);
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return sockfd;
+}
+
+
+static int __read_socket_cb(int sockfd, char *dataptr, int datalen)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ int pollret = 0;
+ struct pollfd pollfd;
+ int timeout = 2000; /** for 2 sec */
+ int retval = 0;
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Reading msg from socketfd=[%d]\n", sockfd);
+
+ if (sockfd <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! Invalid socket FD [%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ if ((dataptr == NULL) || (datalen <= 0))
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! Invalid parameter\n");
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return -1;
+ }
+
+ //printf("@@@@@@@ len = %d @@@@@@@@@@@\n", datalen);
+
+ pollfd.fd = sockfd;
+ pollfd.events = POLLIN | POLLERR | POLLHUP;
+ pollret = poll(&pollfd, 1, timeout);
+
+ //printf("POLL ret = %d, \n", pollret);
+
+ if (pollret > 0)
+ {
+ if (pollfd.revents == POLLIN)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLLIN\n");
+
+ errno = 0;
+ retval = read(sockfd, (char *) dataptr, datalen);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "sockfd %d retval %d\n", sockfd, retval);
+ if (retval <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Error!!! reading data, Error=[%s]\n", strerror(errno));
+ }
+ __WFD_SERVER_FUNC_EXIT__;
+ return retval;
+ }
+ else if (pollfd.revents & POLLHUP)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLLHUP\n");
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return 0;
+ }
+ else if (pollfd.revents & POLLERR)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLLERR\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+ }
+ }
+ else if (pollret == 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLLing timeout \n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Polling unknown error \n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return 1;
+}
+
+
+void __polling_ip(char *ipaddr_buf, int len, int is_IPv6)
+{
+ int i = 0;
+
+ while(i < 24) {
+ if (wfd_ws_dhcpc_get_ip_address(ipaddr_buf, len, is_IPv6) == true)
+ {
+ return;
+ }
+ usleep(250);
+ i++;
+ }
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "** Failed to get IP address!!\n");
+}
+
+char* __get_event_str(char*ptr, char* event_str)
+{
+ char* p = ptr;
+ int c = 0;
+
+ event_str[0] = '\0';
+
+ if (p==NULL)
+ return NULL;
+
+ while(*p != '\n')
+ {
+ if (*p == '\0')
+ {
+ event_str[c] = '\0';
+ return NULL;
+ }
+
+ if (*p == ' ')
+ break;
+
+ event_str[c++] = *p++;
+ }
+ event_str[c]='\0';
+ p++;
+
+ return p;
+}
+
+int __extract_value_str(char *str, char *key, char *value)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ char *tmp_str = NULL;
+ int i = 0;
+
+ if(value == NULL)
+ return -1;
+
+ tmp_str = strstr(str, key);
+ if(tmp_str == NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Key[%s] is not found\n", key);
+ return -1;
+ }
+ tmp_str = tmp_str + strlen(key) + 1;
+ //WFD_SERVER_LOG(WFD_LOG_LOW, "tmp_str [%s]\n", tmp_str);
+
+ for(i = 0; tmp_str[i]; i++)
+ {
+ if(tmp_str[i] == '\n' || tmp_str[i] == '\r' || tmp_str[i] == ' ')
+ {
+ break;
+ }
+ }
+
+ memcpy(value, tmp_str, i);
+ value[i] = '\0';
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "extracted value [%s]\n", value);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return i;
+}
+
+
+int __is_white_space(char c)
+{
+ if (c < 32)
+ return 1;
+
+ return 0;
+}
+
+int __is_item_char(char c)
+{
+ if (c >= 'a' && c <= 'z')
+ return 1;
+
+ if (c >= 'A' && c <= 'Z')
+ return 1;
+
+ if (c >= '0' && c <= '9')
+ return 1;
+
+ if (c=='_')
+ return 1;
+
+ if (c=='-')
+ return 1;
+
+ if (c==':')
+ return 1;
+
+ if (c=='[')
+ return 1;
+
+ if (c==']')
+ return 1;
+
+ return 0;
+}
+
+
+char* __get_item_value(char*ptr, char* item, char* value)
+{
+ char* p = ptr;
+ int c = 0;
+
+ item[0] = '\0';
+ value[0]='\0';
+
+ if (p==NULL)
+ return NULL;
+
+ while(*p != '=')
+ {
+ if (*p == '\n')
+ {
+ item[c] = '\0';
+ return ++p;
+ }
+ if (*p == '\0')
+ {
+ item[c] = '\0';
+ return NULL;
+ }
+ if (__is_white_space(*p) || !__is_item_char(*p))
+ p++;
+ else
+ item[c++] = *p++;
+ }
+ item[c]='\0';
+ p++;
+
+ c=0;
+ while(*p != '\n')
+ {
+ if (*p == '\0')
+ {
+ value[c] = '\0';
+ return NULL;
+ }
+ if (__is_white_space(*p))
+ p++;
+ else
+ value[c++] = *p++;
+ }
+ value[c]='\0';
+ p++;
+
+ return p;
+}
+
+
+char* __get_persistent_group_value(char*ptr, ws_network_info_s* group)
+{
+ char* p = ptr;
+ int c;
+ char value[128];
+
+ if (p==NULL)
+ return NULL;
+
+ /* network_id */
+ c = 0;
+ memset(value, 0, sizeof(value));
+ while(__is_item_char(*p))
+ {
+ value[c++] = *p++;
+ }
+ group->network_id = atoi(value);
+
+ while(!__is_item_char(*p))
+ {
+ p++;
+ }
+
+ /* ssid */
+ c = 0;
+ memset(value, 0, sizeof(value));
+ while(__is_item_char(*p))
+ {
+ value[c++] = *p++;
+ }
+ strncpy(group->ssid, value, sizeof(group->ssid));
+
+ while(!__is_item_char(*p))
+ {
+ p++;
+ }
+
+ /* bssid */
+ c = 0;
+ memset(value, 0, sizeof(value));
+ while(__is_item_char(*p))
+ {
+ value[c++] = *p++;
+ }
+ strncpy(group->bssid, value, sizeof(group->bssid));
+
+ while(!__is_item_char(*p))
+ {
+ p++;
+ }
+
+ /* flags */
+ c = 0;
+ memset(value, 0, sizeof(value));
+ while(*p != '\n')
+ {
+ value[c++] = *p++;
+ }
+ strncpy(group->flags, value, sizeof(group->flags));
+
+ p++;
+ return p;
+}
+
+
+int __parsing_peer(char* buf, ws_discovered_peer_info_s* peer)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char* ptr = buf;
+ char item[64];
+ char value[128];
+ int i;
+ int item_id;
+
+ memset(peer, 0, sizeof(ws_discovered_peer_info_s));
+
+ // Get mac address
+ strncpy(peer->mac, ptr, 17);
+ peer->mac[18]='\0';
+ ptr += 17+1;
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "mac=%s\n", peer->mac);
+
+ for(;;)
+ {
+ ptr = __get_item_value(ptr, item, value);
+ if (ptr==NULL)
+ break;
+
+ //printf("item=%s, value=%s\n", item,value);
+
+ i=0;
+ item_id = WS_PEER_INFO_NONE;
+ while(g_ws_field_info[i].item_id != WS_PEER_INFO_NONE)
+ {
+ if (strcmp(g_ws_field_info[i].item_str, item)==0)
+ {
+ item_id = g_ws_field_info[i].item_id;
+ break;
+ }
+ i++;
+ }
+
+ switch(item_id)
+ {
+ case WS_PEER_INFO_AGE:
+ peer->age = atoi(value);
+ break;
+ case WS_PEER_INFO_LISTEN_FREQ:
+ peer->listen_freq = atoi(value);
+ break;
+ case WS_PEER_INFO_LEVEL:
+ peer->level = atoi(value);
+ break;
+ case WS_PEER_INFO_WPS_METHOD:
+ strncpy(peer->wps_method, value, sizeof(peer->wps_method));
+ break;
+ case WS_PEER_INFO_INTERFACE_ADDR:
+ strncpy(peer->interface_addr, value, sizeof(peer->interface_addr));
+ break;
+ case WS_PEER_INFO_MEMBER_IN_GO_DEV:
+ strncpy(peer->member_in_go_dev, value, sizeof(peer->member_in_go_dev));
+ break;
+ case WS_PEER_INFO_MEMBER_IN_GO_IFACE:
+ strncpy(peer->member_in_go_iface, value, sizeof(peer->member_in_go_iface));
+ break;
+ case WS_PEER_INFO_PRI_DEV_TYPE:
+ strncpy(peer->pri_dev_type, value, sizeof(peer->pri_dev_type));
+ break;
+ case WS_PEER_INFO_DEVICE_NAME:
+ strncpy(peer->device_name, value, sizeof(peer->device_name));
+ break;
+ case WS_PEER_INFO_MANUFACTURER:
+ strncpy(peer->manufacturer, value, sizeof(peer->manufacturer));
+ break;
+ case WS_PEER_INFO_MODEL_NAME:
+ strncpy(peer->model_name, value, sizeof(peer->model_name));
+ break;
+ case WS_PEER_INFO_MODEL_NUMBER:
+ strncpy(peer->model_number, value, sizeof(peer->model_number));
+ break;
+ case WS_PEER_INFO_SERIAL_NUMBER:
+ strncpy(peer->serial_number, value, sizeof(peer->serial_number));
+ break;
+ case WS_PEER_INFO_CONFIG_METHODS:
+ {
+ char* p = value;
+ unsigned long int ret = 0;
+ ret = strtoul(p, &p, 16);
+ if (ret == ULONG_MAX)
+ {
+ peer->config_methods = 0;
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "config_methods has wrong value=[%s], Error=[%s]\n", value, strerror(errno));
+ }
+ else
+ {
+ peer->config_methods = (unsigned int)ret;
+ WFD_SERVER_LOG(WFD_LOG_LOW, "config_methods value=[%x <- %s]\n", peer->config_methods, value);
+ }
+ }
+ break;
+ case WS_PEER_INFO_DEV_CAPAB:
+ {
+ char* p = value;
+ unsigned long int ret = 0;
+ ret = strtoul(p, &p, 16);
+ if (ret == ULONG_MAX)
+ {
+ peer->dev_capab = 0;
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "device_capab has wrong value=[%s], Error=[%s]\n", value, strerror(errno));
+ }
+ else
+ {
+ peer->dev_capab = (unsigned int)ret;
+ WFD_SERVER_LOG(WFD_LOG_LOW, "device_capab value=[%x <- %s]\n", peer->dev_capab, value);
+ }
+ }
+ break;
+ case WS_PEER_INFO_GROUP_CAPAB:
+ {
+ char* p = value;
+ unsigned long int ret = 0;
+ ret = strtoul(p, &p, 16);
+ if (ret == ULONG_MAX)
+ {
+ peer->group_capab = 0;
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "group_capab has wrong value=[%s], Error=[%s]\n", value, strerror(errno));
+ }
+ else
+ {
+ peer->group_capab = (unsigned int)ret;
+ WFD_SERVER_LOG(WFD_LOG_LOW, "group_capab value=[%x <- %s]\n", peer->group_capab, value);
+ }
+ }
+ break;
+ case WS_PEER_INFO_GO_NEG_REQ_SENT:
+ peer->go_neg_req_sent = atoi(value);
+ break;
+ case WS_PEER_INFO_GO_STATE:
+ strncpy(peer->go_state, value, sizeof(peer->go_state));
+ break;
+ case WS_PEER_INFO_DIALOG_TOKEN:
+ peer->dialog_token = atoi(value);
+ break;
+ case WS_PEER_INFO_INTENDED_ADDR:
+ strncpy(peer->intended_addr, value, sizeof(peer->intended_addr));
+ break;
+ case WS_PEER_INFO_COUNTRY:
+ strncpy(peer->country, value, sizeof(peer->country));
+ break;
+ case WS_PEER_INFO_OPER_FREQ:
+ peer->oper_freq = atoi(value);
+ break;
+ case WS_PEER_INFO_REQ_CONFIG_METHODS:
+ peer->req_config_methods = atoi(value);
+ break;
+ case WS_PEER_INFO_FLAGS:
+ strncpy(peer->flags, value, sizeof(peer->flags));
+ break;
+ case WS_PEER_INFO_STATUS:
+ strncpy(peer->status, value, sizeof(peer->status));
+ break;
+ case WS_PEER_INFO_WAIT_COUNT:
+ peer->wait_count = atoi(value);
+ break;
+ case WS_PEER_INFO_INVITATION_REQS:
+ peer->invitation_reqs = atoi(value);
+ break;
+ case WS_PEER_INFO_OPER_SSID:
+ strncpy(peer->oper_ssid, value, sizeof(peer->oper_ssid));
+ break;
+
+/*----- Miracast -----*/
+ case WS_PEER_INFO_IS_WFD_DEVICE:
+ peer->is_wfd_device = atoi(value);
+ break;
+
+ default:
+ WFD_SERVER_LOG(WFD_LOG_LOW, "unknown field\n");
+ break;
+ }
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return 0;
+
+}
+
+
+int __parsing_persistent_group(char* buf, ws_network_info_s ws_persistent_group_list[], int* persistent_group_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char* ptr = buf;
+ ws_network_info_s group;
+ int count;
+ int i;
+
+ memset(&group, 0, sizeof(ws_network_info_s));
+
+
+ // Passing first line : "network id / ssid / bssid / flags"
+ while (*ptr != '\n')
+ {
+ ptr++;
+ }
+ ptr++;
+
+ count = 0;
+ while(*ptr != '\0')
+ {
+ ptr = __get_persistent_group_value(ptr, &group);
+
+ ws_persistent_group_list[count].network_id = group.network_id;
+ strncpy(ws_persistent_group_list[count].ssid, group.ssid, sizeof(ws_persistent_group_list[count].ssid));
+ strncpy(ws_persistent_group_list[count].bssid, group.bssid, sizeof(ws_persistent_group_list[count].bssid));
+ strncpy(ws_persistent_group_list[count].flags, group.flags, sizeof(ws_persistent_group_list[count].flags));
+ count++;
+ }
+
+ *persistent_group_num = count;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+
+}
+
+void __parsing_ws_event(char* buf, ws_event_s *event)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char* ptr = buf;
+ char event_str[64];
+ int i;
+ ws_field_id_e event_id;
+ int res = 0;
+
+ if (NULL == buf)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "ERROR : buf is NULL!!\n");
+ return;
+ }
+
+ ptr = ptr +3;
+ ptr = __get_event_str(ptr, event_str);
+
+ if (NULL != event_str)
+ WFD_SERVER_LOG(WFD_LOG_LOW, "event str [%s]\n", event_str);
+
+ i=0;
+ event_id = WS_EVENT_NONE;
+ while(g_ws_event_info[i].id != WS_EVENT_NONE)
+ {
+ if (strcmp(g_ws_event_info[i].str, event_str)==0)
+ {
+ event_id = g_ws_event_info[i].id;
+ break;
+ }
+ i++;
+ }
+
+ switch(event_id)
+ {
+ memset(event, 0, sizeof(ws_event_s));
+
+ case WS_EVENT_DISCOVER_FOUND_PEER:
+ event->id = WS_EVENT_DISCOVER_FOUND_PEER;
+ WFD_SERVER_LOG(WFD_LOG_LOW, "WS EVENT : [WS_EVENT_DISCOVER_FOUND_PEER]\n");
+ break;
+
+ case WS_EVENT_PROVISION_DISCOVERY_RESPONSE:
+ event->id = WS_EVENT_PROVISION_DISCOVERY_RESPONSE;
+ ptr = __get_event_str(ptr, event_str);
+ strncpy(event->peer_mac_address, event_str, sizeof(event->peer_mac_address));
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_RESPONSE]\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [MAC : %s]\n", event_str);
+ break;
+
+ case WS_EVENT_PROVISION_DISCOVERY_PBC_REQ:
+ event->id = WS_EVENT_PROVISION_DISCOVERY_PBC_REQ;
+ res = __extract_value_str(ptr, "p2p_dev_addr", event->peer_mac_address);
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to extract p2p_dev_addr");
+ // TO-DO: stop parsing and make event callback function stop
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ res = __extract_value_str(ptr, "name" , event->peer_ssid);
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to extract name(ssid)");
+ // TO-DO: stop parsing and make event callback function stop
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_PBC_REQ]\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [MAC : %s]\n", event_str);
+ break;
+
+ case WS_EVENT_PROVISION_DISCOVERY_DISPLAY:
+ event->id = WS_EVENT_PROVISION_DISCOVERY_DISPLAY;
+ res = __extract_value_str(ptr, "p2p_dev_addr", event->peer_mac_address);
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Failed to extract p2p_dev_addr");
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Prov disc Response : DISPLAY");
+ event->id = WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY;
+ ptr = __get_event_str(ptr, event_str);
+ strncpy(event->peer_mac_address, event_str, sizeof(event->peer_mac_address));
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY]\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [MAC : %s]\n", event_str);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ res = __extract_value_str(ptr, "name" , event->peer_ssid);
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to extract name(ssid)");
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_DISPLAY]\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [MAC : %s]\n", event_str);
+ break;
+
+ case WS_EVENT_PROVISION_DISCOVERY_KEYPAD:
+ event->id = WS_EVENT_PROVISION_DISCOVERY_KEYPAD;
+ res = __extract_value_str(ptr, "p2p_dev_addr", event->peer_mac_address);
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Failed to extract p2p_dev_addr");
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Prov disc Response : KEYPAD");
+ event->id = WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD;
+ ptr = __get_event_str(ptr, event_str);
+ strncpy(event->peer_mac_address, event_str, sizeof(event->peer_mac_address));
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD]\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [MAC : %s]\n", event_str);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ res = __extract_value_str(ptr, "name" , event->peer_ssid);
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to extract name(ssid)");
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_PROVISION_DISCOVERY_KEYPAD]\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [MAC : %s]\n", event_str);
+ break;
+
+
+ case WS_EVENT_GROUP_STARTED:
+ event->id = WS_EVENT_GROUP_STARTED;
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_GROUP_STARTED]\n");
+ {
+ int res = 0;
+ char *dev_addr;
+ dev_addr = (char*) calloc(1, 18);
+ res = __extract_value_str(ptr, "dev_addr", dev_addr);
+ if(res > 0)
+ strcpy(event->peer_mac_address, dev_addr);
+ free(dev_addr);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "connected peer mac address [%s]", event->peer_mac_address);
+ }
+ break;
+
+ case WS_EVENT_GROUP_REMOVED:
+ event->id = WS_EVENT_GROUP_REMOVED;
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_GROUP_REMOVED]\n");
+ break;
+
+ case WS_EVENT_TERMINATING:
+ event->id = WS_EVENT_TERMINATING;
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_TERMINATING]\n");
+ break;
+#if 1
+ case WS_EVENT_CONNECTED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_CONNECTED]\n");
+ int res = 0;
+ char *intf_addr;
+ intf_addr = (char*) calloc(1, 18);
+ event->id = WS_EVENT_CONNECTED;
+ res = __extract_value_str(ptr, "to", intf_addr);
+ if(res > 0)
+ wfd_macaddr_atoe(intf_addr, g_assoc_sta_mac);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "connected peer interface mac address [%s]", intf_addr);
+ free(intf_addr);
+ }
+ break;
+#endif
+ case WS_EVENT_STA_CONNECTED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_STA_CONNECTED]\n");
+ int res = 0;
+ event->id = WS_EVENT_STA_CONNECTED;
+
+ ptr = __get_event_str(ptr, event_str);
+ strncpy(event->peer_intf_mac_address, event_str, sizeof(event->peer_intf_mac_address));
+
+ res = __extract_value_str(ptr, "dev_addr", event->peer_mac_address);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "connected peer mac address [%s]", event->peer_intf_mac_address);
+ }
+ break;
+
+ case WS_EVENT_DISCONNECTED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_DISCONNECTED]\n");
+ int res = 0;
+ char *intf_addr;
+ intf_addr = (char*) calloc(1, 18);
+ event->id = WS_EVENT_DISCONNECTED;
+ res = __extract_value_str(ptr, "to", intf_addr);
+ if(res > 0)
+ strncpy(event->peer_mac_address, intf_addr, 18);
+ free(intf_addr);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "disconnected peer mac address [%s]", event->peer_mac_address);
+ }
+ break;
+
+ case WS_EVENT_STA_DISCONNECTED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_STA_DISCONNECTED]\n");
+ int res = 0;
+ event->id = WS_EVENT_STA_DISCONNECTED;
+
+ ptr = __get_event_str(ptr, event_str);
+ strncpy(event->peer_intf_mac_address, event_str, sizeof(event->peer_intf_mac_address));
+
+ res = __extract_value_str(ptr, "dev_addr", event->peer_mac_address);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "disconnected peer mac address [%s]", event->peer_intf_mac_address);
+ }
+ break;
+
+ case WS_EVENT_INVITATION_REQ:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_INVITATION_REQ]\n");
+ int res = 0;
+ event->id = WS_EVENT_INVITATION_REQ;
+
+#if 1
+ res = __extract_value_str(ptr, "go_dev_addr", event->peer_mac_address);
+#else
+ res = __extract_value_str(ptr, "bssid", event->peer_mac_address);
+#endif
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to extract p2p_dev_addr");
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [GO MAC : %s]\n", event->peer_mac_address);
+ }
+ break;
+
+ case WS_EVENT_INVITATION_RSP:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [WS_EVENT_INVITATION_RSP]\n");
+ //int res = 0;
+ event->id = WS_EVENT_INVITATION_RSP;
+
+#if 0
+ res = __extract_value_str(ptr, "status", );
+ if(res <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to extract p2p_dev_addr");
+ return;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "WS EVENT : [GO MAC : %s]\n", event->peer_mac_address);
+#endif
+
+ }
+ break;
+
+
+ default:
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ERROR : unknown event !!\n");
+ break;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return;
+
+}
+
+int glist_compare_peer_mac_cb(const void* data1, const void* data2)
+{
+ char *mac_str1 = (char*) data1;
+ char *mac_str2 = (char*) data2;
+ int r = 0;
+
+ if (data1==NULL || data2==NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!! data is NULL\n");
+ return -1;
+ }
+
+ r = strcmp(mac_str1, mac_str2);
+ if (r==0)
+ return 0;
+ else
+ return 1;
+}
+
+void glist_print_connected_peer_cb(gpointer data, gpointer user_data)
+{
+ char *mac_str = (char*) data;
+ int count = *(int*)user_data;
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Connected peer[%d] mac=[%s]\n", count, mac_str);
+ *(int*)user_data = count+1;
+}
+
+void wfd_ws_print_connected_peer()
+{
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Connected Peer Table\n");
+ int count = 0;
+ g_list_foreach(g_conn_peer_addr, glist_print_connected_peer_cb, &count);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Count=%d\n", count);
+}
+
+void wfd_ws_glist_reset_connected_peer()
+{
+ if(g_conn_peer_addr)
+ {
+ GList *element = NULL;
+
+ element = g_list_first(g_conn_peer_addr);
+ while(element)
+ {
+ if(element->data)
+ free((char*) element->data);
+ element = g_list_next(element);
+ }
+ g_list_free(g_conn_peer_addr);
+ g_conn_peer_addr = NULL;
+ }
+}
+
+
+static gboolean __ws_event_callback(GIOChannel * source,
+ GIOCondition condition,
+ gpointer data)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ int sockfd = g_monitor_sockfd;
+ char buffer[4096] = {0, };
+ int n = 0;
+ ws_event_s event = {0,};
+
+ // Read socket
+ if ( (n = __read_socket_cb(sockfd, buffer, sizeof(buffer))) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! Reading Async Event[%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Received Event:[%d, %s]\n", n, buffer);
+
+ __parsing_ws_event(buffer, &event);
+
+ switch (event.id)
+ {
+
+ case WS_EVENT_DISCOVER_FOUND_PEER:
+ g_noti_cb(WFD_EVENT_DISCOVER_FOUND_PEERS);
+ break;
+
+ case WS_EVENT_PROVISION_DISCOVERY_RESPONSE:
+ {
+ unsigned char la_mac_addr[6];
+ wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
+
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "wfd_server->current_peer.is_group_owner=[%d]\n", wfd_server->current_peer.is_group_owner);
+ if (wfd_server->current_peer.is_group_owner == FALSE)
+ wfd_ws_connect(la_mac_addr, WIFI_DIRECT_WPS_TYPE_PBC);
+ }
+ break;
+
+ case WS_EVENT_PROVISION_DISCOVERY_RESPONSE_DISPLAY:
+ case WS_EVENT_PROVISION_DISCOVERY_RESPONSE_KEYPAD:
+ {
+ unsigned char la_mac_addr[6];
+ wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
+ memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
+ memcpy(&g_incomming_peer_mac_address, la_mac_addr, 6);
+
+ g_noti_cb(WFD_EVENT_CONNECT_PBC_START);
+ }
+ break;
+
+
+ case WS_EVENT_PROVISION_DISCOVERY_PBC_REQ:
+ case WS_EVENT_PROVISION_DISCOVERY_DISPLAY:
+ case WS_EVENT_PROVISION_DISCOVERY_KEYPAD:
+ {
+ unsigned char la_mac_addr[6];
+ wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
+ memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
+ memcpy(&g_incomming_peer_mac_address, la_mac_addr, 6);
+ memset(g_incomming_peer_ssid, 0, sizeof(g_incomming_peer_ssid));
+ strncpy(g_incomming_peer_ssid, event.peer_ssid, sizeof(g_incomming_peer_ssid));
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Prov Req: mac[" MACSTR"] ssid=[%s]\n",
+ MAC2STR(g_incomming_peer_mac_address), g_incomming_peer_ssid);
+
+ if (WS_EVENT_PROVISION_DISCOVERY_PBC_REQ == event.id)
+ g_noti_cb(WFD_EVENT_PROV_DISCOVERY_REQUEST);
+ else if (WS_EVENT_PROVISION_DISCOVERY_DISPLAY == event.id)
+ g_noti_cb(WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY);
+ else
+ g_noti_cb(WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD);
+ }
+ break;
+
+ case WS_EVENT_GROUP_STARTED:
+ {
+ if(wfd_ws_is_groupowner())
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW," CHECK : It's AP... \n");
+ system("/usr/bin/wifi-direct-dhcp.sh server");
+ __polling_ip(g_local_interface_ip_address, 20, FALSE);
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "*** IP : %s\n", g_local_interface_ip_address);
+
+ g_noti_cb(WFD_EVENT_SOFTAP_READY);
+ }
+ else
+ {
+ wfd_ws_glist_reset_connected_peer();
+
+ g_conn_peer_addr = g_list_append(g_conn_peer_addr, strdup(event.peer_mac_address));
+ WFD_SERVER_LOG(WFD_LOG_LOW, "connected peer[%s] is added\n", event.peer_mac_address);
+
+ g_noti_cb(WFD_EVENT_CREATE_LINK_COMPLETE);
+ }
+ }
+ break;
+
+ case WS_EVENT_GROUP_REMOVED:
+ {
+ system("/usr/bin/wifi-direct-dhcp.sh stop");
+ g_noti_cb(WFD_EVENT_CREATE_LINK_CANCEL);
+ g_noti_cb(WFD_EVENT_CREATE_LINK_DOWN);
+ g_noti_cb(WFD_EVENT_SOFTAP_STOP);
+
+ wfd_ws_glist_reset_connected_peer();
+#if 0
+ wfd_ws_flush();
+#endif
+ }
+ break;
+
+ case WS_EVENT_TERMINATING:
+ system("/usr/bin/wlan.sh stop");
+ system("/usr/sbin/wpa_supp_p2p.sh stop");
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Device is Deactivated\n");
+ break;
+
+ case WS_EVENT_CONNECTED:
+ {
+ // Nothing
+ }
+ break;
+
+ case WS_EVENT_DISCONNECTED:
+ {
+ GList *element = NULL;
+ element = g_list_find(g_conn_peer_addr, event.peer_mac_address);
+ if(element != NULL)
+ {
+ g_conn_peer_addr = g_list_remove(g_conn_peer_addr, event.peer_mac_address);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "disconnected peer[%s] is removed\n", event.peer_mac_address);
+ free((char*) element->data);
+ }
+ }
+ break;
+
+ case WS_EVENT_STA_CONNECTED:
+ {
+ GList *element = NULL;
+ element = g_list_find_custom(g_conn_peer_addr, event.peer_mac_address, glist_compare_peer_mac_cb);
+ if(element == NULL)
+ {
+ g_conn_peer_addr = g_list_append(g_conn_peer_addr, strdup(event.peer_mac_address));
+ WFD_SERVER_LOG(WFD_LOG_LOW, "connected peer[%s] is added\n", event.peer_mac_address);
+ }
+
+ wfd_ws_print_connected_peer();
+
+ wfd_macaddr_atoe(event.peer_intf_mac_address, g_assoc_sta_mac);
+ g_noti_cb(WFD_EVENT_CREATE_LINK_COMPLETE);
+ }
+ break;
+ case WS_EVENT_STA_DISCONNECTED:
+ {
+ GList *element = NULL;
+
+ wfd_ws_print_connected_peer();
+
+ element = g_list_find_custom(g_conn_peer_addr, event.peer_mac_address, glist_compare_peer_mac_cb);
+ if(element != NULL)
+ {
+ g_conn_peer_addr = g_list_remove(g_conn_peer_addr, element->data);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "disconnected peer[%s] is removed\n", event.peer_mac_address);
+ wfd_ws_print_connected_peer();
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Something wrong.. disconnected peer[%s] is not in Table\n", event.peer_mac_address);
+ }
+ wfd_macaddr_atoe(event.peer_intf_mac_address, g_disassoc_sta_mac);
+ g_noti_cb(WFD_EVENT_SOFTAP_STA_DISASSOC);
+ }
+ break;
+
+ case WS_EVENT_INVITATION_REQ:
+ {
+ unsigned char la_mac_addr[6];
+ wfd_macaddr_atoe(event.peer_mac_address, la_mac_addr);
+ memcpy(&g_incomming_peer_mac_address, la_mac_addr, 6);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "INVITATION REQ. RECEIVED: mac[" MACSTR"]\n", MAC2STR(g_incomming_peer_mac_address));
+
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+ wfd_server->current_peer.is_group_owner = true;
+
+ g_noti_cb(WFD_EVENT_INVITE_REQUEST);
+ }
+ break;
+
+ case WS_EVENT_INVITATION_RSP:
+ {
+ }
+ break;
+
+ default:
+ break;
+
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return true;
+}
+
+int __convert_category_from_type(char *pri_dev_type)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ char *saveptr = NULL;
+ char *token = NULL;
+
+ if(pri_dev_type == NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Incorrect parameter\n");
+ return -1;
+ }
+
+ token = strtok_r(pri_dev_type, "-", &saveptr);
+ if(token == NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Extracting failed\n");
+ return -1;
+ }
+
+ if(!strcmp(token, "255"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_OTHER;
+ else if(!strcmp(token, "11"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_AUDIO;
+ else if(!strcmp(token, "10"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE;
+ else if(!strcmp(token, "9"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_GAME_DEVICE;
+ else if(!strcmp(token, "8"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_MULTIMEDIA_DEVICE;
+ else if(!strcmp(token, "7"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_DISPLAY;
+ else if(!strcmp(token, "6"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_NETWORK_INFRA;
+ else if(!strcmp(token, "5"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_STORAGE;
+ else if(!strcmp(token, "4"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_CAMERA;
+ else if(!strcmp(token, "3"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_PRINTER;
+ else if(!strcmp(token, "2"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_INPUT_DEVICE;
+ else if(!strcmp(token, "1"))
+ return WIFI_DIRECT_PRIMARY_DEVICE_TYPE_COMPUTER;
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Unknown device type [%s]\n", token);
+ return -1;
+ }
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+}
+
+
+int __wpa_ctrl_attach(int sockfd)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[8] = {0};
+ char res_buffer[1024]={0,};
+ int res_buffer_len=sizeof(res_buffer);
+ int result= 0;
+
+ strncpy(cmd, CMD_ATTACH, sizeof(cmd));
+ result = __send_wpa_request(sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request(ATTACH) result=[%d]\n", result);
+
+ if (result < 0)
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return result;
+}
+
+
+
+
+static char*
+__convert_wps_config_methods_value(wifi_direct_wps_type_e wps_config_methods)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW,"wps_config_methods [%d]\n", wps_config_methods);
+
+ switch(wps_config_methods)
+ {
+ case WIFI_DIRECT_WPS_TYPE_PBC:
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return "pbc";
+ }
+ break;
+
+ case WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY:
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return "display";
+ }
+ break;
+
+ case WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD:
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return "keypad";
+ }
+ break;
+
+ default :
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW,"Invalid input parameter!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return "";
+ }
+ break;
+
+ }
+}
+
+static unsigned int
+__convert_device_type(char *ptr)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char* p = ptr;
+ int c = 0;
+ char category_type[3] = {0,};
+
+ if (p==NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ERROR : ptr is NULL!!\n");
+ return 0;
+ }
+
+ c = 0;
+ while(*p != '-') // take the first number before the first '-' (e.g. 1-0050F204-5)
+ {
+ category_type[c++] = *p++;
+ }
+ category_type[c]='\0';
+
+ WFD_SERVER_LOG( WFD_LOG_LOW,"category=[%d]\n", atoi(category_type));
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return atoi(category_type);
+}
+
+static unsigned int
+__convert_secondary_device_type(char *ptr)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char* p = NULL;
+ int c = 0;
+ char category_type[3] = {0,};
+
+ if (ptr==NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ERROR : ptr is NULL!!\n");
+ return 0;
+ }
+
+ p = strstr(ptr, WIFI_ALLIANCE_OUI);
+ if (p==NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "ERROR : Unknown OUI, It's vendor specific device type..\n");
+ return 0;
+ }
+ p += strlen(WIFI_ALLIANCE_OUI); // // skip OUI (e.g. 1-0050F204-5)
+ p ++; // skip the second '-' (e.g. 1-0050F204-5)
+
+ c = 0;
+ while(*p != '\0')
+ {
+ category_type[c++] = *p++;
+ }
+ category_type[c]='\0';
+
+ WFD_SERVER_LOG( WFD_LOG_LOW,"sub-category [%d]\n", atoi(category_type));
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return atoi(category_type);
+}
+
+
+int __convert_freq_to_channel(char *freq_kHz)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ int i = 0;
+ int channel = 0;
+
+ while(g_ws_op_channel_info[i].channel != 0)
+ {
+ if (strcmp(g_ws_op_channel_info[i].freq, freq_kHz)==0)
+ {
+ channel = g_ws_op_channel_info[i].channel;
+ break;
+ }
+ i++;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return channel;
+}
+
+
+#if 1 // Threadsafe event handling.
+
+void __wfd_oem_callback(wfd_event_t event)
+{
+ // write header parts
+ write(g_oem_pipe[1], &event, sizeof(event));
+}
+
+#else
+
+void __wfd_oem_callback(wfd_event_t event_type)
+{
+ if (g_oem_event_callback != NULL)
+ g_oem_event_callback(event_type);
+}
+
+#endif
+
+int wfd_ws_init(wfd_oem_event_cb event_callback)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+#if 1 // Threadsafe event handling
+ if (pipe(g_oem_pipe) < 0) {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "pipe error : Error=[%s]\n", strerror(errno));
+ return false;
+ }
+
+ GIOChannel* gio2 = g_io_channel_unix_new(g_oem_pipe[0]);
+ g_io_add_watch(gio2, G_IO_IN, (GIOFunc)__wfd_oem_thread_safe_event_handler_cb, NULL);
+ g_io_channel_unref(gio2);
+#endif
+
+ g_oem_event_callback = event_callback;
+
+ g_noti_cb = __wfd_oem_callback;
+
+ memset(g_incomming_peer_mac_address, 0, sizeof(g_incomming_peer_mac_address));
+ memset(g_incomming_peer_ssid, 0, sizeof(g_incomming_peer_ssid));
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_destroy()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ // Do nothing upto now...
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_activate()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ int result = 0;
+ char cmd[128] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len=sizeof(res_buffer);
+
+ // Loading Driver, Excuting p2p_supplicant
+ system("/usr/bin/wlan.sh p2p");
+ system("/usr/sbin/p2p_supp.sh start");
+
+ sleep(1);
+ g_global_sockfd = __create_ctrl_intf("p2p_ctrl_global", "/var/run/p2p_global");
+ if(g_global_sockfd < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Failed to create Global Control interface\n");
+ return false;
+ }
+
+ strncpy(cmd, CMD_INTERFACE, sizeof(cmd));
+ result = __send_wpa_request(g_global_sockfd, cmd, res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request(LOG_LEVEL) result=[%d]\n", result);
+ if(!strstr(res_buffer, "wlan0"))
+ {
+ memset(cmd, 0x0, 128);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_INTERFACE_ADD, "wlan0\t/usr/etc/wifi-direct/p2p_suppl.conf\tnl80211\t/var/run/p2p_supplicant");
+ result = __send_wpa_request(g_global_sockfd, cmd, res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request(LOG_LEVEL) result=[%d]\n", result);
+ }
+ memset(res_buffer, 0x0, 1024);
+
+ // Creating Socket
+ int count = 10;
+ do
+ {
+ sleep(1);
+
+ // Sync Socket
+ g_control_sockfd = __create_ctrl_intf("p2p_ctrl_control", "/var/run/p2p_supplicant/wlan0");
+ if (g_control_sockfd > 0)
+ {
+ // Async Socket
+ g_monitor_sockfd = __create_ctrl_intf("p2p_ctrl_monitor", "/var/run/p2p_supplicant/wlan0");
+ if (g_monitor_sockfd > 0)
+ {
+ if (__wpa_ctrl_attach(g_monitor_sockfd) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Failed to attach p2p_supplicant!!! monitor_sockfd=[%d]\n", g_monitor_sockfd);
+ return false;
+ }
+ break;
+ }
+ }
+ count--;
+
+ if (count == 0)
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Failed to create socket !!\n");
+
+ } while (count > 0);
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Successfully socket connected to server !!\n");
+
+ GIOChannel *gio3;
+
+ gio3 = g_io_channel_unix_new(g_monitor_sockfd);
+ g_source_id = g_io_add_watch(gio3, G_IO_IN | G_IO_ERR | G_IO_HUP, (GIOFunc) __ws_event_callback, NULL);
+ g_io_channel_unref(gio3);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Scoket is successfully registered to g_main_loop.\n");
+
+ //wfd_ws_set_oem_loglevel(3);
+
+ /* init miracast */
+ if(wfd_ws_dsp_init() == true)
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Success : wfd_ws_dsp_init() \n");
+ else
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Failed : wfd_ws_dsp_init()\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_deactivate()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len=sizeof(res_buffer);
+ int result = 0;
+
+ // stop p2p_find
+ wfd_ws_cancel_discovery();
+
+ // detach monitor interface
+ strncpy(cmd, CMD_DETACH, sizeof(cmd));
+ result = __send_wpa_request(g_monitor_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_DETACH) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "DETACH command Fail. result [%d], res_buffer [%s]\n", result, res_buffer);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+
+ // close control interface
+ g_source_remove(g_source_id);
+ unlink("/tmp/wpa_ctrl_monitor");
+ if (g_monitor_sockfd >= 0)
+ close(g_monitor_sockfd);
+ unlink("/tmp/wpa_ctrl_control");
+ if (g_control_sockfd >= 0)
+ close(g_control_sockfd);
+
+ // interface_remove
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_INTERFACE_REMOVE, "p2p-wlan0-0");
+ result = __send_wpa_request(g_global_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(INTERFACE_REMOVE p2p-wlan0-0) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ // interface_remove
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_INTERFACE_REMOVE, "wlan0");
+ result = __send_wpa_request(g_global_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(INTERFACE_REMOVE wlan0) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ // close global interface
+ unlink("/tmp/wpa_ctrl_global");
+ if(g_global_sockfd >= 0)
+ close(g_global_sockfd);
+
+ wfd_ws_glist_reset_connected_peer();
+
+ // wlan.sh stop
+ system("/usr/bin/wlan.sh stop");
+ system("/usr/sbin/wpa_supp_p2p.sh stop");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_wps_pbc_start(void)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[8] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if (wfd_ws_is_groupowner()!=true)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "wps_pbc_start() can be called, only when device is go!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ strncpy(cmd, CMD_WPS_PUSHBUTTON_START, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(WPS_PBC) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "start WPS PBC...\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_connect(unsigned char mac_addr[6], wifi_direct_wps_type_e wps_config)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[50] = {0, };
+ char mac_str[18] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+ WFD_SERVER_LOG(WFD_LOG_LOW, "wfd_server->current_peer.is_group_owner=[%d]\n", wfd_server->current_peer.is_group_owner);
+
+ if (wfd_ws_is_groupowner()==true)
+ {
+ strncpy(cmd, CMD_WPS_PUSHBUTTON_START, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(WPS_PBC) result=[%d]\n", result);
+ }
+
+ if (wfd_server->current_peer.is_group_owner)
+ {
+ snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
+ snprintf(cmd, sizeof(cmd),"%s %s %s join", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(wps_config));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_CONNECT join) result=[%d]\n", result);
+ }
+ else
+ {
+ if (wfd_server->config_data.want_persistent_group == true) /* persistent mode */
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "[persistent mode!!!]\n");
+ snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
+ snprintf(cmd, sizeof(cmd), "%s %s %s persistent", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(wps_config));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_CONNECT ... persistent) result=[%d]\n", result);
+ }
+ else
+ {
+ snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
+ snprintf(cmd, sizeof(cmd), "%s %s %s", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(wps_config));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_CONNECT) result=[%d]\n", result);
+ }
+ }
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Connecting... peer-MAC [%s]\n", mac_str);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_disconnect()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_GROUP_REMOVE, DEFAULT_IF_NAME);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_GROUP_REMOVE) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "disconnect... remove group [%s]\n", DEFAULT_IF_NAME);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+// TODO: should find how to disconnect with peer by peer_mac
+int wfd_ws_disconnect_sta(unsigned char mac_addr[6])
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ int result;
+
+ result = wfd_ws_disconnect();
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return result;
+}
+
+bool wfd_ws_is_discovery_enabled()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+}
+
+bool wfd_ws_flush()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len=sizeof(res_buffer);
+ int result = 0;
+
+ // Skip checking result..
+ strncpy(cmd, CMD_FLUSH, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_FLUSH) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+
+int wfd_ws_start_discovery(bool listen_only, int timeout)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len=sizeof(res_buffer);
+ int result = 0;
+
+#if 0
+ if (wfd_ws_is_groupowner()==false && wfd_ws_is_groupclient()==false)
+ wfd_ws_flush();
+#endif
+
+ if (listen_only == true)
+ {
+ if (timeout > 0)
+ snprintf(cmd, sizeof(cmd), "%s %d", CMD_START_LISTEN, timeout);
+ else
+ strncpy(cmd, CMD_START_LISTEN, sizeof(cmd));
+
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_LISTEN) result=[%d]\n", result);
+ }
+ else
+ {
+ strncpy(cmd, CMD_START_DISCOVER, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_FIND) result=[%d]\n", result);
+ }
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ // to notify to the application.
+ if (listen_only == true)
+ g_noti_cb(WFD_EVENT_DISCOVER_START_LISTEN_ONLY);
+ else
+ g_noti_cb(WFD_EVENT_DISCOVER_START_80211_SCAN);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_cancel_discovery()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len=sizeof(res_buffer);
+ int result = 0;
+
+ strncpy(cmd, CMD_CANCEL_DISCOVER, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_STOP_FIND) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ // to notify to the application.
+ g_noti_cb(WFD_EVENT_DISCOVER_CANCEL);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_discovery_result(wfd_discovery_entry_s ** peer_list, int* peer_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[40] = {0, };
+ char mac_str[18] = {0, };
+ char res_buffer[1024] = {0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result = 0;
+ int peer_count = 0;
+ int i;
+ ws_discovered_peer_info_s ws_peer_list[MAX_PEER_NUM];
+ static wfd_discovery_entry_s wfd_peer_list[16];
+
+ memset(&ws_peer_list, 0, (sizeof(ws_discovered_peer_info_s)*MAX_PEER_NUM));
+ memset(&wfd_peer_list, 0, (sizeof(wfd_discovery_entry_s)*16));
+
+ /* Reading first discovered peer */
+ strncpy(cmd, CMD_GET_FIRST_DISCOVERED_PEER, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_PEER FIRST) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ *peer_num = 0;
+ *peer_list = NULL;
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0)) /* p2p_supplicant returns the 'FAIL' if there is no discovered peer. */
+ {
+ *peer_num = 0;
+ *peer_list = NULL;
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __parsing_peer(res_buffer, &ws_peer_list[peer_count]);
+ peer_count++;
+
+ /* Reading Next discovered peers */
+ do
+ {
+ memset(cmd, 0x0, 40);
+ memset(mac_str, 0x0, 18);
+ memset(res_buffer, 0, sizeof(res_buffer));
+
+ strncpy(mac_str, ws_peer_list[peer_count-1].mac, sizeof(mac_str));
+ snprintf(cmd, sizeof(cmd), "%s%s", CMD_GET_NEXT_DISCOVERED_PEER, mac_str);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_PEER NEXT-) result=[%d]\n", result);
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0)) /* p2p_asupplicant returns the 'FAIL' if there is no discovered peer. */
+ break;
+
+ __parsing_peer(res_buffer, &ws_peer_list[peer_count]);
+ peer_count++;
+
+ } while(1);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "number of discovered peers: %d\n", peer_count);
+
+ for(i=0; i<peer_count; i++)
+ {
+ memset(&wfd_peer_list[i], 0, sizeof(wfd_discovery_entry_s));
+ WFD_SERVER_LOG( WFD_LOG_LOW, "index [%d] MAC [%s] GOstate=[%s] groupCapab=[%x] devCapab=[%x] is_wfd_device[%d] Name[%s] type=[%s] ssid[%s]\n",
+ i,
+ ws_peer_list[i].mac,
+ ws_peer_list[i].go_state,
+ ws_peer_list[i].group_capab,
+ ws_peer_list[i].dev_capab,
+ ws_peer_list[i].is_wfd_device,
+ ws_peer_list[i].device_name,
+ ws_peer_list[i].pri_dev_type,
+ ws_peer_list[i].oper_ssid);
+/*
+ typedef struct
+ {
+ bool is_group_owner;
+ char ssid[WIFI_DIRECT_MAX_SSID_LEN + 1];
+ unsigned char mac_address[6];
+ int channel;
+ bool is_connected;
+ unsigned int services;
+ bool is_persistent_go;
+ unsigned char intf_mac_address[6];
+ unsigned int wps_device_pwd_id;
+ unsigned int wps_cfg_methods;
+ unsigned int category;
+ unsigned int subcategory;
+ } wfd_discovery_entry_s;
+*/
+ // Device MAC address
+ if (NULL != ws_peer_list[i].mac)
+ {
+ unsigned char la_mac_addr[6];
+
+ wfd_macaddr_atoe(ws_peer_list[i].mac, la_mac_addr);
+ memcpy(wfd_peer_list[i].mac_address, (char*)(la_mac_addr), sizeof(la_mac_addr));
+ }
+
+ // Interface MAC address
+ if (NULL != ws_peer_list[i].interface_addr)
+ {
+ unsigned char la_mac_addr[6];
+
+ wfd_macaddr_atoe(ws_peer_list[i].interface_addr, la_mac_addr);
+ memcpy(wfd_peer_list[i].intf_mac_address, (char*)(la_mac_addr), sizeof(la_mac_addr));
+ }
+
+ // WPS Config method
+ wfd_peer_list[i].wps_cfg_methods = 0;
+ if ((ws_peer_list[i].config_methods & WPS_CONFIG_DISPLAY) > 0)
+ wfd_peer_list[i].wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;
+ if ((ws_peer_list[i].config_methods & WPS_CONFIG_PUSHBUTTON) > 0)
+ wfd_peer_list[i].wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PBC;
+ if ((ws_peer_list[i].config_methods & WPS_CONFIG_KEYPAD) > 0)
+ wfd_peer_list[i].wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
+
+ // Device name --> SSID
+ strncpy(wfd_peer_list[i].ssid, ws_peer_list[i].device_name, sizeof(wfd_peer_list[i].ssid));
+
+ // is_group_owner
+ if ((ws_peer_list[i].group_capab & GROUP_CAPAB_GROUP_OWNER) > 0) /* checking GO state */
+ wfd_peer_list[i].is_group_owner = true;
+ else
+ wfd_peer_list[i].is_group_owner = false;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "GroupOwnerCapab: %x & %x = %d\n", ws_peer_list[i].group_capab, GROUP_CAPAB_GROUP_OWNER, (ws_peer_list[i].group_capab & GROUP_CAPAB_GROUP_OWNER));
+
+ // is_persistent_go
+ if ((ws_peer_list[i].group_capab & GROUP_CAPAB_PERSISTENT_GROUP) > 0) /* checking persistent GO state */
+ wfd_peer_list[i].is_persistent_go = true;
+ else
+ wfd_peer_list[i].is_persistent_go = false;
+
+ // is_connected
+#if 1
+ if (wfd_peer_list[i].is_group_owner)
+ wfd_peer_list[i].is_connected = true;
+ else if (strncmp(ws_peer_list[i].member_in_go_dev, "00:00:00:00:00:00", strlen("00:00:00:00:00:00"))!=0)
+ wfd_peer_list[i].is_connected = true;
+ else
+ wfd_peer_list[i].is_connected = false;
+#else
+ wfd_peer_list[i].is_connected = wfd_server_is_connected_peer_by_device_mac(wfd_peer_list[i].mac_address);
+#endif
+
+
+ // Listen channel
+ // ToDo: convert freq to channel...
+ wfd_peer_list[i].channel = ws_peer_list[i].listen_freq;
+
+ // wps_device_pwd_id
+ // ToDo: where to get it?
+ wfd_peer_list[i].wps_device_pwd_id = 0;
+
+ wfd_peer_list[i].category = __convert_device_type(ws_peer_list[i].pri_dev_type);
+ wfd_peer_list[i].subcategory = __convert_secondary_device_type(ws_peer_list[i].pri_dev_type);
+ }
+
+ *peer_num = peer_count;
+ *peer_list = &wfd_peer_list[0];
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Getting discovery result is Completed.\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+
+}
+
+int wfd_ws_get_peer_info(unsigned char *mac_addr, wfd_discovery_entry_s **peer)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char mac_str[18] = {0, };
+ char res_buffer[1024] = {0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result = 0;
+ ws_discovered_peer_info_s ws_peer_info;
+ wfd_discovery_entry_s* wfd_peer_info;
+
+ memset(&ws_peer_info, 0x0, sizeof(ws_discovered_peer_info_s));
+ wfd_peer_info = (wfd_discovery_entry_s *) calloc(1, sizeof(wfd_discovery_entry_s));
+
+ /* Reading first discovered peer */
+ snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
+ snprintf(cmd, sizeof(cmd),"%s %s", CMD_GET_PEER_INFO, mac_str);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_PEER) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ *peer = NULL;
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0)) /* p2p_supplicant returns the 'FAIL' if there is no discovered peer. */
+ {
+ *peer = NULL;
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ // TODO: parsing peer info
+ __parsing_peer(res_buffer, &ws_peer_info);
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "MAC [%s] GOstate=[%s] groupCapab=[%x] devCapab=[%x] Name[%s] type=[%s] ssid[%s]\n",
+ ws_peer_info.mac,
+ ws_peer_info.go_state,
+ ws_peer_info.group_capab,
+ ws_peer_info.dev_capab,
+ ws_peer_info.device_name,
+ ws_peer_info.pri_dev_type,
+ ws_peer_info.oper_ssid);
+
+ if (NULL != ws_peer_info.mac)
+ {
+ unsigned char la_mac_addr[6];
+
+ wfd_macaddr_atoe(ws_peer_info.mac, la_mac_addr);
+ memcpy(wfd_peer_info->mac_address, (char*)(la_mac_addr), sizeof(la_mac_addr));
+ }
+
+ // Interface MAC address
+ if (NULL != ws_peer_info.interface_addr)
+ {
+ unsigned char la_mac_addr[6];
+
+ wfd_macaddr_atoe(ws_peer_info.interface_addr, la_mac_addr);
+ memcpy(wfd_peer_info->intf_mac_address, (char*)(la_mac_addr), sizeof(la_mac_addr));
+ }
+
+ // WPS Config method
+ wfd_peer_info->wps_cfg_methods = 0;
+ if ((ws_peer_info.config_methods & WPS_CONFIG_DISPLAY) > 0)
+ wfd_peer_info->wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;
+ if ((ws_peer_info.config_methods & WPS_CONFIG_PUSHBUTTON) > 0)
+ wfd_peer_info->wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PBC;
+ if ((ws_peer_info.config_methods & WPS_CONFIG_KEYPAD) > 0)
+ wfd_peer_info->wps_cfg_methods += WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
+
+ // Device name --> SSID
+ strncpy(wfd_peer_info->ssid, ws_peer_info.device_name, sizeof(wfd_peer_info->ssid));
+
+ // is_group_owner
+ if ((ws_peer_info.group_capab & GROUP_CAPAB_GROUP_OWNER) > 0) /* checking GO state */
+ wfd_peer_info->is_group_owner = true;
+ else
+ wfd_peer_info->is_group_owner = false;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "GroupOwnerCapab: %x & %x = %d\n", ws_peer_info.group_capab, GROUP_CAPAB_GROUP_OWNER, (ws_peer_info.group_capab & GROUP_CAPAB_GROUP_OWNER));
+
+ // is_persistent_go
+ if ((ws_peer_info.group_capab & GROUP_CAPAB_PERSISTENT_GROUP) > 0) /* checking persistent GO state */
+ wfd_peer_info->is_persistent_go = true;
+ else
+ wfd_peer_info->is_persistent_go = false;
+
+ // is_connected
+#if 1
+ if (wfd_peer_info->is_group_owner)
+ wfd_peer_info->is_connected = true;
+ else if (strncmp(ws_peer_info.member_in_go_dev, "00:00:00:00:00:00", strlen("00:00:00:00:00:00"))!=0)
+ wfd_peer_info->is_connected = true;
+ else
+ wfd_peer_info->is_connected = false;
+#else
+ wfd_peer_info->is_connected = wfd_server_is_connected_peer_by_device_mac(wfd_peer_info->mac_address);
+#endif
+
+
+ // Listen channel
+ // ToDo: convert freq to channel...
+ wfd_peer_info->channel = ws_peer_info.listen_freq;
+
+ // wps_device_pwd_id
+ // ToDo: where to get it?
+ wfd_peer_info->wps_device_pwd_id = 0;
+
+ wfd_peer_info->category = __convert_device_type(ws_peer_info.pri_dev_type);
+ wfd_peer_info->subcategory = __convert_secondary_device_type(ws_peer_info.pri_dev_type);
+
+ *peer = wfd_peer_info;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_send_provision_discovery_request(unsigned char mac_addr[6], wifi_direct_wps_type_e config_method, int is_peer_go)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[40] = {0, };
+ char mac_str[18] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ // temporary code : stop p2p_find (multi-supplicant ignore provision discovery response)
+ wfd_ws_cancel_discovery();
+
+ if (is_peer_go)
+ {
+ snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
+ snprintf(cmd, sizeof(cmd),"%s %s %s join", CMD_CONNECT, mac_str, __convert_wps_config_methods_value(config_method));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_PROV_DISC) result=[%d]\n", result);
+ }
+ else
+ {
+ snprintf(mac_str, 18, MACSTR, MAC2STR(mac_addr));
+ snprintf(cmd, sizeof(cmd),"%s %s %s", CMD_SEND_PROVISION_DISCOVERY_REQ, mac_str, __convert_wps_config_methods_value(config_method));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_PROV_DISC) result=[%d]\n", result);
+ }
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Provisioning... peer-MAC [%s]\n", mac_str);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+bool wfd_ws_get_go_dev_addr(char* p2p_device_address)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if (p2p_device_address == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Wrong param\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ char* ptr = strstr(res_buffer, "p2p_device_address=");
+ if (ptr==NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Can't find p2p_device_address...\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ char item[32];
+ char value[32];
+
+ if (__get_item_value(ptr, item, value) == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Can't wrong format to get p2p_device_address...\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if (strcmp(item, "p2p_device_address")!=0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Can't get p2p_device_address.... item=[%s]\n", item);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ strncpy(p2p_device_address, value, sizeof(value));
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_send_invite_request(unsigned char dev_mac_addr[6])
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[128] = {0, };
+ char mac_str[18] = {0, };
+ char res_buffer[1024]={0,};
+ char p2p_device_address[32];
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if(wfd_ws_get_go_dev_addr(p2p_device_address) == false)
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ snprintf(mac_str, 18, MACSTR, MAC2STR(dev_mac_addr));
+ snprintf(cmd, sizeof(cmd), "%s group=p2p-wlan0-0 peer=%s go_dev_addr=%s", CMD_SEND_INVITE_REQ, mac_str, p2p_device_address);
+
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_SEND_INVITE_REQ) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Invite... peer-MAC [%s]\n", mac_str);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+int wfd_ws_create_group(char* ssid)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[64] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+
+ if (wfd_server->config_data.want_persistent_group)
+ {
+ /* Persistent group mode */
+ snprintf(cmd, sizeof(cmd), "%s %s %s", CMD_CREATE_GROUP, "persistent", FREQUENCY_2G);
+ }
+ else
+ {
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_CREATE_GROUP, FREQUENCY_2G);
+ }
+
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_GROUP_ADD) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Create p2p group... \n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_cancel_group()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[30] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_GROUP_REMOVE, DEFAULT_IF_NAME);
+
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(P2P_GROUP_REMOVE) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Remove p2p group... \n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_activate_pushbutton()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[8] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ strncpy(cmd, CMD_WPS_PUSHBUTTON_START, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(WPS_PBC) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "start WPS PBC...\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+ }
+
+bool wfd_ws_is_groupowner()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if(strstr(res_buffer, "mode=P2P GO") == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "This device is not Groupowner\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+bool wfd_ws_is_groupclient()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if(strstr(res_buffer, "mode=station") == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "This device is not client\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_ssid(char* ssid, int len)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[12] = {0, };
+ char tmp_ssid[64] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if(ssid == NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Incorrect parameter");
+ return -1;
+ }
+
+ strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(STATUS) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ result = __extract_value_str(res_buffer, "\nssid", (char*) tmp_ssid);
+ if(result <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Extracting value failed\n");
+ return -1;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "###### ssid [%s] ###########\n", tmp_ssid);
+ memcpy(ssid, tmp_ssid, len);
+ ssid[len] = '\0';
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+char* wfd_ws_get_default_interface_name()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return DEFAULT_IF_NAME;
+}
+
+bool wfd_ws_dhcpc_get_ip_address(char *ipaddr_buf, int len, int is_IPv6)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ struct ifreq IfRequest;
+ struct sockaddr_in* sin = NULL;
+ int fd;
+
+ if (ipaddr_buf == NULL)
+ return false;
+#if 0
+ FILE *fp = NULL;
+ if((fp = fopen(DEFAULT_IP_LOG_PATH, "r+")) != NULL)
+ {
+ fclose(fp);
+ fp = NULL;
+#endif
+
+ if((fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP)) < 0) {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Failed to open socket\n");
+ return false;
+ }
+
+ memset(IfRequest.ifr_name, 0, DEFAULT_IF_NAME_LEN);
+ strncpy(IfRequest.ifr_name, DEFAULT_IF_NAME, DEFAULT_IF_NAME_LEN - 1);
+ if(ioctl(fd, SIOCGIFADDR, &IfRequest) < 0) {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Failed to get IP\n");
+ close(fd);
+ return false;
+ }
+
+ sin = (struct sockaddr_in*)&IfRequest.ifr_broadaddr;
+ if (ipaddr_buf != NULL)
+ strncpy(ipaddr_buf, (char*)inet_ntoa(sin->sin_addr), len);
+ return true;
+#if 0
+ }
+#endif
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return false;
+}
+
+
+char* wfd_ws_get_ip()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char ip_string[20] = {0,};
+
+ snprintf(ip_string, 20, "%s", g_local_interface_ip_address);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "################################################\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "###### IP = %s ###########\n", ip_string);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "################################################\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return ip_string;
+}
+
+int wfd_ws_set_wps_pin(char* pin)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+ }
+
+int wfd_ws_get_wps_pin(char* wps_pin, int len)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_generate_wps_pin()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+
+}
+
+
+int wfd_ws_set_ssid(char* ssid)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[128] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if (ssid == NULL || strlen(ssid) == 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Wrong SSID\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ snprintf(cmd, sizeof(cmd), "%s device_name %s", CMD_SET_PARAM, ssid);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ memset(cmd, 0x0, 128);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s p2p_ssid_postfix %s", CMD_SET_PARAM, ssid);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_set_wpa_passphrase(char* wpa_key)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_supported_wps_mode()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ int wps_config;
+
+ //TO-DO : supplicant CLI command should be supported.
+
+ wps_config = WIFI_DIRECT_WPS_TYPE_PBC |WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY |WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;
+
+ return wps_config;
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_connected_peers_count(int* peer_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ GList *element = NULL;
+
+ *peer_num = 0;
+ element = g_list_first(g_conn_peer_addr);
+ while(element)
+ {
+ (*peer_num)++;
+ element = g_list_next(element);
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Connected peer number [%d]\n", *peer_num);
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+int wfd_ws_get_connected_peers_info(wfd_connected_peer_info_s ** peer_list, int* peer_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ int i = 0;
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ char pri_dev_type[16] ={0, };
+ GList *element = NULL;
+ int result;
+
+ if(peer_list == NULL || peer_num == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Incorrect parameter\n");
+ return false;
+ }
+
+ wfd_ws_get_connected_peers_count(peer_num);
+
+ wfd_connected_peer_info_s *tmp_peer_list = NULL;
+
+ tmp_peer_list = (wfd_connected_peer_info_s*) calloc(*peer_num, sizeof(wfd_connected_peer_info_s));
+ if(tmp_peer_list == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Memory allocatin failed\n");
+ *peer_list = NULL;
+ *peer_num = 0;
+
+ return false;
+ }
+
+ element = g_list_first(g_conn_peer_addr);
+ while(element)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "element data is [%s]\n", (char*) element->data);
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s %s", CMD_GET_PEER_INFO, (char*) element->data);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(%s) result=[%d]\n", cmd, result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ *peer_list = NULL;
+ *peer_num = 0;
+ if (tmp_peer_list != NULL)
+ free(tmp_peer_list);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ *peer_list = NULL;
+ *peer_num = 0;
+ if (tmp_peer_list != NULL)
+ free(tmp_peer_list);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ /*
+ typedef struct
+ {
+ char ssid[WIFI_DIRECT_MAX_SSID_LEN + 1];
+ unsigned char mac_address[6];
+ unsigned char intf_mac_address[6];
+ unsigned int services;
+ bool is_p2p;
+ unsigned short category;
+ int channel;
+ } wfd_connected_peer_info_s;
+ */
+ result = __extract_value_str(res_buffer, "device_name", (char*) tmp_peer_list[i].ssid);
+ if(result <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Extracting value failed\n");
+ *peer_list = NULL;
+ *peer_num = 0;
+ if (tmp_peer_list != NULL)
+ free(tmp_peer_list);
+
+ return false;
+ }
+
+ wfd_macaddr_atoe((char*) element->data, tmp_peer_list[i].mac_address);
+
+ char intf_mac_address[18] = {0, };
+ result = __extract_value_str(res_buffer, "interface_addr", (char*) intf_mac_address);
+ if(result <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Extracting value failed\n");
+ *peer_list = NULL;
+ *peer_num = 0;
+ if (tmp_peer_list != NULL)
+ free(tmp_peer_list);
+
+ return false;
+ }
+ wfd_macaddr_atoe((char*) intf_mac_address, tmp_peer_list[i].intf_mac_address);
+
+ tmp_peer_list[i].services = 0;
+ tmp_peer_list[i].is_p2p = true;
+
+ result = __extract_value_str(res_buffer, "pri_dev_type", (char*) pri_dev_type);
+ if(result <= 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Extracting value failed\n");
+ *peer_list = NULL;
+ *peer_num = 0;
+ if (tmp_peer_list != NULL)
+ free(tmp_peer_list);
+
+ return false;
+ }
+
+ tmp_peer_list[i].category = __convert_category_from_type(pri_dev_type);
+ if(tmp_peer_list[i].category < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Category converting error\n");
+ *peer_list = NULL;
+ *peer_num = 0;
+ if (tmp_peer_list != NULL)
+ free(tmp_peer_list);
+
+ return false;
+ }
+
+ element = g_list_next(element);
+ i++;
+ }
+
+ *peer_list = tmp_peer_list;
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+int wfd_ws_get_go_intent(int *p2p_go_intent)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if (p2p_go_intent == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "p2p_go_intent is NULL\n", p2p_go_intent);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ snprintf(cmd, sizeof(cmd), "%s p2p_go_intent", CMD_GET_PARAM);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(GET P2P_GO_INTENT) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ *p2p_go_intent = atoi(res_buffer);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_set_go_intent(int go_intent)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ if (go_intent < 0 || go_intent > 15)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Wrong p2p_go_intent [%d]\n", go_intent);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ snprintf(cmd, sizeof(cmd), "%s p2p_go_intent %d", CMD_SET_PARAM, go_intent);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+int wfd_ws_set_device_type(wifi_direct_primary_device_type_e primary_cat, wifi_direct_secondary_device_type_e sub_cat)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ snprintf(cmd, sizeof(cmd), "%s device_type %d", CMD_SET_PARAM, primary_cat);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s device_type %d", CMD_SET_PARAM, sub_cat);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_SET_PARAM) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+int wfd_ws_get_device_mac_address(unsigned char* device_mac)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[8] = {0, };
+ char device_address[18] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ strncpy(cmd, CMD_STATUS, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(STATUS) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ __extract_value_str(res_buffer, "p2p_device_address", (char*) device_address);
+ if(strlen(device_address) ==18)
+ {
+ wfd_macaddr_atoe((char*) device_address, device_mac);
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Extracting value failed\n");
+ return -1;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+}
+
+int wfd_ws_set_oem_loglevel(int is_increase)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ snprintf(cmd, sizeof(cmd), "%s %d", CMD_LOG_LEVEL, is_increase);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request(LOG_LEVEL) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_assoc_sta_mac(unsigned char *mac_addr)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ memcpy(mac_addr, g_assoc_sta_mac, 6);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_disassoc_sta_mac(unsigned char *mac_addr)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ memcpy(mac_addr, g_disassoc_sta_mac, 6);
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_requestor_mac(unsigned char* mac_addr)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ memcpy(mac_addr, g_incomming_peer_mac_address, 6);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+int wfd_ws_get_operating_channel(void)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+ char item[32] = {0, };
+ char freq_value[32] = {0,};
+ int channel;
+
+
+ strncpy(cmd, CMD_STATUS_P2P, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(STATUS P2P) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ char* ptr = strstr(res_buffer, "frequency=");
+ if (ptr==NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Can't find frequency field...\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if (__get_item_value(ptr, item, freq_value) == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Can't get value of frequency...\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if (strcmp(item, "frequency")!=0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Can't get frequency.... item=[%s]\n", item);
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "freq_value=[%s]\n", freq_value);
+
+ channel = __convert_freq_to_channel(freq_value);
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "channel=[%d]\n", channel);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return channel;
+
+}
+
+
+/* -------------------- Miracast ---------------------------*/
+
+
+int wfd_ws_dsp_init(void)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[32] = {0, };
+ char res_buffer[1024]={0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result;
+
+ int enable = 1;
+ char* dev_info = "0400";
+ int ctrl_port = 2022;
+ int max_tput = 40;
+ char* cpled_sink_status = "00";
+
+ /* param : enable*/
+ snprintf(cmd, sizeof(cmd), "%s enable %d", CMD_WFD_SET, enable);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED[param : enable]!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ /* param : dev_info */
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s dev_info %s", CMD_WFD_SET, dev_info);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED[param : dev_info]!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ /* param : ctrl_port */
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s ctrl_port %d", CMD_WFD_SET, ctrl_port);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED[param : ctrl_port]!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ /* param : max_tput */
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s max_tput %d", CMD_WFD_SET, max_tput);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED[param : max_tput]!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ /* param : cpled_sink_status */
+ memset(cmd, 0x0, 32);
+ memset(res_buffer, 0x0, 1024);
+
+ snprintf(cmd, sizeof(cmd), "%s cpled_sink_status %s", CMD_WFD_SET, cpled_sink_status);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_WFD_SET) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED[param : cpled_sink_status]!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+int wfd_ws_get_persistent_group_info(wfd_persistent_group_info_s ** persistent_group_list, int* persistent_group_num)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char cmd[16] = {0, };
+ char mac_str[18] = {0, };
+ char res_buffer[1024] = {0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result = 0;
+ int i;
+ ws_network_info_s ws_persistent_group_list[MAX_PERSISTENT_GROUP_NUM];
+ wfd_persistent_group_info_s wfd_persistent_group_list[MAX_PERSISTENT_GROUP_NUM];
+
+ memset(ws_persistent_group_list, 0, (sizeof(ws_network_info_s)*MAX_PERSISTENT_GROUP_NUM));
+ memset(wfd_persistent_group_list, 0, (sizeof(wfd_persistent_group_info_s)*MAX_PERSISTENT_GROUP_NUM));
+
+ /* Reading lists the configured networks, including stored information for persistent groups.
+ The identifier in this is used with p2p_group_add and p2p_invite to indicate witch persistent
+ group is to be reinvoked. */
+ strncpy(cmd, CMD_GET_LIST_NETWORKS, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(LIST_NETWORKS) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ *persistent_group_num = 0;
+ *persistent_group_list = NULL;
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ *persistent_group_num = 0;
+ *persistent_group_list = NULL;
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __parsing_persistent_group(res_buffer, ws_persistent_group_list, persistent_group_num);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Persistent Group Count=%d\n", *persistent_group_num);
+ for(i=0;i<(*persistent_group_num);i++)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "----persistent group [%d]----\n", i);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "network_id=%d\n", ws_persistent_group_list[i].network_id);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "ssid=%s\n", ws_persistent_group_list[i].ssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "bssid=%s\n", ws_persistent_group_list[i].bssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "flags=%s\n", ws_persistent_group_list[i].flags);
+
+
+// TODO: should filer by [PERSISTENT] value of flags.
+
+
+ strncpy(wfd_persistent_group_list[i].ssid, ws_persistent_group_list[i].ssid, sizeof(wfd_persistent_group_list[i].ssid));
+
+ unsigned char la_mac_addr[6];
+ wfd_macaddr_atoe(ws_persistent_group_list[i].bssid, la_mac_addr);
+ memcpy(wfd_persistent_group_list[i].go_mac_address, la_mac_addr, 6);
+ }
+
+ *persistent_group_list = &wfd_persistent_group_list[0];
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+
+}
+
+int wfd_ws_remove_persistent_group(wfd_persistent_group_info_s *persistent_group)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+ char cmd[32] = {0, };
+ char res_buffer[1024] = {0,};
+ int res_buffer_len = sizeof(res_buffer);
+ int result = 0;
+ int i;
+ ws_network_info_s ws_persistent_group_list[MAX_PERSISTENT_GROUP_NUM];
+ int persistent_group_num;
+ char go_mac_str[18];
+
+ memset(ws_persistent_group_list, 0, (sizeof(ws_network_info_s)*MAX_PERSISTENT_GROUP_NUM));
+ memset(go_mac_str, 0, sizeof(go_mac_str));
+ snprintf(go_mac_str, 18, MACSTR, MAC2STR(persistent_group->go_mac_address));
+
+ strncpy(cmd, CMD_GET_LIST_NETWORKS, sizeof(cmd));
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(LIST_NETWORKS) result=[%d]\n", result);
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+ __parsing_persistent_group(res_buffer, ws_persistent_group_list, &persistent_group_num);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Persistent Group Count=%d\n", persistent_group_num);
+ for(i=0;i<persistent_group_num;i++)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "----persistent group [%d]----\n", i);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "network_id=%d\n", ws_persistent_group_list[i].network_id);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "ssid=%s\n", ws_persistent_group_list[i].ssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "bssid=%s\n", ws_persistent_group_list[i].bssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "flags=%s\n", ws_persistent_group_list[i].flags);
+
+// TODO: should filer by [PERSISTENT] value of flags.
+
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "persistent_group->ssid [%s]----\n", persistent_group->ssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "ws_persistent_group_list[i].ssid [%s]----\n", ws_persistent_group_list[i].ssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "go_mac_str [%s]----\n", go_mac_str);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "ws_persistent_group_list[i].bssid [%s]----\n", ws_persistent_group_list[i].bssid);
+
+ if (strcmp(persistent_group->ssid, ws_persistent_group_list[i].ssid) == 0
+ && strcmp(go_mac_str, ws_persistent_group_list[i].bssid) == 0)
+ {
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "----Found persistent group [%d]----\n", i);
+
+ memset(cmd, 0x0, sizeof(cmd));
+ memset(res_buffer, 0x0, sizeof(res_buffer));
+
+ snprintf(cmd, sizeof(cmd), "%s %d", CMD_REMOVE_NETWORK, ws_persistent_group_list[i].network_id);
+ result = __send_wpa_request(g_control_sockfd, cmd, (char*)res_buffer, res_buffer_len);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "__send_wpa_request(CMD_REMOVE_NETWORK) result=[%d]\n", result);
+
+ if (result < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "__send_wpa_request FAILED[CMD_REMOVE_NETWORK]!!\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+ if ( (result == 0) || (strncmp(res_buffer, "FAIL", 4) == 0))
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return false;
+ }
+
+
+ break;
+ }
+
+ }
+
+
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+
+
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(wfd-manager C)
+
+# Global setting
+SET(VERSION 0.0)
+
+# Build type : Release
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+# Set required packages
+INCLUDE(FindPkgConfig)
+pkg_check_modules(pkgs REQUIRED wifi-direct vconf glib-2.0 dbus-1 dbus-glib-1 gthread-2.0 dlog capi-appfw-application)
+
+FOREACH(flag ${pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag} -g -DVITA_FEATURE")
+ENDFOREACH(flag)
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/src/include
+ ${CMAKE_SOURCE_DIR}/oem/include)
+
+
+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")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+
+# Linker flags
+#SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed")
+
+
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+IF("${ARCH}" MATCHES "^arm.*")
+ SET(SRCS
+ wifi-direct-main.c
+ wifi-direct-utils.c
+ wifi-direct-stub.c
+ wifi-direct-state.c
+ wifi-direct-dhcp.c
+ wifi-direct-client-handler.c
+ wifi-direct-event-handler.c
+ ${CMAKE_SOURCE_DIR}/oem/wifi-direct-oem.c
+ )
+ MESSAGE("Build for Target")
+
+ ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
+
+ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS} -ldl)
+
+ # pkgconfig file
+ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+
+ # Install
+ INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd.p2p.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd.wl0.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd.eth.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/udhcp_script.non-autoip DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/p2p_suppl.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd-notify.sh DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/wifi-direct-server.sh DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/wifi-direct-dhcp.sh DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/p2p_supp.sh DESTINATION sbin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/p2p_supplicant DESTINATION sbin)
+
+ELSE()
+ SET(SRCS
+ wifi-direct-main.c
+ wifi-direct-utils.c
+ wifi-direct-stub.c
+ wifi-direct-state.c
+ wifi-direct-dhcp.c
+ wifi-direct-client-handler.c
+ wifi-direct-event-handler.c
+ ${CMAKE_SOURCE_DIR}/oem/wifi-direct-oem.c
+ )
+ MESSAGE("Build for Emulator")
+
+ ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
+ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${pkgs_LDFLAGS} -ldl)
+
+ # pkgconfig file
+ SET(PREFIX ${CMAKE_INSTALL_PREFIX})
+
+ # Install
+ INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd.p2p.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd.wl0.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd.eth.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/udhcp_script.non-autoip DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/p2p_suppl.conf DESTINATION etc/wifi-direct)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/dhcpd-notify.sh DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/wifi-direct-server.sh DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/wifi-direct-dhcp.sh DESTINATION bin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/p2p_supp.sh DESTINATION sbin)
+ INSTALL(FILES ${CMAKE_SOURCE_DIR}/files/p2p_supplicant DESTINATION sbin)
+
+ENDIF()
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#ifndef __WIFI_DIRECT_CLIENT_HANDLER_H_
+#define __WIFI_DIRECT_CLIENT_HANDLER_H_
+
+#include "wifi-direct.h"
+
+//void wfd_server_process_client_request(wifi_direct_client_request_s * client_req);
+
+
+#endif //__WIFI_DIRECT_CLIENT_HANDLER_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#ifndef __WIFI_DIRECT_EVENT_HANDLER_H_
+#define __WIFI_DIRECT_EVENT_HANDLER_H_
+
+/**
+ * @enum wfd_event_t
+ * Wi-Fi Direct event
+ */
+typedef enum {
+ WFD_EVENT_INVALID = -1,
+ WFD_EVENT_DISCOVER_START_80211_SCAN,
+ WFD_EVENT_DISCOVER_START_SEARCH_LISTEN,
+ WFD_EVENT_DISCOVER_FOUND_PEERS,
+ WFD_EVENT_DISCOVER_FOUND_P2P_GROUPS,
+ WFD_EVENT_DISCOVER_CANCEL,
+ WFD_EVENT_DISCOVER_COMPLETE,
+ WFD_EVENT_DISCOVER_FAIL,
+ WFD_EVENT_DISCOVER_RESUMED,
+ WFD_EVENT_DISCOVER_SUSPENDED,
+ WFD_EVENT_DISCOVER_START_LISTEN_ONLY,
+
+ WFD_EVENT_PROV_DISCOVERY_REQUEST,
+ WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY,
+ WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD,
+ WFD_EVENT_PROV_DISCOVERY_RESPONSE,
+ WFD_EVENT_PROV_DISCOVERY_TIMEOUT,
+
+ WFD_EVENT_INVITE_REQUEST,
+ WFD_EVENT_INVITE_RESPONSE,
+
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_START,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_AP_ACK,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_STA_ACK,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_REQUEST_RECEIVED,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_COMPLETE,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_ALREADY_CONNECTED,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_FAIL,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_NO_PROV_INFO,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_INFO_UNAVAIL,
+ WFD_EVENT_GROUP_OWNER_NEGOTIATION_FAIL_INTENT,
+ WFD_EVENT_CREATE_LINK_START,
+ WFD_EVENT_CREATE_LINK_CANCEL,
+ WFD_EVENT_CREATE_LINK_DOWN,
+ WFD_EVENT_CREATE_LINK_TIMEOUT,
+ WFD_EVENT_CREATE_LINK_AUTH_FAIL,
+ WFD_EVENT_CREATE_LINK_FAIL,
+ WFD_EVENT_CREATE_LINK_COMPLETE,
+
+ WFD_EVENT_IP_ASSIGNED,
+ WFD_EVENT_IP_LEASED,
+
+ WFD_EVENT_CONNECT_PBC_START,
+
+ WFD_EVENT_SOFTAP_START,
+ WFD_EVENT_SOFTAP_READY,
+ WFD_EVENT_SOFTAP_STA_ASSOC,
+ WFD_EVENT_SOFTAP_STA_DISASSOC,
+ WFD_EVENT_SOFTAP_FAIL,
+ WFD_EVENT_SOFTAP_STOP,
+
+ WFD_EVENT_WPS_START,
+ WFD_EVENT_WPS_STATUS_SCANNING,
+ WFD_EVENT_WPS_STATUS_SCANNING_OVER,
+ WFD_EVENT_WPS_STATUS_ASSOCIATING,
+ WFD_EVENT_WPS_STATUS_ASSOCIATED,
+ WFD_EVENT_WPS_STATUS_WPS_MSG_EXCHANGE,
+ WFD_EVENT_WPS_STATUS_DISCONNECTING,
+ WFD_EVENT_WPS_PROTOCOL_FAIL,
+ WFD_EVENT_WPS_FAIL,
+ WFD_EVENT_WPS_WRONG_PIN,
+ WFD_EVENT_WPS_TIMEOUT,
+ WFD_EVENT_WPS_SESSION_OVERLAP,
+ WFD_EVENT_WPS_COMPLETE,
+
+ WFD_EVENT_PRIMARY_IF_DISCONNECTION,
+ WFD_EVENT_SVC_REQ_RECEIVED,
+ WFD_EVENT_SVC_RESP_RECEIVED,
+ WFD_EVENT_SVC_COMEBACK_REQ_RECEIVED,
+ WFD_EVENT_SVC_COMEBACK_RESP_RECEIVED,
+ WFD_EVENT_DEV_DISCOVERABILITY_REQ,
+ WFD_EVENT_DEV_DISCOVERABILITY_RSP,
+ WFD_EVENT_GO_DISCOVERABILITY_REQ,
+
+ WFD_EVENT_MAX,
+} wfd_event_t;
+
+typedef void (*wfd_oem_event_cb) (wfd_event_t event);
+
+#endif //__WIFI_DIRECT_EVENT_HANDLER_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#ifndef __WIFI_DIRECT_SERVICE_H_
+#define __WIFI_DIRECT_SERVICE_H_
+
+#include "wifi-direct.h"
+#include "wifi-direct-internal.h"
+#include "wifi-direct-event-handler.h"
+//#include "wifi-direct-utils.h"
+
+/*****************************************************************************
+ * Macros
+ *****************************************************************************/
+#define WFD_MAX_CLIENTS 16
+#define WFD_MAC_ASSOC_STA 8
+
+#define WFD_SERVER_SOCKET_PATH "/tmp/wfd_client_socket"
+
+/*****************************************************************************
+ * Definitions
+ *****************************************************************************/
+
+typedef struct
+{
+ bool isUsed;
+ int client_id;
+ int sync_sockfd;
+ int async_sockfd;
+ int dev_handle;
+ int g_source_id;
+} wfd_server_client_t;
+
+
+
+/**
+ * @enum wfd_connected_dev_info_t
+ * Wi-Fi Direct buffer structure to store device information of connected peer */
+typedef struct
+{
+ /** Null-terminated device friendly name. */
+ char ssid[WIFI_DIRECT_MAX_SSID_LEN + 1];
+
+ /** Peer's P2P Device Address */
+ unsigned char mac_address[6];
+
+ /** Peer's P2P Interface Address. Valid only if our device is a P2P GO. */
+ unsigned char int_address[6];
+
+ /** Peer's P2P IP Address. Valid only if our device is a P2P GO. */
+ unsigned char ip_address[4];
+
+} wfd_connected_dev_info_t;
+
+
+/**
+ * @enum wfd_connected_dev_info_t
+ * Wi-Fi Direct buffer structure to store device information of connected peer */
+typedef struct
+{
+ bool isUsed;
+
+ wfd_discovery_entry_s peer;
+
+ /** Peer's P2P Interface Address. Valid only if our device is a P2P GO. */
+ unsigned char int_address[6];
+
+ /** Peer's P2P IP Address. Valid only if our device is a P2P GO. */
+ unsigned char ip_address[4];
+} wfd_local_connected_peer_info_t;
+
+
+typedef struct
+{
+ wfd_server_client_t client[WFD_MAX_CLIENTS];
+ int active_clients;
+
+ int sync_sockfd;
+ int async_sockfd;
+
+ wfd_config_data_s config_data;
+
+ wifi_direct_state_e state;
+
+ wfd_discovery_entry_s current_peer; // it is used during connecting/disconnecting
+
+ wfd_local_connected_peer_info_t connected_peers[WFD_MAC_ASSOC_STA];
+ int connected_peer_count;
+
+ int dhcp_pid;
+
+ void* mainloop;
+
+ /** Daemon timer */
+ int connection_timer;
+ int termination_timer;
+ int discovery_timer;
+
+ int dhcp_ip_address_timer;
+
+ /** Autonomous Group mode */
+ bool autonomous_group_owner;
+
+}wfd_server_control_t;
+
+
+/*****************************************************************************
+ * Functions
+ *****************************************************************************/
+wfd_server_control_t * wfd_server_get_control();
+char * wfd_server_print_cmd(wifi_direct_cmd_e cmd);
+
+void wfd_refresh_wifi_direct_state(void *data);
+
+int wfd_server_check_valid(wifi_direct_cmd_e command);
+void wfd_server_set_state(int state);
+int wfd_server_get_state();
+void wfd_timer_connection_start();
+void wfd_timer_connection_cancel();
+void wfd_termination_timer_start();
+void wfd_termination_timer_cancel();
+void wfd_timer_discovery_start(int seconds);
+void wfd_timer_discovery_cancel();
+
+int wfd_server_is_connected_peer_by_device_mac(unsigned char device_mac[6]);
+wfd_local_connected_peer_info_t*
+wfd_server_get_connected_peer_by_device_mac(unsigned char device_mac[6]);
+wfd_local_connected_peer_info_t*
+wfd_server_get_connected_peer_by_interface_mac(unsigned char int_mac[6]);
+int wfd_server_is_connected_peer_by_interface_mac(unsigned char interface_mac[6]);
+void wfd_server_remove_connected_peer_by_interface_mac(unsigned char interface_mac[6]);
+void wfd_server_remove_connected_peer(wfd_discovery_entry_s * peer);
+void wfd_server_add_connected_peer(wfd_discovery_entry_s* peer, unsigned char interface_mac[6], char* ip_address);
+void wfd_server_reset_connecting_peer();
+bool wfd_server_clear_connected_peer();
+bool wfd_server_remember_connecting_peer(unsigned char device_mac[6]);
+void wfd_server_process_event(wfd_event_t event);
+
+char *__wfd_server_print_event(wfd_event_t event);
+char *__wfd_print_client_event(wfd_client_event_e event);
+char *wfd_print_state(wifi_direct_state_e s);
+
+
+#endif //__WIFI_DIRECT_SERVICE_H_
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#ifndef __WIFI_DIRECT_STUB_H_
+#define __WIFI_DIRECT_STUB_H_
+
+#include "wifi-direct-internal.h"
+#include "wifi-direct-utils.h"
+
+int wfd_server_is_fd_writable(int fd);
+bool wfd_server_register_client(int sockfd);
+void wfd_server_process_client_request(wifi_direct_client_request_s * client_req);
+void wfd_server_reset_client(int sync_sockfd);
+void wfd_server_print_client();
+int wfd_server_read_socket_event(int sockfd, char* dataptr, int datalen);
+
+#endif //__WIFI_DIRECT_STUB_H_
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+
+
+#ifndef __WIFI_DIRECT_UTILS_H_
+#define __WIFI_DIRECT_UTILS_H_
+
+/*****************************************************************************
+ * Standard headers
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Platform headers
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Extern Functions
+ *****************************************************************************/
+
+int wfd_macaddr_atoe(char *p, unsigned char mac[]);
+
+/*****************************************************************************
+ * Macros
+ *****************************************************************************/
+
+
+#ifdef VITA_FEATURE
+#include <dlog.h>
+
+#define WIFI_DIRECT_SERVER_MID "wfd-server"
+
+#define WFD_LOG_LOW LOG_VERBOSE
+#define WFD_LOG_HIGH LOG_INFO
+#define WFD_LOG_ERROR LOG_ERROR
+#define WFD_LOG_WARN LOG_WARN
+#define WFD_LOG_ASSERT LOG_FATAL
+#define WFD_LOG_EXCEPTION LOG_FATAL
+
+char * wfd_debug_print(char* file, int line, char* format, ...);
+char * wfd_trimming_path(const char* filewithpath);
+
+char * wfd_trim_path(const char* filewithpath);
+int wfd_gettid();
+
+#define WFD_SERVER_LOG(log_level, format, args...) \
+ LOG(log_level, WIFI_DIRECT_SERVER_MID, "[%s:%04d,%d] " format, wfd_trim_path(__FILE__), __LINE__,wfd_gettid(),##args)
+#define __WFD_SERVER_FUNC_ENTER__ LOG(LOG_VERBOSE, WIFI_DIRECT_SERVER_MID, "[%s:%04d,%d] Enter: %s()\n", wfd_trim_path(__FILE__), __LINE__,wfd_gettid(),__func__)
+#define __WFD_SERVER_FUNC_EXIT__ LOG(LOG_VERBOSE, WIFI_DIRECT_SERVER_MID, "[%s:%04d,%d] Quit: %s()\n", wfd_trim_path(__FILE__), __LINE__,wfd_gettid(),__func__)
+
+#else /** _DLOG_UTIL */
+
+#define WFD_SERVER_LOG(log_level, format, args...) printf("[%s:%04d,%d] " format, wfd_trim_path(__FILE__), __LINE__,wfd_gettid(), ##args)
+#define __WFD_SERVER_FUNC_ENTER__ printf("[%s:%04d,%d] Entering: %s()\n", wfd_trim_path(__FILE__), __LINE__,wfd_gettid(),__func__)
+#define __WFD_SERVER_FUNC_EXIT__ printf("[%s:%04d,%d] Quit: %s()\n", wfd_trim_path(__FILE__), __LINE__,wfd_gettid(),__func__)
+
+#endif /** _USE_DLOG_UTIL */
+
+
+#endif /** __WIFI_DIRECT_UTILS_H_ */
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#include <glib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+#include <vconf.h>
+#include <vconf-keys.h>
+
+#include "wifi-direct-client-handler.h"
+#include "wifi-direct-internal.h"
+#include "wifi-direct-service.h"
+#include "wifi-direct-stub.h"
+#include "wifi-direct-oem.h"
+
+
+
+int wfd_check_wifi_status()
+{
+ int wifi_state = 0;
+
+ /* vconf key and value (vconf-keys.h)
+#define VCONFKEY_WIFI_STATE "memory/wifi/state"
+enum {
+ VCONFKEY_WIFI_OFF = 0x00,
+ VCONFKEY_WIFI_UNCONNECTED,
+ VCONFKEY_WIFI_CONNECTED,
+ VCONFKEY_WIFI_TRANSFER,
+ VCONFKEY_WIFI_STATE_MAX
+};
+ */
+
+ /* Check wifi state again */
+ if (vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error reading vconf (%s)\n", VCONFKEY_WIFI_STATE);
+ return -1;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "VCONFKEY_WIFI_STATE(%s) : %d\n", VCONFKEY_WIFI_STATE, wifi_state);
+ if (wifi_state > VCONFKEY_WIFI_OFF)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Sorry. Wi-Fi is on\n");
+ return 0;
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "OK. Wi-Fi is off\n");
+ }
+ return 1;
+}
+
+int wfd_check_mobile_ap_status()
+{
+ int mobile_ap_state = 0;
+
+ /* Check wifi state again */
+ if (vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &mobile_ap_state) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error reading vconf (%s)\n", VCONFKEY_MOBILE_HOTSPOT_MODE);
+ return -1;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "VCONFKEY_WIFI_STATE(%s) : %d\n", VCONFKEY_MOBILE_HOTSPOT_MODE, mobile_ap_state);
+ if (mobile_ap_state != VCONFKEY_MOBILE_HOTSPOT_MODE_NONE)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Sorry. Mobile AP is on\n");
+ return 0;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "OK. Mobile AP is off\n");
+ }
+ }
+ return 1;
+}
+
+
+int wfd_set_wifi_direct_state(int state)
+{
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "VCONFKEY_WIFI_DIRECT_STATE(%s) : %d\n", VCONFKEY_WIFI_DIRECT_STATE, state);
+
+ if (vconf_set_int(VCONFKEY_WIFI_DIRECT_STATE, state) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error setting vconf (%s)\n", VCONFKEY_WIFI_DIRECT_STATE);
+ return -1;
+ }
+
+ return 1;
+}
+
+int wfd_check_wifi_direct_state()
+{
+ int wifi_direct_state = 0;
+
+ if (vconf_get_int(VCONFKEY_WIFI_DIRECT_STATE, &wifi_direct_state) < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error reading vconf (%s)\n", VCONFKEY_WIFI_DIRECT_STATE);
+ return -1;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "VCONFKEY_WIFI_DIRECT_STATE(%s) : %d\n", VCONFKEY_WIFI_DIRECT_STATE, wifi_direct_state);
+
+ switch(wifi_direct_state)
+ {
+ case VCONFKEY_WIFI_DIRECT_DEACTIVATED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Wi-Fi direct is off\n");
+ }
+ break;
+
+ case VCONFKEY_WIFI_DIRECT_ACTIVATED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Wi-Fi direct is on\n");
+ }
+ break;
+
+ case VCONFKEY_WIFI_DIRECT_DISCOVERING:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Wi-Fi direct is discovering\n");
+ }
+ break;
+
+ case VCONFKEY_WIFI_DIRECT_CONNECTED:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Wi-Fi direct is connected\n");
+ }
+ break;
+
+ case VCONFKEY_WIFI_DIRECT_GROUP_OWNER:
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Wi-Fi direct is group owner\n");
+ }
+ break;
+
+ default:
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ERROR:Wi-Fi direct is unkown state\n");
+ return -1;
+ }
+ break;
+ }
+ }
+ return wifi_direct_state;
+}
+
+
+int wfd_get_device_name(char* str, int len)
+{
+ char* get_str = NULL;
+ if (str==NULL || len <=0)
+ return -1;
+
+ get_str = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
+
+ if (get_str == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error reading vconf (%s)\n", VCONFKEY_SETAPPL_DEVICE_NAME_STR);
+ return -1;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "VCONFKEY_WIFI_STATE(%s) : %d\n", VCONFKEY_SETAPPL_DEVICE_NAME_STR, get_str);
+ strncpy(str, get_str, len);
+ return 0;
+ }
+}
+
+
+void wfd_set_device_name_to_ssid()
+{
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+ char device_name[WIFI_DIRECT_MAX_SSID_LEN + 1];
+ wifi_direct_state_e state = wfd_server_get_state();
+
+ if (wfd_get_device_name(device_name, WIFI_DIRECT_MAX_SSID_LEN) != -1)
+ {
+ strncpy(wfd_server->config_data.ssid, device_name, WIFI_DIRECT_MAX_SSID_LEN);
+ wfd_oem_set_ssid(device_name);
+
+ // In WIFI_DIRECT_STATE_ACTIVATED state, devie name will be applied to ssid immediately.
+ // In other sate, it will be set in next discovery start.
+ if (state == WIFI_DIRECT_STATE_ACTIVATED)
+ {
+ wfd_oem_cancel_discovery();
+ wfd_oem_start_discovery(false,0);
+ }
+ return;
+ }
+}
+
+void __wfd_device_name_change_cb(keynode_t *key, void* data)
+{
+ WFD_SERVER_LOG(WFD_LOG_LOW, "device name has been changed. change ssid (friendly name)..\n");
+ wfd_set_device_name_to_ssid();
+}
+
+int wfd_set_device_name_as_ssid()
+{
+ wfd_set_device_name_to_ssid();
+ vconf_notify_key_changed(VCONFKEY_SETAPPL_DEVICE_NAME_STR, __wfd_device_name_change_cb, NULL);
+}
+
+void __wfd_server_print_entry_list(wfd_discovery_entry_s * list, int num)
+{
+ int i = 0;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "------------------------------------------\n");
+ for(i = 0; i < num; i++)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "== Peer index : %d ==\n", i);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "is Group Owner ? %s\n", list[i].is_group_owner ? "YES" : "NO");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "is Connected ? %s\n", list[i].is_connected ? "YES" : "NO");
+ WFD_SERVER_LOG( WFD_LOG_LOW, "SSID : %s\n", list[i].ssid);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "MAC address : " MACSTR "\n", MAC2STR(list[i].mac_address));
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Device type [%d/%d] ==\n", list[i].category, list[i].subcategory);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "wps cfg method [%d] ==\n", list[i].wps_cfg_methods);
+
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "------------------------------------------\n");
+}
+
+void __wfd_server_print_connected_peer_info(wfd_connected_peer_info_s* list, int num)
+{
+ int i = 0;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "------------------------------------------\n");
+ for(i = 0; i < num; i++)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "CONN[%d] ssid=[%s]\n",
+ i,
+ list[i].ssid);
+ WFD_SERVER_LOG(WFD_LOG_LOW, " cat=[%d] svc=[%d] isp2p=[%d] channel=[%d]\n",
+ list[i].category,
+ list[i].services,
+ list[i].is_p2p,
+ list[i].channel);
+ WFD_SERVER_LOG( WFD_LOG_LOW, " mac dev/Intf=[" MACSTR "/" MACSTR "]\n",
+ MAC2STR(list[i].mac_address),
+ MAC2STR(list[i].intf_mac_address));
+ WFD_SERVER_LOG( WFD_LOG_LOW, " IP =["IPSTR"]\n",
+ IP2STR(list[i].ip_address));
+ }
+ WFD_SERVER_LOG( WFD_LOG_LOW, "------------------------------------------\n");
+}
+
+wfd_server_client_t * wfd_server_find_client(int client_id)
+{
+ int i = 0;
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ for(i = 0; i < WFD_MAX_CLIENTS; i++)
+ {
+ if(wfd_server->client[i].client_id == client_id)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "index [%d] client id [%d]\n", i, wfd_server->client[i].client_id);
+ return &(wfd_server->client[i]);
+ }
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "No Matching client!! client id [%d]\n", client_id);
+ return NULL;
+}
+
+int wfd_server_find_peer_by_macaddr(wfd_discovery_entry_s *plist, int entry_size, unsigned char macaddr[6])
+{
+ int i = 0;
+ __WFD_SERVER_FUNC_ENTER__;
+
+ if (plist == NULL)
+ return -1;
+
+ if (entry_size < 0 || entry_size > WFD_MAX_CLIENTS)
+ return -2;
+
+ for(i = 0; i < entry_size; i++)
+ {
+ if(memcmp((void*)&plist[i].mac_address[0], (void*)&macaddr[0], sizeof(macaddr))==0)
+ {
+ return i;
+ }
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "No Matching client!! client mac addr\n");
+
+ return -3;
+}
+
+
+int wfd_server_send_response(int sockfd, void * data, int len)
+{
+ int ret_val = 0;
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+ wifi_direct_client_response_s* resp = (wifi_direct_client_response_s*) data;
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Send sync resp cmd=[%d], result=[%d], len=[%d]\n", resp->cmd, resp->result, len);
+
+ wfd_server->sync_sockfd = sockfd;
+
+ if (wfd_server_is_fd_writable(sockfd) <= 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "socketfd[%d] write is not possible!! \n", sockfd);
+ return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
+ }
+
+ ret_val = write(sockfd, (char*)data, len);
+ if(ret_val <= 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "socket write FAILED!!! [%s]\n", strerror(errno));
+ return WIFI_DIRECT_ERROR_COMMUNICATION_FAILED;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return WIFI_DIRECT_ERROR_NONE;
+}
+
+void wfd_server_process_client_request(wifi_direct_client_request_s * client_req)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ int ret = WIFI_DIRECT_ERROR_NONE;
+ wifi_direct_client_response_s resp;
+ wfd_server_control_t * wfd_server = wfd_server_get_control();
+ wfd_server_client_t * client = wfd_server_find_client(client_req->client_id);
+ wifi_direct_client_noti_s noti;
+
+ if(client == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Invalid client id [%d]\n", client_req->client_id);
+ return ;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Requested Cmd [%d, %s]\n", client_req->cmd, wfd_server_print_cmd(client_req->cmd));
+
+ memset(&resp, 0, sizeof(wifi_direct_client_response_s));
+ resp.client_id = client_req->client_id;
+ resp.data_length = 0;
+ resp.cmd = client_req->cmd;
+
+ if (wfd_server_check_valid(client_req->cmd) == false) {
+ resp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
+ WFD_SERVER_LOG( WFD_LOG_HIGH, "Invalid command [%d] at state=[%d]\n", client_req->cmd, wfd_server->state);
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ switch(client_req->cmd)
+ {
+ case WIFI_DIRECT_CMD_DEREGISTER:
+ {
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ wfd_server_reset_client(client_req->client_id);
+ }
+ break;
+ case WIFI_DIRECT_CMD_ACTIVATE:
+ {
+ if (wfd_check_wifi_status() == 0)
+ {
+ resp.result = WIFI_DIRECT_ERROR_WIFI_USED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ return;
+ }
+ else if (wfd_check_mobile_ap_status() == 0)
+ {
+ resp.result =WIFI_DIRECT_ERROR_MOBILE_AP_USED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ return;
+ }
+ else
+ {
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+
+ int res = 0;
+ wifi_direct_client_noti_s noti;
+ memset(¬i, 0, sizeof(wifi_direct_client_noti_s));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_ACTIVATION;
+ noti.error = WIFI_DIRECT_ERROR_NONE;
+
+ // Initialize server db.
+ {
+ int i = -1;
+ unsigned char NULL_MAC[6] = {0,0,0,0,0,0};
+ for(i=0;i<WFD_MAC_ASSOC_STA;i++)
+ {
+ memset(&wfd_server->connected_peers[i], 0, sizeof(wfd_local_connected_peer_info_t));
+ wfd_server->connected_peers[i].isUsed = 0;
+ }
+ wfd_server->connected_peer_count = 0;
+ memcpy(wfd_server->current_peer.mac_address, NULL_MAC, 6);
+ }
+
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATING);
+
+ res = wfd_oem_activate();
+
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Device handle from oem res=[%d]\n", res);
+
+ if (res == false)
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_DEACTIVATED);
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ wfd_set_device_name_to_ssid();
+ wfd_oem_set_device_type(wfd_server->config_data.primary_dev_type,
+ wfd_server->config_data.secondary_dev_type);
+ wfd_oem_set_go_intent(7);
+
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+
+ noti.error = WIFI_DIRECT_ERROR_NONE;
+ }
+
+ __wfd_server_send_client_event(¬i);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_DEACTIVATE:
+ {
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ wfd_server_set_state(WIFI_DIRECT_STATE_DEACTIVATING);
+ wfd_oem_deactivate();
+ wfd_server_set_state(WIFI_DIRECT_STATE_DEACTIVATED);
+
+ wifi_direct_client_noti_s noti;
+ memset(¬i, 0, sizeof(wifi_direct_client_noti_s));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_DEACTIVATION;
+ noti.error = WIFI_DIRECT_ERROR_NONE;
+ __wfd_server_send_client_event(¬i);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_START_DISCOVERY:
+ {
+ bool listen_only = client_req->data.listen_only;
+ int timeout = client_req->data.timeout;
+ wifi_direct_state_e state = wfd_server_get_state();
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Flag of Listen only : %s timeout[%d]\n", listen_only ? "ON" : "OFF", timeout);
+
+ if (wfd_oem_start_discovery(listen_only, timeout)==true)
+ {
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||
+ state == WIFI_DIRECT_STATE_DISCOVERING)
+ wfd_server_set_state(WIFI_DIRECT_STATE_DISCOVERING);
+
+ if ( timeout>0 )
+ wfd_timer_discovery_start(timeout);
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+
+ }
+ else
+ {
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
+ {
+ ret = wfd_oem_cancel_discovery();
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_cancel_discovery() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT:
+ {
+ int peer_count = 0;
+ int total_msg_len = 0;
+ wfd_discovery_entry_s* plist;
+
+ wifi_direct_state_e state = wfd_server_get_state();
+ if (state > WIFI_DIRECT_STATE_ACTIVATING)
+ {
+ ret = wfd_oem_get_discovery_result(&plist, &peer_count);
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_get_discovery_result() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+
+ total_msg_len = sizeof(wifi_direct_client_response_s) + (sizeof(wfd_discovery_entry_s) * peer_count);
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Peer count : %d, total message size : %d\n", peer_count, total_msg_len);
+
+ char * msg = (char*)malloc(total_msg_len);
+ if(msg == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Memory Allocation is FAILED!!!!!![%d]\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.param1 = peer_count;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+
+ memset(msg, 0, total_msg_len);
+ memcpy(msg, &resp, sizeof(wifi_direct_client_response_s));
+ memcpy(msg + sizeof(wifi_direct_client_response_s), plist, sizeof(wfd_discovery_entry_s) * peer_count);
+
+ __wfd_server_print_entry_list((wfd_discovery_entry_s*)plist, peer_count);
+ wfd_server_send_response(client->sync_sockfd, msg, total_msg_len);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SEND_PROVISION_DISCOVERY_REQ:
+ {
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+#if 0
+ int peer_index = -1;
+ static wfd_discovery_entry_s plist[WFD_MAX_CLIENTS];
+ wifi_direct_wps_type_e wps_config;
+ memset(&plist, 0, sizeof(wfd_discovery_entry_s) * WFD_MAX_CLIENTS);
+ int peer_count = 0;
+
+ // TODO: need to check mac address validation and wps config
+
+ wps_config = WIFI_DIRECT_WPS_TYPE_PBC;
+ if (wfd_oem_send_provision_discovery_request(client_req->data.mac_addr, wps_config) == true)
+ {
+ wfd_server_remember_connecting_peer(client_req->data.mac_addr);
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+ else
+ {
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+#endif
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_CONNECT:
+ {
+ int peer_index = -1;
+ int peer_count = 0;
+ wifi_direct_wps_type_e wps_config;
+ int max_client;
+
+ max_client = wfd_server->config_data.max_clients;
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "max_client [%d] connected_peer_count[%d]\n", max_client, wfd_server->connected_peer_count);
+ if (wfd_server->connected_peer_count >= max_client)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... available number of clients is full!!\n");
+ resp.result = WIFI_DIRECT_ERROR_TOO_MANY_CLIENT;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ }
+ else
+ {
+ int is_groupowner = false;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+
+ wfd_server_set_state(WIFI_DIRECT_STATE_CONNECTING);
+
+ wfd_server_remember_connecting_peer(client_req->data.mac_addr);
+
+ is_groupowner = wfd_oem_is_groupowner();
+ if (is_groupowner==true)
+ {
+ ret = wfd_oem_send_invite_request(client_req->data.mac_addr);
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Invite request: ret = %d\n", ret);
+ }
+ else
+ {
+ wps_config = wfd_server->config_data.wps_config;
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "wps_config : %d\n", wps_config);
+
+ ret = wfd_oem_send_provision_discovery_request(client_req->data.mac_addr, wps_config, wfd_server->current_peer.is_group_owner);
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "ProvisionDiscovery request: ret = %d\n", ret);
+ }
+
+ if (ret == true)
+ {
+ wfd_oem_wps_pbc_start();
+
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(client_req->data.mac_addr));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_START;
+ noti.error = WIFI_DIRECT_ERROR_NONE;
+ }
+ else
+ {
+ if (is_groupowner == true)
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... fail to connect\n");
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ __wfd_server_send_client_event(¬i);
+ }
+
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_DISCONNECT_ALL:
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_DISCONNECTING);
+
+ // Response app first.
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+
+ if (wfd_oem_disconnect())
+ {
+ wfd_server->config_data.wps_config = WIFI_DIRECT_WPS_TYPE_PBC; // set wps_config to default value
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... wfd_oem_disconnect() failed\n");
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ __wfd_server_send_client_event(¬i);
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_DISCONNECT:
+ {
+ wfd_local_connected_peer_info_t* peer = NULL;
+
+ peer = wfd_server_get_connected_peer_by_device_mac(client_req->data.mac_addr);
+#if 0
+ if (peer == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Connected Peer not found!\n");
+ resp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ break;
+ }
+#endif
+
+ // Response app first.
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+
+ if (wfd_oem_is_groupowner() == TRUE)
+ {
+ if (NULL == peer)
+ {
+ if ( NULL == wfd_server->current_peer.intf_mac_address )
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "[wfd_server->current_peer.intf_mac_address] is NULL!\n");
+ resp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ break;
+ }
+
+ if (wfd_oem_disconnect_sta(wfd_server->current_peer.intf_mac_address))
+ {
+ wfd_server_remember_connecting_peer(client_req->data.mac_addr);
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... wfd_oem_disconnect() failed\n");
+ noti.event =WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ __wfd_server_send_client_event(¬i);
+ }
+ }
+ else
+ {
+ if (wfd_oem_disconnect_sta(peer->int_address))
+ {
+ wfd_server_remember_connecting_peer(client_req->data.mac_addr);
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... wfd_oem_disconnect() failed\n");
+ noti.event =WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ __wfd_server_send_client_event(¬i);
+ }
+ }
+
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_DISCONNECTING);
+
+ ret = wfd_oem_disconnect();
+ if (ret)
+ {
+ wfd_server_remember_connecting_peer(client_req->data.mac_addr);
+ wfd_server->config_data.wps_config = WIFI_DIRECT_WPS_TYPE_PBC; // set wps_config to default
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... wfd_oem_disconnect() failed\n");
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ __wfd_server_send_client_event(¬i);
+ }
+
+ }
+
+
+ }
+
+ break;
+ case WIFI_DIRECT_CMD_GET_LINK_STATUS:
+ {
+ int status = wfd_server_get_state();
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Link Status [%s]\n", wfd_print_state(status));
+ resp.param1 = status;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SEND_CONNECT_REQ:
+ {
+ int peer_index = -1;
+ int peer_count = 0;
+ wifi_direct_wps_type_e wps_config;
+ int max_client;
+
+ max_client = wfd_server->config_data.max_clients;
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "max_client [%d] connected_peer_count[%d]\n", max_client, wfd_server->connected_peer_count);
+ if (wfd_server->connected_peer_count >= max_client)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... available number of clients is full!!\n");
+ resp.result = WIFI_DIRECT_ERROR_TOO_MANY_CLIENT;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ }
+ else
+ {
+ wps_config = wfd_server->config_data.wps_config;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Connect to peer %02x:%02x:%02x:%02x:%02x:%02x\n",
+ client_req->data.mac_addr[0],
+ client_req->data.mac_addr[1],
+ client_req->data.mac_addr[2],
+ client_req->data.mac_addr[3],
+ client_req->data.mac_addr[4],
+ client_req->data.mac_addr[5]);
+
+ wfd_server_remember_connecting_peer(client_req->data.mac_addr);
+
+ wfd_server_set_state(WIFI_DIRECT_STATE_CONNECTING);
+
+ // Response app first.
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+
+ if (wfd_oem_connect(client_req->data.mac_addr, wps_config))
+ {
+ //strncpy(noti.param1, client_req->data.mac_addr, strlen(client_req->data.mac_addr));
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(client_req->data.mac_addr));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_START;
+ noti.error = WIFI_DIRECT_ERROR_NONE;
+
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error: wfd_oem_connect() failed..\n");
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(client_req->data.mac_addr));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ __wfd_server_send_client_event(¬i);
+
+
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_CONFIG:
+ {
+ int status = wfd_server_get_state();
+
+ resp.param1 = status;
+ resp.result = ret;
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(resp)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ if (wfd_server_send_response(client->sync_sockfd, &wfd_server->config_data, sizeof(wfd_config_data_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_CONFIG:
+ {
+ wfd_config_data_s config;
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)&config, sizeof(wfd_config_data_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.param1 = wfd_server_get_state();
+ resp.result = ret;
+
+ memcpy((void*)&wfd_server->config_data, (void*)&config, sizeof(wfd_config_data_s));
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_CREATE_GROUP:
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_CONNECTING);
+ ret = wfd_oem_create_group(wfd_server->config_data.ssid);
+ if (ret==false)
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);
+ wfd_server->autonomous_group_owner = true;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:
+ {
+ wfd_oem_activate_pushbutton();
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_IS_GROUPOWNER:
+ {
+ int owner = wfd_oem_is_groupowner();
+ resp.param1 = owner;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_SSID:
+ {
+ char ssid[32+1];
+
+ wifi_direct_state_e state = wfd_server_get_state();
+
+ if (state < WIFI_DIRECT_STATE_CONNECTED) /* Non-member state */
+ {
+ strncpy(ssid, wfd_server->config_data.ssid, WIFI_DIRECT_MAX_SSID_LEN);
+ sprintf(resp.param2, ssid);
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+ else /* GO or GC state */
+ {
+ if (wfd_oem_get_ssid(ssid, 32)==false)
+ {
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ sprintf(resp.param2, ssid);
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+
+ }
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_IP_ADDR:
+ {
+ char* ip_addr = wfd_oem_get_ip();
+ sprintf(resp.param2, ip_addr);
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_WPS_PIN:
+ {
+ char pin[WIFI_DIRECT_WPS_PIN_LEN+1];
+
+ memset(pin, 0, WIFI_DIRECT_WPS_PIN_LEN+1);
+
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)pin, WIFI_DIRECT_WPS_PIN_LEN) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ if ( NULL != pin )
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "PIN = [%s]\n", pin);
+ else
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "PIN is NULL !!\n");
+
+ ret = wfd_oem_set_wps_pin(pin);
+
+ if (ret == TRUE)
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ else
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_WPS_PIN:
+ {
+ char pin[WIFI_DIRECT_WPS_PIN_LEN+1];
+ memset(pin, 0, WIFI_DIRECT_WPS_PIN_LEN+1);
+
+ if (wfd_oem_get_wps_pin(pin, sizeof(pin)) == false)
+ {
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "wfd_oem_get_wps_pin() failed!\n");
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "pin [%s]\n", pin);
+ sprintf(resp.param2, pin);
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GENERATE_WPS_PIN:
+ {
+
+ if (wfd_oem_generate_wps_pin() == false)
+ {
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "wfd_oem_generate_wps_pin() failed!\n");
+ }
+ else
+ {
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_SSID:
+ {
+ char ssid[WIFI_DIRECT_MAX_SSID_LEN+1] = {0,};
+
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)ssid, WIFI_DIRECT_MAX_SSID_LEN) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ if ( NULL != ssid )
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ssid = [%s]\n", ssid);
+ else
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ssid is NULL !!\n");
+
+ ret = wfd_oem_set_ssid(ssid);
+
+ if (ret == TRUE)
+ {
+ strncpy(wfd_server->config_data.ssid, ssid, WIFI_DIRECT_MAX_SSID_LEN);
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+
+ else
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_WPA:
+ {
+ char new_wpa[64+1] = {0,};
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)new_wpa, 64) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ if ( NULL != new_wpa )
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "new_wpa = [%s]\n", new_wpa);
+ else
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "new_wpa is NULL !!\n");
+
+ if (wfd_oem_set_wpa_passphrase(new_wpa) == false)
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:
+ {
+ int wps_mode = wfd_oem_get_supported_wps_mode();
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "supported wps mode (%d)\n", wps_mode);
+ resp.param1 = wps_mode;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_CURRENT_WPS_MODE:
+ {
+ wifi_direct_wps_type_e wps_mode;
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)&wps_mode, sizeof(wifi_direct_wps_type_e)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "wps_mode (%d)\n", wps_mode);
+
+ resp.param1 = wfd_server_get_state();
+ resp.result = ret;
+
+ wfd_server->config_data.wps_config = wps_mode;
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
+ {
+ int total_msg_len = 0;
+ wfd_connected_peer_info_s* plist = NULL;
+ wfd_connected_peer_info_s plist_buf;
+ wfd_connected_peer_info_s* tmp_plist = NULL;
+ wfd_local_connected_peer_info_t* tmplist = NULL;
+ int peer_count = 0;
+ int i;
+ int val = 0;
+
+ wifi_direct_state_e state = wfd_server_get_state();
+ ret = WIFI_DIRECT_ERROR_NONE;
+ if (state == WIFI_DIRECT_STATE_CONNECTED)
+ {
+ val = wfd_oem_get_connected_peers_info(&tmp_plist, &peer_count);
+ if (val == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_get_connected_peers_info() failed..\n");
+ peer_count = 0;
+ tmp_plist = NULL;
+ ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ tmplist = wfd_server_get_connected_peer_by_interface_mac(tmp_plist[0].intf_mac_address);
+ if (tmplist == NULL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!! Can't find connected peer info of mac=[" MACSTR "]\n",
+ MAC2STR(tmp_plist[0].intf_mac_address));
+ peer_count = 0;
+ ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ memset(&plist_buf, 0, sizeof(plist_buf));
+ strncpy(plist_buf.ssid, tmplist->peer.ssid, sizeof(plist_buf.ssid));
+ memcpy(&plist_buf.intf_mac_address[0], &tmplist->int_address[0], 6);
+ memcpy(&plist_buf.mac_address[0], &tmplist->peer.mac_address[0], 6);
+ plist_buf.services = tmplist->peer.services;
+ plist_buf.is_p2p = 1;
+ plist_buf.category = tmplist->peer.category;
+ plist_buf.channel = wfd_oem_get_operating_channel();
+ memcpy(&plist_buf.ip_address[0], &tmplist->ip_address[0], 4);
+
+ plist = &plist_buf;
+ peer_count = 1;
+ }
+ }
+ }
+ else if (state == WIFI_DIRECT_STATE_GROUP_OWNER)
+ {
+ val = wfd_oem_get_connected_peers_info(&plist, &peer_count);
+ if (val == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_get_connected_peers_info() failed..\n");
+ ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ // Append Device MAC address
+ for(i=0;i<peer_count;i++)
+ {
+ tmplist = wfd_server_get_connected_peer_by_interface_mac(plist[i].intf_mac_address);
+ if (tmplist != NULL)
+ {
+ memcpy(&plist[i].mac_address[0], &tmplist->peer.mac_address[0], 6);
+ memcpy(&plist[i].ip_address[0], &tmplist->ip_address[0], 4);
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error, Cant' find connected peer by int_addr" MACSTR "!!\n",
+ MAC2STR(plist[i].intf_mac_address));
+ // continue...
+ }
+ }
+ }
+ }
+ else
+ {
+ plist = NULL;
+ peer_count = 0;
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "state != WIFI_DIRECT_STATE_CONNECTED\n");
+ ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
+ }
+
+ total_msg_len = sizeof(wifi_direct_client_response_s) + (sizeof(wfd_connected_peer_info_s) * peer_count);
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Peer count : %d, total message size : %d\n", peer_count, total_msg_len);
+
+ char * msg = (char*)malloc(total_msg_len);
+ if(msg == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Memory Allocation is FAILED!!!!!![%d]\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+ }
+
+ resp.param1 = peer_count;
+#if 0
+ if (ret == TRUE)
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+#else
+ resp.result = ret;
+#endif
+
+ memset(msg, 0, total_msg_len);
+ memcpy(msg, &resp, sizeof(wifi_direct_client_response_s));
+ if (peer_count > 0)
+ memcpy(msg + sizeof(wifi_direct_client_response_s), plist, sizeof(wfd_connected_peer_info_s) * peer_count);
+
+ __wfd_server_print_connected_peer_info((wfd_connected_peer_info_s*)plist, peer_count);
+
+ if (wfd_server_send_response(client->sync_sockfd, msg, total_msg_len) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_CANCEL_GROUP:
+ {
+ ret = wfd_oem_cancel_group();
+ if (ret==false)
+ {
+ //wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_GO_INTENT:
+ {
+ int intent;
+
+ ret = wfd_oem_get_go_intent(&intent);
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_get_go_intent() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.param1 = intent;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_GO_INTENT:
+ {
+ int intent;
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)&intent, sizeof(int)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "intent (%d)\n", intent);
+
+ ret = wfd_oem_set_go_intent(intent);
+
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_set_go_intent() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.param1 = wfd_server_get_state();
+ resp.result = ret;
+
+ wfd_server->config_data.group_owner_intent = intent;
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_MAX_CLIENT:
+ {
+ int max_client;
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)&max_client, sizeof(int)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "max_client (%d)\n", max_client);
+
+ resp.param1 = wfd_server_get_state();
+
+ if (max_client > WFD_MAC_ASSOC_STA)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "ERROR : Max client number shold be under [%d]\n", WFD_MAC_ASSOC_STA);
+ resp.result = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
+ }
+ else
+ {
+ wfd_server->config_data.max_clients = max_client;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ }
+
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_MAX_CLIENT:
+ {
+ int max_client;
+
+ max_client = wfd_server->config_data.max_clients;
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "max_client (%d)\n", max_client);
+ resp.param1 = max_client;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+
+ case WIFI_DIRECT_CMD_GET_DEVICE_MAC:
+ {
+
+ unsigned char device_mac[6] = {0,};
+
+ ret = wfd_oem_get_device_mac_address((unsigned char*)&device_mac);
+
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_get_device_mac_address() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ memcpy(resp.param2, device_mac, sizeof(device_mac));
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_IS_AUTONOMOUS_GROUP:
+ {
+ int autonomous_group = wfd_server->autonomous_group_owner;
+ resp.param1 = autonomous_group;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_AUTOCONNECTION_MODE:
+ {
+ bool autoconnection_mode;
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)&autoconnection_mode, sizeof(bool)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "autoconnection_mode (%d)\n", autoconnection_mode);
+
+ resp.param1 = wfd_server_get_state();
+ resp.result = ret;
+
+ wfd_server->config_data.auto_connection = autoconnection_mode;
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_IS_AUTOCONNECTION_MODE:
+ {
+ int auto_connection = (int)wfd_server->config_data.auto_connection;
+ resp.param1 = auto_connection;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_IS_DISCOVERABLE:
+ {
+#if 0
+ int discoverable = (int)wfd_oem_is_discovery_enabled();
+ resp.param1 = discoverable;
+#else
+ if ((wfd_server->state == WIFI_DIRECT_STATE_DISCOVERING)
+ || (wfd_server->autonomous_group_owner == TRUE))
+ resp.param1 = 1;
+ else
+ resp.param1 = 0;
+#endif
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:
+ {
+ int listen_only = (int)wfd_server->config_data.listen_only;
+ resp.param1 = listen_only;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_SET_OEM_LOGLEVEL:
+ {
+ if (client_req->data.listen_only)
+ wfd_oem_set_oem_loglevel(true);
+ else
+ wfd_oem_set_oem_loglevel(false);
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL:
+ {
+ int operating_channel = wfd_oem_get_operating_channel();
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "operating_channel (%d)\n", operating_channel);
+ resp.param1 = operating_channel;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_ACTIVATE_PERSISTENT_GROUP:
+ {
+ wfd_server->config_data.want_persistent_group = true;
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_DEACTIVATE_PERSISTENT_GROUP:
+ {
+ wfd_server->config_data.want_persistent_group = false;
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_IS_PERSISTENT_GROUP:
+ {
+ int persistent_group_enabled = (int)wfd_server->config_data.want_persistent_group;
+ resp.param1 = persistent_group_enabled;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+
+ case WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO:
+ {
+ int persistent_group_count = 0;
+ int total_msg_len = 0;
+ wfd_persistent_group_info_s* plist;
+
+ ret = wfd_oem_get_persistent_group_info(&plist, &persistent_group_count);
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_get_persistent_group_info() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ total_msg_len = sizeof(wifi_direct_client_response_s) + (sizeof(wfd_persistent_group_info_s) * persistent_group_count);
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "persistent_group_count : %d, total message size : %d\n", persistent_group_count, total_msg_len);
+
+ char * msg = (char*)malloc(total_msg_len);
+ if(msg == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Memory Allocation is FAILED!!!!!![%d]\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.param1 = persistent_group_count;
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+
+ memset(msg, 0, total_msg_len);
+ memcpy(msg, &resp, sizeof(wifi_direct_client_response_s));
+ memcpy(msg + sizeof(wifi_direct_client_response_s), plist, sizeof(wfd_persistent_group_info_s) * persistent_group_count);
+
+ wfd_server_send_response(client->sync_sockfd, msg, total_msg_len);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+
+ case WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP:
+ {
+ wfd_persistent_group_info_s persistent_group;
+
+ if(wfd_server_read_socket_event(client->sync_sockfd, (char*)&persistent_group, sizeof(wfd_persistent_group_info_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ ret = wfd_oem_remove_persistent_group(&persistent_group);
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_remove_persistent_group() failed..\n");
+ resp.result = WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s));
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+
+ resp.result = WIFI_DIRECT_ERROR_NONE;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+ break;
+
+ default:
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! Invalid cmd = [%d] \n", client_req->cmd);
+ resp.result = WIFI_DIRECT_ERROR_NOT_PERMITTED;
+ if (wfd_server_send_response(client->sync_sockfd, &resp, sizeof(wifi_direct_client_response_s)) < 0)
+ {
+ wfd_server_reset_client(client->sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ break;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+
+
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#include <glib.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+
+#include <sys/stat.h>
+#include <sys/socket.h>
+#include <errno.h>
+#include <linux/wireless.h>
+#include <sys/ioctl.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <sys/wait.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include <vconf.h>
+#include <vconf-keys.h>
+
+#include "wifi-direct.h"
+#include "wifi-direct-client-handler.h"
+#include "wifi-direct-internal.h"
+#include "wifi-direct-service.h"
+#include "wifi-direct-stub.h"
+#include "wifi-direct-oem.h"
+
+#if 0
+
+#define IF_BUF_LEN 30
+#define NET_BUF_LEN 10
+
+
+#define DRIVER_DELAY 250000 /* micro seconds */
+
+#define SOFTAP_SSID_LEN 32
+#define SOFTAP_PASSWD_LEN 64
+#define SOFTAP_IP_ADDR_LEN 20
+#define SOFTAP_STR_BSSID_LEN 18
+#define INTERFACE_NAME_LEN 10
+
+/* Network Interface */
+#define WIFID_IF "wl0.1"
+
+#define IP_ADDRESS_SOFTAP "192.168.61.1"
+
+#define RET_FAILURE (-1)
+#define RET_SUCCESS (0)
+#define MAX_BUF_SIZE (256u)
+#define WFD_BSSID_LEN 32
+#define MOBILE_AP_WIFI_MAX_DEVICE 8
+#define DNSMASQ_CONF_LEN 1024
+
+#define DNSMASQ_CONF "dhcp-range=set:red,192.168.61.21,192.168.61.150\n" \
+ "dhcp-range=set:green,192.168.130.2,192.168.130.150\n" \
+ "dhcp-range=set:blue,192.168.129.4,192.168.129.150\n"\
+ "dhcp-option=option:dns-server,%s\n" \
+ "dhcp-option=tag:red,option:router,192.168.61.1\n" \
+ "dhcp-option=tag:green,option:router,192.168.130.1\n" \
+ "dhcp-option=tag:blue,option:router,192.168.129.3\n"
+
+
+#define DNSMASQ_CONF_FILE "/tmp/dnsmasq.conf"
+#define RESOLV_CONF_FILE "/etc/resolv.conf"
+
+#define DNSMASQ_LEASES_FILE "/var/lib/misc/dnsmasq.leasess"
+
+
+typedef struct
+{
+ unsigned int number; /* Number of connected device */
+ /* BSSID list of connected device */
+ char bssid[MOBILE_AP_WIFI_MAX_DEVICE][WFD_BSSID_LEN];
+} softap_device_info_t;
+
+
+static int __issue_ioctl(int sock_fd, char *if_name, char *cmd, char *buf)
+{
+ int ret_val = RET_SUCCESS;
+ 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;
+
+ /* Print the command buffer. */
+ //MH_AGENT_LOG (MH_LOW, "iwr.u.data.length = %d\n", iwr.u.data.length);
+ //__print_buf (iwr.u.data.pointer, iwr.u.data.length, 16);
+
+ usleep(DRIVER_DELAY);
+ /* Issue ioctl */
+ if ((ioctl(sock_fd, SIOCSIWPRIV, &iwr)) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "ioctl failed...!!!\n");
+ ret_val = RET_FAILURE;
+ }
+
+ /* Print the return buffer. */
+ //MH_AGENT_LOG (MH_LOW, "iwr.u.data.length = %d\n", iwr.u.data.length);
+ //__print_buf (iwr.u.data.pointer, iwr.u.data.length, 16);
+
+ return ret_val;
+}
+
+
+int _wfd_core_set_ip_address(const char *if_name, const char *ip_address)
+{
+ struct ifreq ifr;
+ struct sockaddr_in addr;
+ int sock_fd;
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "if_name : %s ip address :%s\n", if_name, ip_address);
+
+ if ((sock_fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "socket open failed!!!\n");
+ return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
+ }
+
+ 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 = inet_addr(ip_address);
+
+ memcpy(&ifr.ifr_addr, &addr, sizeof(struct sockaddr));
+ if (ioctl(sock_fd, SIOCSIFADDR, &ifr) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "ioctl failed...!!!\n");
+ close(sock_fd);
+ return WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ if (ioctl(sock_fd, SIOCGIFFLAGS, &ifr) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "ioctl failed...!!!\n");
+ close(sock_fd);
+ return WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ ifr.ifr_flags |= IFF_UP | IFF_RUNNING;
+ if (ioctl(sock_fd, SIOCSIFFLAGS, &ifr) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "ioctl failed...!!!\n");
+ close(sock_fd);
+ return WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ close(sock_fd);
+
+ return WIFI_DIRECT_ERROR_NONE;
+}
+
+
+int _mh_core_get_device_info(softap_device_info_t * di)
+{
+ int sock_fd;
+ char *if_name = WIFID_IF;
+ char cmd[MAX_BUF_SIZE];
+ char buf[MAX_BUF_SIZE] = { 0 };
+ int ret_status = WIFI_DIRECT_ERROR_NONE;
+
+ char *buf_ptr = NULL;
+ unsigned int sta_count = 0;
+ int i;
+
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "+\n");
+
+ if ((sock_fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Failed to open socket...!!!\n");
+ di->number = 0;
+ return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
+ }
+
+ snprintf(cmd, MAX_BUF_SIZE, "AP_GET_STA_LIST");
+ ret_status = __issue_ioctl(sock_fd, if_name, cmd, buf);
+ if (ret_status < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "__issue_ioctl failed...!!!\n");
+ di->number = 0;
+ return WIFI_DIRECT_ERROR_OPERATION_FAILED;
+ }
+
+ buf_ptr = buf;
+
+ sscanf(buf_ptr, "%02x", &sta_count);
+ buf_ptr += 2;
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "connected station : %d\n", sta_count);
+
+ di->number = sta_count;
+
+ for (i = 0; i < di->number; i++)
+ {
+ unsigned int l_bssid[WFD_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], WFD_BSSID_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]);
+
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "STA[%d] address[%s]\n", i,
+ di->bssid[i]);
+
+ buf_ptr += 12;
+ }
+
+ close(sock_fd);
+
+ return ret_status;
+}
+
+int _mh_core_execute_dhcp_server()
+{
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ char buf[DNSMASQ_CONF_LEN] = "";
+ char dns_server[SOFTAP_IP_ADDR_LEN] = { 0, };
+ FILE *fp = NULL;
+ pid_t pid;
+
+ snprintf(buf, DNSMASQ_CONF_LEN, DNSMASQ_CONF, dns_server);
+
+ fp = fopen(DNSMASQ_CONF_FILE, "w");
+ if (NULL == fp)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Could not create the file.\n");
+ return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
+ }
+
+ fputs(buf, fp);
+ fclose(fp);
+
+ if ((pid = fork()) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "fork failed\n");
+ return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
+ }
+
+ if (!pid)
+ {
+ if (execl("/usr/bin/dnsmasq", "/usr/bin/dnsmasq", "-d", "-p",
+ "0", "-C", DNSMASQ_CONF_FILE, (char *) NULL))
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "execl failed\n");
+ }
+
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Should not get here!");
+ return WIFI_DIRECT_ERROR_RESOURCE_BUSY;
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "child pid : %d\n", pid);
+ wfd_server->dhcp_pid = pid;
+ }
+
+ return WIFI_DIRECT_ERROR_NONE;
+}
+
+int _mh_core_terminate_dhcp_server()
+{
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ kill(wfd_server->dhcp_pid, SIGTERM);
+ waitpid(wfd_server->dhcp_pid, NULL, 0);
+
+ return WIFI_DIRECT_ERROR_NONE;
+}
+#endif
+
+#define VCONFKEY_DHCP_IP_LEASE "memory/private/wifi_direct_manager/dhcp_ip_lease"
+#define DHCP_DUMP_FILE "/tmp/dhcp-client-table"
+#define MAX_DHCP_DUMP_SIZE 64 // Single lease format: [99:66:dd:00:11:aa 192.168.16.20 00:00:60]
+
+void __wfd_DHCP_lease_add_cb(keynode_t *key, void* data)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ wifi_direct_client_noti_s noti;
+ FILE *fp = NULL;
+ char buf[MAX_DHCP_DUMP_SIZE];
+ char ip_str[20];
+ char mac_str[20];
+ unsigned char mac_hex[6];
+ int n = 0;
+ int i = 0;
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "DHCP: IP is leased..\n");
+ memset(¬i, 0, sizeof(wifi_direct_client_noti_s));
+
+ if (wfd_oem_is_groupowner() == FALSE)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "DHCP: Ignore event. and Kill DHPC server\n");
+ system("wifi-direct-dhcp.sh stop");
+ return;
+ }
+
+ fp = fopen(DHCP_DUMP_FILE, "r");
+ if (NULL == fp)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Could not read the file [%s].\n",DHCP_DUMP_FILE);
+ return;
+ }
+
+ while(fgets(buf, MAX_DHCP_DUMP_SIZE, fp) != NULL)
+ {
+ n = sscanf(buf,"%s %s", mac_str, ip_str);
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "ip=[%s], mac=[%s].\n",ip_str, mac_str);
+ if (n != 2)
+ {
+ continue;
+ }
+ wfd_macaddr_atoe(mac_str, mac_hex);
+ __wfd_server_print_connected_peer();
+ for(i=0; i<WFD_MAC_ASSOC_STA; i++)
+ {
+
+ if (wfd_server->connected_peers[i].isUsed == 1 &&
+ memcmp(mac_hex, wfd_server->connected_peers[i].int_address, 6) == 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Found peer: interface mac=[%s].\n",mac_str);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "device mac=["MACSTR"]\n",MAC2STR(wfd_server->connected_peers[i].peer.mac_address));
+
+ inet_aton(ip_str, (struct in_addr*)&wfd_server->connected_peers[i].ip_address);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Fill IP: ip=[%s].\n",ip_str);
+
+ //Send event to client with [dev_mac, ip]
+ noti.event = WIFI_DIRECT_CLI_EVENT_IP_LEASED_IND;
+ snprintf(noti.param1, 18, MACSTR, MAC2STR(wfd_server->connected_peers[i].peer.mac_address));
+ strncpy(noti.param2, ip_str, strlen(ip_str));
+ __wfd_server_send_client_event(¬i);
+ break;
+ }
+ }
+ if (i==WFD_MAC_ASSOC_STA)
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Can't find peer from table\n");
+
+ __wfd_server_print_connected_peer();
+ }
+ fclose(fp);
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+
+#define VCONFKEY_DHCPC_SERVER_IP "memory/private/wifi_direct_manager/dhcpc_server_ip"
+int wfd_get_dhcpc_server_ip(char* str, int len)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ char* get_str = NULL;
+ if (str==NULL || len <=0)
+ return -1;
+
+ get_str = vconf_get_str(VCONFKEY_DHCPC_SERVER_IP);
+
+ if (get_str == NULL)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error reading vconf (%s)\n", VCONFKEY_DHCPC_SERVER_IP);
+ return -1;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "VCONFKEY_WIFI_STATE(%s) : %d\n", VCONFKEY_DHCPC_SERVER_IP, get_str);
+ strncpy(str, get_str, len);
+ return 0;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return 0;
+
+}
+
+
+int wfd_set_DHCP_event_handler()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+
+ vconf_set_int(VCONFKEY_DHCP_IP_LEASE, 0);
+ vconf_notify_key_changed(VCONFKEY_DHCP_IP_LEASE, __wfd_DHCP_lease_add_cb, NULL);
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return 0;
+}
+
+
--- /dev/null
+/*\r
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved \r
+ *\r
+ * This file is part of <Wi-Fi Direct>\r
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>\r
+ *\r
+ * PROPRIETARY/CONFIDENTIAL\r
+ *\r
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").\r
+ * You shall not disclose such Confidential Information and shall use it only in accordance\r
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.\r
+ * SAMSUNG make no representations or warranties about the suitability of the software,\r
+ * either express or implied, including but not limited to the implied warranties of merchantability,\r
+ * fitness for a particular purpose, or non-infringement.\r
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,\r
+ * modifying or distributing this software or its derivatives.\r
+ *\r
+ */\r
+\r
+#include <errno.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <stdbool.h>\r
+#include <sys/types.h>\r
+#include <unistd.h>\r
+\r
+#include "wifi-direct-service.h"\r
+#include "wifi-direct-event-handler.h"\r
+#include "wifi-direct-oem.h"\r
+#include "wifi-direct-internal.h"\r
+#include "wifi-direct-utils.h"\r
+\r
+char wfd_event_str[WFD_EVENT_MAX];\r
+\r
+char *__wfd_print_client_event(wfd_client_event_e event)\r
+{\r
+ switch (event)\r
+ {\r
+ case WIFI_DIRECT_CLI_EVENT_ACTIVATION:\r
+ return "ACTIVATION";\r
+ case WIFI_DIRECT_CLI_EVENT_DEACTIVATION:\r
+ return "DEACTIVATION";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCOVER_START:\r
+ return "DISCOVER_START_80211_SCAN";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY:\r
+ return "DISCOVER_START_LISTEN_ONLY";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCOVER_START_SEARCH_LISTEN:\r
+ return "DISCOVER_START_SEARCH_LISTEN";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCOVER_END:\r
+ return "DISCOVER_END";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS:\r
+ return "DISCOVER_FOUND_PEERS";\r
+ case WIFI_DIRECT_CLI_EVENT_CONNECTION_START:\r
+ return "CONNECTION_START";\r
+ case WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ:\r
+ return "CONNECTION_REQ";\r
+ case WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP:\r
+ return "CONNECTION_RSP";\r
+ case WIFI_DIRECT_CLI_EVENT_CONNECTION_WPS_REQ:\r
+ return "CONNECTION_WPS_REQ";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP:\r
+ return "DISCONNECTION_RSP";\r
+ case WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND:\r
+ return "DISCONNECTION_IND";\r
+ case WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP:\r
+ return "GROUP_CREATE_RSP";\r
+ case WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP:\r
+ return "GROUP_DESTROY_RSP";\r
+\r
+ default:\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Error!!! Invalid Event (%d) \n", event);\r
+ return "INVALID EVENT";\r
+ }\r
+}\r
+\r
+\r
+char *__wfd_server_print_event(wfd_event_t event)\r
+{\r
+ switch (event)\r
+ {\r
+ case WFD_EVENT_DISCOVER_START_80211_SCAN:\r
+ return "DISCOVER_START_80211_SCAN";\r
+ case WFD_EVENT_DISCOVER_START_SEARCH_LISTEN:\r
+ return "DISCOVER_START_SEARCH_LISTEN";\r
+ case WFD_EVENT_DISCOVER_FOUND_PEERS:\r
+ return "DISCOVER_FOUND_PEERS";\r
+ case WFD_EVENT_DISCOVER_FOUND_P2P_GROUPS:\r
+ return "DISCOVER_FOUND_P2P_GROUPS";\r
+ case WFD_EVENT_DISCOVER_CANCEL:\r
+ return "DISCOVER_CANCEL";\r
+ case WFD_EVENT_DISCOVER_COMPLETE:\r
+ return "DISCOVER_COMPLETE";\r
+ case WFD_EVENT_DISCOVER_FAIL:\r
+ return "DISCOVER_FAIL";\r
+ case WFD_EVENT_DISCOVER_RESUMED:\r
+ return "DISCOVER_RESUMED";\r
+ case WFD_EVENT_DISCOVER_SUSPENDED:\r
+ return "DISCOVER_SUSPENDED";\r
+ case WFD_EVENT_DISCOVER_START_LISTEN_ONLY:\r
+ return "DISCOVER_START_LISTEN_ONLY";\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST:\r
+ return "PROV_DISCOVERY_REQUEST";\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY:\r
+ return "WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY";\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD:\r
+ return "WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD";\r
+ case WFD_EVENT_PROV_DISCOVERY_RESPONSE:\r
+ return "PROV_DISCOVERY_RESPONSE";\r
+ case WFD_EVENT_PROV_DISCOVERY_TIMEOUT:\r
+ return "PROV_DISCOVERY_TIMEOUT";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_START:\r
+ return "GROUP_OWNER_NEGOTIATION_START";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_AP_ACK:\r
+ return "GROUP_OWNER_NEGOTIATION_AP_ACK";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_STA_ACK:\r
+ return "GROUP_OWNER_NEGOTIATION_STA_ACK";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_REQUEST_RECEIVED:\r
+ return "GROUP_OWNER_NEGOTIATION_REQUEST_RECEIVED";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_COMPLETE:\r
+ return "GROUP_OWNER_NEGOTIATION_COMPLETE";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_FAIL:\r
+ return "GROUP_OWNER_NEGOTIATION_FAIL";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_NO_PROV_INFO:\r
+ return "GROUP_OWNER_NEGOTIATION_NO_PROV_INFO";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_INFO_UNAVAIL:\r
+ return "GROUP_OWNER_NEGOTIATION_INFO_UNAVAIL";\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_FAIL_INTENT:\r
+ return "GROUP_OWNER_NEGOTIATION_FAIL_INTENT";\r
+ case WFD_EVENT_CREATE_LINK_START:\r
+ return "CREATE_LINK_START";\r
+ case WFD_EVENT_CREATE_LINK_CANCEL:\r
+ return "CREATE_LINK_CANCEL";\r
+ case WFD_EVENT_CREATE_LINK_TIMEOUT:\r
+ return "CREATE_LINK_TIMEOUT";\r
+ case WFD_EVENT_CREATE_LINK_AUTH_FAIL:\r
+ return "CREATE_LINK_AUTH_FAIL";\r
+ case WFD_EVENT_CREATE_LINK_FAIL:\r
+ return "CREATE_LINK_FAIL";\r
+ case WFD_EVENT_CREATE_LINK_COMPLETE:\r
+ return "CREATE_LINK_COMPLETE";\r
+ case WFD_EVENT_CONNECT_PBC_START:\r
+ return "CONNECT_PBC_START";\r
+ case WFD_EVENT_PRIMARY_IF_DISCONNECTION:\r
+ return "PRIMARY_IF_DISCONNECTION";\r
+ case WFD_EVENT_SVC_REQ_RECEIVED:\r
+ return "SVC_REQ_RECEIVED";\r
+ case WFD_EVENT_SVC_RESP_RECEIVED:\r
+ return "SVC_RESP_RECEIVED";\r
+ case WFD_EVENT_SVC_COMEBACK_REQ_RECEIVED:\r
+ return "SVC_COMEBACK_REQ_RECEIVED";\r
+ case WFD_EVENT_SVC_COMEBACK_RESP_RECEIVED:\r
+ return "SVC_COMEBACK_RESP_RECEIVED";\r
+ case WFD_EVENT_DEV_DISCOVERABILITY_REQ:\r
+ return "DEV_DISCOVERABILITY_REQ";\r
+ case WFD_EVENT_DEV_DISCOVERABILITY_RSP:\r
+ return "DEV_DISCOVERABILITY_RSP";\r
+ case WFD_EVENT_GO_DISCOVERABILITY_REQ:\r
+ return "GO_DISCOVERABILITY_REQ";\r
+ case WFD_EVENT_SOFTAP_READY:\r
+ return "SOFTAP_READY";\r
+ case WFD_EVENT_SOFTAP_STOP:\r
+ return "SOFTAP_STOP";\r
+ case WFD_EVENT_IP_ASSIGNED:\r
+ return "IP_ASSIGNED";\r
+ case WFD_EVENT_IP_LEASED:\r
+ return "IP_LEASED";\r
+ case WFD_EVENT_INVITE_REQUEST:\r
+ return "INVITE_REQUEST";\r
+ case WFD_EVENT_INVITE_RESPONSE:\r
+ return "INVITE_RESPONSE";\r
+ default:\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Error!!! Invalid Event (%d) \n", event);\r
+ return "INVALID EVENT";\r
+ }\r
+\r
+}\r
+\r
+void __wfd_server_print_connected_peer()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed == 0)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Connected Peer[%d] isUsed=[%d]\n", i,\r
+ wfd_server->connected_peers[i].isUsed);\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Connected Peer[%d] isUsed=[%d] dev mac=" MACSTR " intf mac=" MACSTR " ip="IPSTR" ssid=%s\n" ,\r
+ i,\r
+ wfd_server->connected_peers[i].isUsed,\r
+ MAC2STR(wfd_server->connected_peers[i].peer.mac_address),\r
+ MAC2STR(wfd_server->connected_peers[i].int_address),\r
+ IP2STR(wfd_server->connected_peers[i].ip_address),\r
+ wfd_server->connected_peers[i].peer.ssid\r
+ );\r
+ }\r
+ }\r
+}\r
+\r
+\r
+bool __wfd_get_ip_address(void *user_data)\r
+{\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ char ip_addr[64];\r
+ if (wfd_oem_dhcpc_get_ip_address(ip_addr, 64, 0) == true)\r
+ {\r
+ wfd_event_t event;\r
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "** Get IP address!!ip = %s\n", ip_addr);\r
+ wfd_server->dhcp_ip_address_timer = 0;\r
+\r
+ event = WFD_EVENT_IP_ASSIGNED;\r
+ wfd_server_process_event(event);\r
+ return false;\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "** Failed to get IP address!!Wait more...\n");\r
+ return true;\r
+ }\r
+}\r
+\r
+void wfd_server_start_dhcp_wait_timer()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+\r
+#if 0\r
+ //system("killall udhcpc;/usr/bin/udhcpc -i wl0.1 -s /usr/etc/wifi-direct/udhcp_script.non-autoip &");\r
+\r
+ char cmdStr[256] = {0,};\r
+ char *interface_name = NULL;\r
+\r
+ interface_name = wfd_oem_get_default_interface_name();\r
+ if (NULL == interface_name)\r
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "ERROR : \default interface name is NULL !!!\n");\r
+ else\r
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Interface name is [%s]\n", interface_name);\r
+\r
+ sprintf(cmdStr, "killall udhcpc;/usr/bin/udhcpc -i %s -s /usr/etc/wifi-direct/udhcp_script.non-autoip &", interface_name);\r
+ system(cmdStr);\r
+\r
+#else\r
+\r
+ system("/usr/bin/wifi-direct-dhcp.sh client");\r
+\r
+#endif\r
+\r
+ wfd_server->dhcp_ip_address_timer = g_timeout_add(1000, __wfd_get_ip_address, NULL);\r
+}\r
+\r
+void wfd_server_cancel_dhcp_wait_timer()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ if (wfd_server->dhcp_ip_address_timer > 0)\r
+ {\r
+ g_source_remove(wfd_server->dhcp_ip_address_timer);\r
+ wfd_server->dhcp_ip_address_timer = 0;\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "** dhcp_wait_timer is already stopped...\n");\r
+ }\r
+}\r
+\r
+void __wfd_server_send_client_event(wifi_direct_client_noti_s * noti)\r
+{\r
+ int i = 0;\r
+ int ret = 0;\r
+ int len = sizeof(wifi_direct_client_noti_s);\r
+\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "__wfd_server_send_client_event(%d, %s)\n",\r
+ noti->event, __wfd_print_client_event(noti->event));\r
+\r
+ for (i = 0; i < WFD_MAX_CLIENTS; i++)\r
+ {\r
+ errno = 0;\r
+ if ((wfd_server->client[i].isUsed == true)\r
+ && (wfd_server->client[i].client_id > WFD_INVALID_ID)\r
+ && (wfd_server->client[i].async_sockfd > 0))\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Sending event to client[%d]: cid=[%d] sock=[%d] a-sock=[%d], dev_handle=[%d], sourceid=[%d]\n",\r
+ i,\r
+ wfd_server->client[i].client_id,\r
+ wfd_server->client[i].sync_sockfd,\r
+ wfd_server->client[i].async_sockfd,\r
+ wfd_server->client[i].dev_handle,\r
+ wfd_server->client[i].g_source_id);\r
+\r
+ if (wfd_server_is_fd_writable(wfd_server->client[i].async_sockfd) <= 0)\r
+ {\r
+ continue;\r
+ }\r
+\r
+ ret = write(wfd_server->client[i].async_sockfd, (char *) noti, len);\r
+ if (ret <= 0)\r
+ {\r
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! writing to the socket. Error [%s] \n", strerror(errno));\r
+ }\r
+ else\r
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Event(%s) is Sent to client(id:%d) successfully!!!\n",\r
+ __wfd_print_client_event(noti->event), wfd_server->client[i].client_id);\r
+ }\r
+ }\r
+}\r
+\r
+\r
+bool wfd_server_remember_connecting_peer(unsigned char device_mac[6])\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ wfd_discovery_entry_s *peer;\r
+ int status;\r
+\r
+ status = wfd_oem_get_peer_info(device_mac, &peer);\r
+ if (status == true)\r
+ {\r
+ if (peer != NULL)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "wfd_oem_get_peer_info() Success\n");\r
+\r
+#if 1 // Temporary code. peer's go information is not good. This is a supplicant defect.\r
+ if (wfd_server->current_peer.is_group_owner == true)\r
+ {\r
+ memcpy(&wfd_server->current_peer, peer, sizeof(wfd_discovery_entry_s));\r
+ wfd_server->current_peer.is_group_owner = true;\r
+ }\r
+ else\r
+#endif \r
+ {\r
+ memcpy(&wfd_server->current_peer, peer, sizeof(wfd_discovery_entry_s));\r
+ }\r
+ \r
+ __wfd_server_print_connected_peer();\r
+ free(peer);\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "peer " MACSTR" go=[%d] connected=[%d] ch=[%d] ssid=[%s]\n",\r
+ MAC2STR(wfd_server->current_peer.mac_address),\r
+ wfd_server->current_peer.is_group_owner,\r
+ wfd_server->current_peer.is_connected,\r
+ wfd_server->current_peer.channel,\r
+ wfd_server->current_peer.ssid);\r
+\r
+ \r
+ return true;\r
+ }\r
+ }\r
+\r
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Remember Peer: Error!! can't find peer from the discovery result..\n");\r
+ return false;\r
+}\r
+\r
+bool wfd_server_clear_connected_peer()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+ unsigned char NULL_IP[4] = { 0, 0, 0, 0};\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ wfd_server->connected_peers[i].isUsed = 0;\r
+ memcpy(wfd_server->connected_peers[i].ip_address, NULL_IP, 4);\r
+ }\r
+\r
+ wfd_server->connected_peer_count = 0;\r
+ \r
+ __wfd_server_print_connected_peer();\r
+ return true;\r
+}\r
+\r
+\r
+void wfd_server_reset_connecting_peer()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ unsigned char NULL_MAC[6] = { 0, 0, 0, 0, 0, 0 };\r
+ memcpy(wfd_server->current_peer.mac_address, NULL_MAC, 6);\r
+ __wfd_server_print_connected_peer();\r
+}\r
+\r
+void wfd_server_add_connected_peer(wfd_discovery_entry_s* peer, unsigned char interface_mac[6], char* ip_address)\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed == 0)\r
+ {\r
+ wfd_server->connected_peers[i].isUsed = 1;\r
+ memcpy(&wfd_server->connected_peers[i].peer, peer, sizeof(wfd_discovery_entry_s));\r
+ memcpy(wfd_server->connected_peers[i].int_address, interface_mac, 6);\r
+ wfd_server->connected_peer_count++;\r
+ break;\r
+ }\r
+ }\r
+ __wfd_server_print_connected_peer();\r
+\r
+}\r
+\r
+void wfd_server_remove_connected_peer(wfd_discovery_entry_s * peer)\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+ unsigned char NULL_IP[4] = { 0, 0, 0, 0};\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed==1 &&\r
+ memcmp(wfd_server->connected_peers[i].peer.mac_address, peer->mac_address, 6) == 0 )\r
+ {\r
+ wfd_server->connected_peers[i].isUsed = 0;\r
+ wfd_server->connected_peer_count--;\r
+ memcpy(wfd_server->connected_peers[i].ip_address, NULL_IP, 4);\r
+ break;\r
+ }\r
+ }\r
+ __wfd_server_print_connected_peer();\r
+}\r
+\r
+void wfd_server_remove_connected_peer_by_interface_mac(unsigned char interface_mac[6])\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+ unsigned char NULL_IP[4] = { 0, 0, 0, 0};\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed==1 &&\r
+ memcmp(wfd_server->connected_peers[i].int_address, interface_mac, 6) == 0 )\r
+ {\r
+ wfd_server->connected_peers[i].isUsed = 0;\r
+ wfd_server->connected_peer_count--;\r
+ memcpy(wfd_server->connected_peers[i].ip_address, NULL_IP, 4);\r
+ break;\r
+ }\r
+ }\r
+ __wfd_server_print_connected_peer();\r
+}\r
+\r
+\r
+int wfd_server_is_connected_peer_by_device_mac(unsigned char device_mac[6])\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed==1 &&\r
+ memcmp(wfd_server->connected_peers[i].peer.mac_address, device_mac, 6) == 0 )\r
+ {\r
+ return true;\r
+ }\r
+ }\r
+ return false;\r
+}\r
+\r
+wfd_local_connected_peer_info_t* \r
+wfd_server_get_connected_peer_by_device_mac(unsigned char device_mac[6])\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed==1 &&\r
+ memcmp(wfd_server->connected_peers[i].peer.mac_address, device_mac, 6) == 0 )\r
+ {\r
+ return &wfd_server->connected_peers[i];\r
+ }\r
+ }\r
+ return NULL;\r
+}\r
+\r
+\r
+wfd_local_connected_peer_info_t* \r
+wfd_server_get_connected_peer_by_interface_mac(unsigned char int_mac[6])\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+\r
+ __wfd_server_print_connected_peer();\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed == 1 &&\r
+ memcmp(wfd_server->connected_peers[i].int_address, int_mac, 6) == 0)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Found: peer[%d] ssid=[%s] int_mac=["MACSTR"] dev_mac=["MACSTR"] cat=[%d] ip=["IPSTR"]\n",\r
+ i,\r
+ wfd_server->connected_peers[i].peer.ssid,\r
+ MAC2STR(wfd_server->connected_peers[i].int_address),\r
+ MAC2STR(wfd_server->connected_peers[i].peer.mac_address),\r
+ wfd_server->connected_peers[i].peer.category,\r
+ IP2STR(wfd_server->connected_peers[i].ip_address));\r
+\r
+ return &wfd_server->connected_peers[i];\r
+ }\r
+ }\r
+ return NULL;\r
+}\r
+\r
+\r
+int wfd_server_is_connected_peer_by_interface_mac(unsigned char interface_mac[6])\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ int i;\r
+\r
+ for (i = 0; i < WFD_MAC_ASSOC_STA; i++)\r
+ {\r
+ if (wfd_server->connected_peers[i].isUsed==1 &&\r
+ memcmp(wfd_server->connected_peers[i].int_address, interface_mac, 6) == 0 )\r
+ {\r
+ return true;\r
+ }\r
+ }\r
+ return false;\r
+}\r
+\r
+\r
+void wfd_server_process_event(wfd_event_t event)\r
+{\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ wifi_direct_client_noti_s noti;\r
+\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ memset(¬i, 0, sizeof(wifi_direct_client_noti_s));\r
+\r
+ noti.event = event;\r
+ noti.error = WIFI_DIRECT_ERROR_NONE;\r
+\r
+ wifi_direct_state_e state = wfd_server_get_state();\r
+\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "state=[%s] process event= [%s] \n", wfd_print_state(state), __wfd_server_print_event(noti.event));\r
+\r
+ if (state == WIFI_DIRECT_STATE_CONNECTING)\r
+ {\r
+ switch (event)\r
+ {\r
+#if 1\r
+ //case WFD_EVENT_GROUP_OWNER_NEGOTIATION_NO_PROV_INFO:\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_ALREADY_CONNECTED:\r
+ {\r
+ unsigned char mac[6];\r
+ wifi_direct_wps_type_e wps_config;\r
+ \r
+ wps_config = wfd_server->config_data.wps_config;\r
+ \r
+ wfd_oem_get_requestor_mac(mac);\r
+ if (wfd_oem_connect(mac, wps_config) == true)\r
+ {\r
+ return;\r
+ }\r
+ else\r
+ {\r
+ if (wfd_oem_is_groupowner())\r
+ {\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);\r
+ }\r
+ else\r
+ {\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+ \r
+ snprintf(noti.param1, sizeof(noti.param1),MACSTR, MAC2STR(mac));\r
+ wfd_server_reset_connecting_peer();\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;\r
+ noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;\r
+ __wfd_server_send_client_event(¬i);\r
+ }\r
+ }\r
+ break;\r
+#else\r
+ //case WFD_EVENT_GROUP_OWNER_NEGOTIATION_NO_PROV_INFO:\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_ALREADY_CONNECTED:\r
+ // fall down\r
+#endif\r
+\r
+ // TODO: Do we need to make it, asynchronously?\r
+ // Ignore provision discovery timeout, since provision request used syn API.\r
+ // case WFD_EVENT_PROV_DISCOVERY_TIMEOUT:\r
+\r
+ // Fail cases\r
+ //case WFD_EVENT_GROUP_OWNER_NEGOTIATION_INFO_UNAVAIL:\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_FAIL:\r
+ case WFD_EVENT_GROUP_OWNER_NEGOTIATION_FAIL_INTENT:\r
+ case WFD_EVENT_WPS_WRONG_PIN:\r
+ case WFD_EVENT_WPS_TIMEOUT:\r
+ case WFD_EVENT_WPS_SESSION_OVERLAP:\r
+ case WFD_EVENT_CREATE_LINK_CANCEL:\r
+ if (wfd_oem_is_groupowner())\r
+ {\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);\r
+ }\r
+ else\r
+ {\r
+ wfd_server_cancel_dhcp_wait_timer();\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+ snprintf(noti.param1, sizeof(noti.param1),MACSTR, MAC2STR(wfd_server->current_peer.mac_address));\r
+ wfd_server_reset_connecting_peer();\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;\r
+ noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;\r
+ __wfd_server_send_client_event(¬i);\r
+ //wfd_oem_start_discovery(true, 0);\r
+ break;\r
+\r
+ case WFD_EVENT_SOFTAP_FAIL:\r
+ wfd_server_cancel_dhcp_wait_timer();\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ wfd_server_reset_connecting_peer();\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP;\r
+ noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;\r
+ __wfd_server_send_client_event(¬i);\r
+ break;\r
+\r
+ case WFD_EVENT_CREATE_LINK_TIMEOUT:\r
+ case WFD_EVENT_CREATE_LINK_AUTH_FAIL:\r
+ case WFD_EVENT_CREATE_LINK_FAIL:\r
+ if (wfd_oem_is_groupowner())\r
+ {\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);\r
+ }\r
+ else\r
+ {\r
+ wfd_server_cancel_dhcp_wait_timer();\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+ snprintf(noti.param1, sizeof(noti.param1),MACSTR, MAC2STR(wfd_server->current_peer.mac_address));\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;\r
+ if (event == WFD_EVENT_CREATE_LINK_TIMEOUT)\r
+ noti.error = WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT;\r
+ else if (event == WFD_EVENT_CREATE_LINK_AUTH_FAIL)\r
+ noti.error = WIFI_DIRECT_ERROR_AUTH_FAILED;\r
+ else if (event == WFD_EVENT_CREATE_LINK_FAIL)\r
+ noti.error = WIFI_DIRECT_ERROR_CONNECTION_FAILED;\r
+ wfd_server_reset_connecting_peer();\r
+\r
+ if (wfd_oem_is_groupowner() == false)\r
+ wfd_server_clear_connected_peer();\r
+\r
+ __wfd_server_send_client_event(¬i);\r
+ //wfd_oem_start_discovery(true, 0);\r
+ break;\r
+\r
+ case WFD_EVENT_DISCOVER_COMPLETE:\r
+ wfd_server->config_data.listen_only = false;\r
+\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_END;\r
+ __wfd_server_send_client_event(¬i);\r
+\r
+ // TODO: M-Project "find/scan" concept. First time, we start discovery during 30 seconds and then try again discovery with Listen only mode continuosly.\r
+ //wfd_oem_start_discovery(true, 0);\r
+ break;\r
+\r
+ case WFD_EVENT_CREATE_LINK_COMPLETE:\r
+ {\r
+ if (wfd_oem_is_groupowner())\r
+ {\r
+ unsigned char intf_mac[6] = {0, };\r
+\r
+ wfd_oem_get_assoc_sta_mac(intf_mac);\r
+ \r
+ wfd_server_add_connected_peer(&wfd_server->current_peer,\r
+ intf_mac, NULL);\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);\r
+\r
+ wfd_local_connected_peer_info_t *peer = NULL;\r
+ peer =\r
+ wfd_server_get_connected_peer_by_interface_mac(intf_mac);\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Peer's Intf MAC is " MACSTR "\n",\r
+ MAC2STR(intf_mac));\r
+\r
+ if (peer == NULL)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Something wrong... Peer's Dev MAC is " MACSTR "\n",\r
+ MAC2STR(peer->peer.mac_address));\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(wfd_server->current_peer.mac_address));\r
+ }\r
+ else\r
+ {\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(peer->peer.mac_address));\r
+ }\r
+\r
+ wfd_server_reset_connecting_peer();\r
+\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;\r
+\r
+\r
+ __wfd_server_send_client_event(¬i);\r
+ }\r
+ else\r
+ {\r
+ wfd_connected_peer_info_s *peer_list = NULL;\r
+\r
+ int peer_num = 0;\r
+\r
+ wfd_server_clear_connected_peer();\r
+\r
+ wfd_oem_get_connected_peers_info(&peer_list, &peer_num);\r
+\r
+ if (peer_num == 1)\r
+ {\r
+ wfd_server_add_connected_peer(&wfd_server->current_peer,\r
+ peer_list[0].intf_mac_address,\r
+ NULL);\r
+ }\r
+ else\r
+ {\r
+ unsigned char intf_mac[6] = {0, };\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Something wrong. peer_num is [%d]\n",\r
+ peer_num);\r
+ wfd_server_add_connected_peer(&wfd_server->current_peer,\r
+ intf_mac,\r
+ NULL);\r
+ }\r
+\r
+ wfd_server_start_dhcp_wait_timer();\r
+ }\r
+ }\r
+ break;\r
+\r
+ case WFD_EVENT_IP_ASSIGNED:\r
+ {\r
+ // Update peer IP address which is DHCP server IP.\r
+ char peer_ip_str[20];\r
+ wfd_get_dhcpc_server_ip(peer_ip_str, 20);\r
+ inet_aton(peer_ip_str, (struct in_addr*)&wfd_server->connected_peers[0].ip_address);\r
+\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR, MAC2STR(wfd_server->current_peer.mac_address));\r
+ wfd_server_reset_connecting_peer();\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_CONNECTED);\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;\r
+ __wfd_server_send_client_event(¬i);\r
+\r
+ }\r
+ break;\r
+\r
+ case WFD_EVENT_CONNECT_PBC_START:\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_WPS_REQ;\r
+\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "g_incomming_peer_mac_address is " MACSTR "\n",\r
+ MAC2STR(g_incomming_peer_mac_address));\r
+ //WFD_SERVER_LOG(WFD_LOG_HIGH, "g_incomming_peer_ssid is [%s]\n", g_incomming_peer_ssid);\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(g_incomming_peer_mac_address));\r
+ //strncpy(noti.param2, g_incomming_peer_ssid, strlen(g_incomming_peer_ssid));\r
+\r
+ __wfd_server_send_client_event(¬i);\r
+ break;\r
+\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST:\r
+ if (wfd_oem_is_groupowner())\r
+ {\r
+ // provision request comes, when we sent 'invite'...\r
+ wfd_oem_wps_pbc_start();\r
+ }\r
+ else\r
+ {\r
+ //Ignore provision request during connecting...\r
+ }\r
+ break;\r
+\r
+ default:\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Unprocessed event: state=[%s] event= [%s] \n",\r
+ wfd_print_state(state),\r
+ __wfd_server_print_event(noti.event));\r
+ break;\r
+ }\r
+ }\r
+ else if (state == WIFI_DIRECT_STATE_DISCONNECTING)\r
+ {\r
+ switch (event)\r
+ {\r
+ case WFD_EVENT_CREATE_LINK_CANCEL:\r
+\r
+ if (wfd_oem_is_groupowner())\r
+ {\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);\r
+ }\r
+ else\r
+ {\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "Peer's Dev MAC is " MACSTR "\n",\r
+ MAC2STR(wfd_server->current_peer.mac_address));\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(wfd_server->current_peer.mac_address));\r
+\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_RSP;\r
+ wfd_server_reset_connecting_peer();\r
+ wfd_server_clear_connected_peer();\r
+ __wfd_server_send_client_event(¬i);\r
+ //wfd_oem_start_discovery(true, 0);\r
+ break;\r
+ default:\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Unprocessed event: state=[%s] event= [%s] \n",\r
+ wfd_print_state(state),\r
+ __wfd_server_print_event(noti.event));\r
+ break;\r
+ }\r
+ }\r
+ else if (state == WIFI_DIRECT_STATE_CONNECTED ||\r
+ state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING ||\r
+ state == WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ {\r
+ switch (event)\r
+ {\r
+ case WFD_EVENT_INVITE_REQUEST:\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST:\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY:\r
+ case WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD:\r
+ {\r
+ if (event == WFD_EVENT_PROV_DISCOVERY_REQUEST)\r
+ wfd_server->config_data.wps_config =\r
+ WIFI_DIRECT_WPS_TYPE_PBC;\r
+ else if (event == WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_DISPLAY)\r
+ wfd_server->config_data.wps_config =\r
+ WIFI_DIRECT_WPS_TYPE_PIN_DISPLAY;\r
+ else if (event == WFD_EVENT_PROV_DISCOVERY_REQUEST_WPS_KEYPAD)\r
+ wfd_server->config_data.wps_config = WIFI_DIRECT_WPS_TYPE_PIN_KEYPAD;\r
+\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_REQ;\r
+\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "g_incomming_peer_mac_address is " MACSTR "\n",\r
+ MAC2STR(g_incomming_peer_mac_address));\r
+ //WFD_SERVER_LOG(WFD_LOG_HIGH, "g_incomming_peer_ssid is [%s]\n", g_incomming_peer_ssid);\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(g_incomming_peer_mac_address));\r
+\r
+ //strncpy(noti.param2, g_incomming_peer_ssid, strlen(g_incomming_peer_ssid));\r
+\r
+ __wfd_server_send_client_event(¬i);\r
+ }\r
+ break;\r
+\r
+ case WFD_EVENT_SOFTAP_STA_DISASSOC:\r
+ {\r
+ if (wfd_oem_is_groupowner() == true)\r
+ {\r
+ int count = 0;\r
+ unsigned char interface_mac[6];\r
+ wfd_oem_get_disassoc_sta_mac(interface_mac);\r
+\r
+ wfd_local_connected_peer_info_t *peer = NULL;\r
+ peer =\r
+ wfd_server_get_connected_peer_by_interface_mac(interface_mac);\r
+ if (peer != NULL)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Peer's Intf MAC: " MACSTR ", Device MAC:" MACSTR " \n",\r
+ MAC2STR(interface_mac),\r
+ MAC2STR(peer->peer.mac_address));\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(peer->peer.mac_address));\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Peer's Intf MAC: " MACSTR ", Device MAC:null \n",\r
+ MAC2STR(interface_mac));\r
+ memset(noti.param1, 0, 6);\r
+ }\r
+\r
+ wfd_server_remove_connected_peer_by_interface_mac(interface_mac);\r
+ wfd_server_reset_connecting_peer();\r
+\r
+ wfd_oem_get_connected_peers_count(&count);\r
+ if (count == 0)\r
+ {\r
+ wfd_server->config_data.wps_config =\r
+ WIFI_DIRECT_WPS_TYPE_PBC;\r
+ if (wfd_oem_disconnect() == false)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_EXCEPTION,\r
+ "Error!!! wfd_oem_disconnect() failed!!..\n");\r
+ }\r
+ }\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISASSOCIATION_IND;\r
+ __wfd_server_send_client_event(¬i);\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_EXCEPTION,\r
+ "Error!!! DISASSOC event come..\n");\r
+ }\r
+ }\r
+ break;\r
+\r
+ case WFD_EVENT_PRIMARY_IF_DISCONNECTION:\r
+ WFD_SERVER_LOG(WFD_LOG_LOW,\r
+ "Primary interface (wlan0) is down. Just let it up!\n");\r
+ system("ifconfig wlan0 up");\r
+ break;\r
+\r
+ case WFD_EVENT_CREATE_LINK_CANCEL:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Peer's Dev MAC is " MACSTR "\n",\r
+ MAC2STR(wfd_server->current_peer.\r
+ mac_address));\r
+ //WFD_SERVER_LOG(WFD_LOG_HIGH, "Peer's SSID is [%s]\n", wfd_server->current_peer.ssid);\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(wfd_server->current_peer.mac_address));\r
+ //strncpy(noti.param2, wfd_server->current_peer.ssid, strlen(wfd_server->current_peer.ssid));\r
+\r
+ wfd_server_clear_connected_peer();\r
+ wfd_server->config_data.wps_config =\r
+ WIFI_DIRECT_WPS_TYPE_PBC;\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND;\r
+ __wfd_server_send_client_event(¬i);\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW,\r
+ "message is ignored [%d] at state=[%d]\n",\r
+ event, state);\r
+ }\r
+ }\r
+ break;\r
+ case WFD_EVENT_CREATE_LINK_DOWN:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_CONNECTED)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH,\r
+ "Peer's Intf MAC: " MACSTR ", Device MAC:" MACSTR " \n",\r
+ MAC2STR(wfd_server->connected_peers[0].int_address),\r
+ MAC2STR(wfd_server->connected_peers[0].peer.mac_address));\r
+\r
+ snprintf(noti.param1, sizeof(noti.param1), MACSTR,\r
+ MAC2STR(wfd_server->connected_peers[0].peer.mac_address));\r
+\r
+ wfd_server_clear_connected_peer();\r
+ wfd_server->config_data.wps_config =\r
+ WIFI_DIRECT_WPS_TYPE_PBC;\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCONNECTION_IND;\r
+ __wfd_server_send_client_event(¬i);\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+ else\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW,\r
+ "message is ignored [%d] at state=[%d]\n",\r
+ event, state);\r
+ }\r
+ }\r
+ break;\r
+ case WFD_EVENT_DISCOVER_START_80211_SCAN:\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START;\r
+ __wfd_server_send_client_event(¬i);\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING)\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_DISCOVERING);\r
+ break;\r
+#if 0\r
+ case WFD_EVENT_DISCOVER_START_SEARCH_LISTEN:\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START_SEARCH_LISTEN;\r
+ __wfd_server_send_client_event(¬i);\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING)\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ break;\r
+#endif\r
+\r
+ case WFD_EVENT_DISCOVER_START_LISTEN_ONLY:\r
+ wfd_server->config_data.listen_only = true;\r
+ \r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_START_LISTEN_ONLY;\r
+ __wfd_server_send_client_event(¬i);\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING)\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_DISCOVERING);\r
+ break;\r
+\r
+ case WFD_EVENT_DISCOVER_CANCEL:\r
+ case WFD_EVENT_DISCOVER_COMPLETE:\r
+ case WFD_EVENT_DISCOVER_FAIL:\r
+ wfd_server->config_data.listen_only = false;\r
+ \r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_END;\r
+ __wfd_server_send_client_event(¬i);\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING)\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ break;\r
+\r
+ // TODO: M-Project "find/scan" concept. First time, we start discovery during 30 seconds and then try again discovery with Listen only mode continuosly.\r
+#if 0\r
+ case WFD_EVENT_DISCOVER_COMPLETE:\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_END;\r
+ __wfd_server_send_client_event(¬i);\r
+ wfd_oem_start_discovery(true, 0);\r
+ break;\r
+#endif\r
+\r
+ case WFD_EVENT_DISCOVER_FOUND_PEERS:\r
+ case WFD_EVENT_DISCOVER_FOUND_P2P_GROUPS:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_CONNECTED)\r
+ {\r
+ // Note:\r
+ // In case of GC, when connected, interface_mac_address is not updated, since scan is stopped.\r
+ // If scan is started (by user request), then we have changce to get the interface_mac_address.\r
+ //\r
+ unsigned char null_mac[6]={0,};\r
+ if (memcmp(&wfd_server->connected_peers[0].int_address, &null_mac, 6)==0)\r
+ {\r
+ wfd_connected_peer_info_s *peer_list = NULL;\r
+ int peer_num = 0;\r
+\r
+ wfd_oem_get_connected_peers_info(&peer_list, &peer_num);\r
+\r
+ if (peer_num == 1)\r
+ {\r
+ memcpy(&wfd_server->connected_peers[0].int_address,\r
+ &peer_list[0].intf_mac_address,\r
+ 6);\r
+ }\r
+ else\r
+ {\r
+ // Something wrong, and ignore it...\r
+ }\r
+ }\r
+ }\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_FOUND_PEERS;\r
+ __wfd_server_send_client_event(¬i);\r
+ }\r
+ break;\r
+\r
+ case WFD_EVENT_SOFTAP_READY:\r
+ {\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_GROUP_CREATE_RSP;\r
+ __wfd_server_send_client_event(¬i);\r
+ }\r
+ break;\r
+\r
+ case WFD_EVENT_SOFTAP_STOP:\r
+ {\r
+ noti.event = WIFI_DIRECT_CLI_EVENT_GROUP_DESTROY_RSP;\r
+ __wfd_server_send_client_event(¬i);\r
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);\r
+ }\r
+ break;\r
+\r
+ default:\r
+ WFD_SERVER_LOG(WFD_LOG_HIGH, "Unprocessed event: state=[%s] event= [%s] \n", wfd_print_state(state), __wfd_server_print_event(noti.event));\r
+ break;\r
+ }\r
+ }\r
+\r
+ __WFD_SERVER_FUNC_EXIT__;\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+
+/*****************************************************************************
+ * Standard headers
+ *****************************************************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/socket.h>
+#include <string.h>
+#include <stdbool.h>
+#include <sys/un.h>
+#include <unistd.h>
+#include <errno.h>
+#include <linux/unistd.h>
+#include <glib.h>
+#include <glib-object.h>
+#include <sys/stat.h>
+#include <dlfcn.h>
+#include <sys/utsname.h>
+
+/*****************************************************************************
+ * Platform headers
+ *****************************************************************************/
+#include "vconf-keys.h"
+
+/*****************************************************************************
+ * Wi-Fi Direct Server headers
+ *****************************************************************************/
+#include "wifi-direct.h"
+#include "wifi-direct-stub.h"
+#include "wifi-direct-service.h"
+#include "wifi-direct-utils.h"
+#include "wifi-direct-event-handler.h"
+#include "wifi-direct-oem.h"
+
+/*****************************************************************************
+ * Wi-Fi Macros
+ *****************************************************************************/
+
+
+/*****************************************************************************
+ * Wi-Fi Global variables
+ *****************************************************************************/
+wfd_server_control_t g_wfd_server;
+
+
+void wfd_server_process_event(wfd_event_t event);
+
+
+char *wfd_server_print_cmd(wifi_direct_cmd_e cmd)
+{
+ switch (cmd)
+ {
+ case WIFI_DIRECT_CMD_REGISTER:
+ return "WIFI_DIRECT_CMD_REGISTER";
+ case WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET:
+ return "WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET";
+ case WIFI_DIRECT_CMD_DEREGISTER:
+ return "WIFI_DIRECT_CMD_DEREGISTER";
+ case WIFI_DIRECT_CMD_ACTIVATE:
+ return "WIFI_DIRECT_CMD_ACTIVATE";
+ case WIFI_DIRECT_CMD_DEACTIVATE:
+ return "WIFI_DIRECT_CMD_DEACTIVATE";
+ case WIFI_DIRECT_CMD_START_DISCOVERY:
+ return "WIFI_DIRECT_CMD_START_DISCOVERY";
+ case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:
+ return "WIFI_DIRECT_CMD_CANCEL_DISCOVERY";
+ case WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT:
+ return "WIFI_DIRECT_CMD_GET_DISCOVERY_RESULT";
+ case WIFI_DIRECT_CMD_SEND_PROVISION_DISCOVERY_REQ:
+ return "WIFI_DIRECT_CMD_SEND_PROVISION_DISCOVERY_REQ";
+ case WIFI_DIRECT_CMD_GET_LINK_STATUS:
+ return "WIFI_DIRECT_CMD_GET_LINK_STATUS";
+ case WIFI_DIRECT_CMD_CONNECT:
+ return "WIFI_DIRECT_CMD_CONNECT";
+ case WIFI_DIRECT_CMD_DISCONNECT_ALL:
+ return "WIFI_DIRECT_CMD_DISCONNECT_ALL";
+ case WIFI_DIRECT_CMD_CREATE_GROUP:
+ return "WIFI_DIRECT_CMD_CREATE_GROUP";
+ case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:
+ return "WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON";
+ case WIFI_DIRECT_CMD_IS_GROUPOWNER:
+ return "WIFI_DIRECT_CMD_IS_GROUPOWNER";
+ case WIFI_DIRECT_CMD_GET_SSID:
+ return "WIFI_DIRECT_CMD_GET_SSID";
+ case WIFI_DIRECT_CMD_SET_SSID:
+ return "WIFI_DIRECT_CMD_SET_SSID";
+ case WIFI_DIRECT_CMD_GET_IP_ADDR:
+ return "WIFI_DIRECT_CMD_GET_IP_ADDR";
+ case WIFI_DIRECT_CMD_GET_CONFIG:
+ return "WIFI_DIRECT_CMD_GET_CONFIG";
+ case WIFI_DIRECT_CMD_SET_WPS_PIN:
+ return "WIFI_DIRECT_CMD_SET_WPS_PIN";
+ case WIFI_DIRECT_CMD_GET_WPS_PIN:
+ return "WIFI_DIRECT_CMD_GET_WPS_PIN";
+ case WIFI_DIRECT_CMD_GET_INCOMMING_PEER_INFO:
+ return "WIFI_DIRECT_CMD_GET_INCOMMING_PEER_INFO";
+ case WIFI_DIRECT_CMD_SET_WPA:
+ return "WIFI_DIRECT_CMD_SET_WPA";
+ case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:
+ return "WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE";
+ case WIFI_DIRECT_CMD_SET_CURRENT_WPS_MODE:
+ return "WIFI_DIRECT_CMD_SET_CURRENT_WPS_MODE";
+ case WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO:
+ return "WIFI_DIRECT_CMD_GET_CONNECTED_PEERS_INFO";
+ case WIFI_DIRECT_CMD_CANCEL_GROUP:
+ return "WIFI_DIRECT_CMD_CANCEL_GROUP";
+ case WIFI_DIRECT_CMD_DISCONNECT:
+ return "WIFI_DIRECT_CMD_DISCONNECT";
+ case WIFI_DIRECT_CMD_GET_GO_INTENT:
+ return "WIFI_DIRECT_CMD_GET_GO_INTENT";
+ case WIFI_DIRECT_CMD_SET_GO_INTENT:
+ return "WIFI_DIRECT_CMD_SET_GO_INTENT";
+ case WIFI_DIRECT_CMD_IS_DISCOVERABLE:
+ return "WIFI_DIRECT_CMD_IS_DISCOVERABLE";
+ case WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL:
+ return "WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL";
+ default:
+ return "WIFI_DIRECT_CMD_INVALID";
+
+ }
+}
+
+wfd_server_control_t *wfd_server_get_control()
+{
+ return &g_wfd_server;
+}
+
+static gboolean wfd_server_accept_client_socket(GIOChannel* source, GIOCondition condition, gpointer data)
+{
+ int clientfd = -1;
+ socklen_t clientlen = 0;
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ int servfd = wfd_server->async_sockfd;
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ if (servfd < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! Invalid sockfd argument = [%d] \n", servfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+ }
+
+ errno = 0;
+ clientfd = accept(servfd, NULL, &clientlen);
+ if (clientfd == -1)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ASSERT,
+ "Error!!! Accepting the client socket. Error = [%s]. Server socket = [%d] \n",
+ strerror(errno), servfd);
+
+ int ret = 0;
+ char req[10] = "";
+ int reqlen = 10;
+
+ errno = 0;
+ ret = read(servfd, req, reqlen);
+ if (ret == 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Server Socket got closed\n");
+ }
+ else if (ret < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! reading server socket. Error = [%s]\n", strerror(errno));
+ }
+ else
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Read [%d] data\n", ret);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Accepted the client: [%d]\n", clientfd);
+
+ if (!(wfd_server_register_client(clientfd)))
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! adding new client\n");
+ close(clientfd);
+ }
+ __WFD_SERVER_FUNC_EXIT__;
+ return true;
+}
+
+static int wfd_server_create_socket(void)
+{
+ int len = 0;
+ int sockfd = -1;
+ struct sockaddr_un servAddr;
+ mode_t sock_mode; // socket file permission
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ /** It is safe to Unlink the path.*/
+ unlink(WFD_SERVER_SOCKET_PATH);
+ errno = 0;
+ if ((sockfd = socket(PF_LOCAL, SOCK_STREAM, 0)) == -1)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! creating UNIX socket. Error = [%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ memset(&servAddr, 0, sizeof(servAddr));
+ servAddr.sun_family = AF_UNIX;
+ strcpy(servAddr.sun_path, WFD_SERVER_SOCKET_PATH);
+ len = sizeof(servAddr.sun_family) + strlen(WFD_SERVER_SOCKET_PATH);
+
+ errno = 0;
+
+ sock_mode = (S_IRWXU | S_IRWXG | S_IRWXO);
+
+ if (bind(sockfd, (struct sockaddr *) &servAddr, len) == -1)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Error!!! binding to the socket address. Error = [%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Binded to the server socket.\n");
+
+ if (chmod(WFD_SERVER_SOCKET_PATH, sock_mode) < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "[server] chmod() error\n");
+ return -1;
+ }
+
+ errno = 0;
+ if (listen(sockfd, WFD_MAX_CLIENTS) == -1)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! while listening to the socket. Error = [%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ wfd_server->async_sockfd = sockfd;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Successfully created the server socket [%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return 1;
+}
+
+void wfd_load_plugin()
+{
+ void *handle;
+ char *filename;
+ struct utsname kernel_info;
+ int res;
+
+ res = uname(&kernel_info);
+ if(res != 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Failed to detect target type\n");
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Node name of this device [%s]\n", kernel_info.nodename);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "HW ID of this device [%s]\n", kernel_info.machine);
+
+
+ if((strcmp(kernel_info.nodename, "U1SLP") == 0)
+ || (strcmp(kernel_info.nodename, "U1HD") == 0)
+ /*|| (strcmp(kernel_info.nodename, "TRATS") == 0)*/)
+ filename = "/usr/lib/wifi-direct-plugin-broadcom.so";
+ else
+ filename = "/usr/lib/wifi-direct-plugin-wpasupplicant.so";
+ }
+
+ handle = dlopen(filename, RTLD_NOW);
+ if (!handle) {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error for dlopen\n");
+ fputs(dlerror(), stderr);
+ return;
+ }
+
+ int (*plugin_load)(struct wfd_oem_operations **ops) = NULL;
+ plugin_load = (int (*)(struct wfd_oem_operations **ops))dlsym(handle, "wfd_plugin_load");
+
+ if (!plugin_load) {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error for dlsym[%s]\n", strerror(errno));
+ return ;
+ }
+
+ struct wfd_oem_operations *temp_ops;
+ (*plugin_load)(&temp_ops);
+ g_ops = temp_ops;
+
+ return;
+}
+
+
+/*****************************************************************************
+ * Wi-Fi Global Function Definition
+ *****************************************************************************/
+
+static int wfd_server_init(void)
+{
+ int i = -1;
+ unsigned char NULL_MAC[6] = { 0, 0, 0, 0, 0, 0 };
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ memset(&g_wfd_server, 0, sizeof(wfd_server_control_t));
+ g_wfd_server.active_clients = 0;
+ g_wfd_server.async_sockfd = -1;
+ g_wfd_server.sync_sockfd = -1;
+
+ // ToDo: Read them from repository.
+ g_wfd_server.config_data.channel = 11;
+ g_wfd_server.config_data.wps_config = WIFI_DIRECT_WPS_TYPE_PBC;
+ g_wfd_server.config_data.auto_connection = false;
+ g_wfd_server.config_data.want_persistent_group = false;
+ g_wfd_server.config_data.max_clients = WFD_MAC_ASSOC_STA;
+ g_wfd_server.config_data.hide_SSID = false;
+ g_wfd_server.config_data.group_owner_intent = 8;
+ g_wfd_server.config_data.primary_dev_type = WIFI_DIRECT_PRIMARY_DEVICE_TYPE_TELEPHONE; // Telephone
+ g_wfd_server.config_data.secondary_dev_type = WIFI_DIRECT_SECONDARY_DEVICE_TYPE_PHONE_SM_DUAL; // smart phone dual mode (wifi and cellular)
+
+ //g_wfd_server.config_data.primary_dev_type = WFD_DEVICE_TYPE_CAT_TELEPHONE;
+ //g_wfd_server.config_data.secondary_dev_type = WFD_DEVICE_TYPE_SUB_CAT_PHONE_WM;
+
+
+ for (i = 0; i < WFD_MAX_CLIENTS; i++)
+ {
+ memset(&g_wfd_server.client[i], 0, sizeof(wfd_server_client_t));
+ }
+
+ for (i = 0; i < 8; i++)
+ {
+ memset(&g_wfd_server.connected_peers[i], 0, sizeof(wfd_local_connected_peer_info_t));
+ g_wfd_server.connected_peers[i].isUsed = 0;
+
+ }
+ g_wfd_server.connected_peer_count = 0;
+ memcpy(g_wfd_server.current_peer.mac_address, NULL_MAC, 6);
+
+ g_wfd_server.autonomous_group_owner = false;
+
+ wfd_load_plugin();
+
+ wfd_oem_init(wfd_server_process_event);
+
+ wfd_set_device_name_as_ssid();
+
+ wfd_set_DHCP_event_handler();
+
+ if (wfd_set_wifi_direct_state(WIFI_DIRECT_STATE_DEACTIVATED) < 0)
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");
+
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+}
+
+static int wfd_server_destroy()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ if (g_wfd_server.async_sockfd>0)
+ close(g_wfd_server.async_sockfd);
+ unlink(WFD_SERVER_SOCKET_PATH);
+
+ memset(&g_wfd_server, 0, sizeof(wfd_server_control_t));
+
+ wfd_oem_destroy();
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+}
+
+static gboolean wfd_connection_timeout_cb(void *user_data)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ wifi_direct_client_noti_s noti;
+
+ g_source_remove(wfd_server->connection_timer);
+ wfd_server->connection_timer = 0;
+
+
+ if (wfd_oem_is_groupowner())
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ }
+
+#if 0
+ // disconnect the peer to reset state.
+ if (wfd_oem_is_groupowner() == TRUE)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Peer's Intf MAC is " MACSTR "\n", MAC2STR(wfd_server->current_peer.intf_mac_address));
+ if ( NULL == wfd_server->current_peer.intf_mac_address )
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "[wfd_server->current_peer.intf_mac_address] is Null!\n");
+
+ if (wfd_oem_disconnect_sta(wfd_server->current_peer.intf_mac_address) == FALSE)
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... wfd_oem_disconnect_sta() failed\n");
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_DISCONNECTING);
+
+ if (wfd_oem_disconnect() == TRUE)
+ {
+ wfd_server->config_data.wps_config = WIFI_DIRECT_WPS_TYPE_PBC; // set wps_config to default
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error... wfd_oem_disconnect() failed\n");
+ }
+ }
+#endif
+
+ memset(¬i, 0, sizeof(wifi_direct_client_noti_s));
+
+
+ snprintf(noti.param1, sizeof(noti.param1),MACSTR, MAC2STR(wfd_server->current_peer.mac_address));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_CONNECTION_RSP;
+ noti.error = WIFI_DIRECT_ERROR_CONNECTION_TIME_OUT;
+
+ wfd_server_reset_connecting_peer();
+ wfd_server_clear_connected_peer();
+
+ __wfd_server_send_client_event(¬i);
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return FALSE;
+}
+
+void wfd_timer_connection_start()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->connection_timer > 0)
+ g_source_remove(wfd_server->connection_timer);
+
+ wfd_server->connection_timer = 0;
+
+ wfd_server->connection_timer = g_timeout_add(120000 /* 120 seconds*/, (GSourceFunc)wfd_connection_timeout_cb , NULL);
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+void wfd_timer_connection_cancel()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->connection_timer > 0)
+ g_source_remove(wfd_server->connection_timer);
+
+ wfd_server->connection_timer = 0;
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+
+static gboolean wfd_termination_timeout_cb(void *user_data)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->active_clients > 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "There is an active clients(Num=[%d]). Run timer again..\n", wfd_server->active_clients);
+ // Restart timer by returning true.
+ return TRUE;
+ }
+
+ int state = wfd_server_get_state();
+
+ if (state != WIFI_DIRECT_STATE_DEACTIVATED)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "State is not 'deactivated' ( state=[%d] ). Cancel timer.\n", state);
+ // Cancel timer by returning false.
+ return FALSE;
+ }
+
+ if (wfd_server->async_sockfd > 0)
+ close(wfd_server->async_sockfd);
+
+ g_main_quit(wfd_server->mainloop);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "g_main_quit()..\n");
+ __WFD_SERVER_FUNC_EXIT__;
+
+ // Cancel timer by returning false.
+ return FALSE;
+}
+
+
+void wfd_termination_timer_start()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->termination_timer > 0)
+ {
+ g_source_remove(wfd_server->termination_timer);
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Termination timer is restarted..\n");
+ }
+ else
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Termination timer is started..\n");
+ }
+
+ wfd_server->termination_timer = 0;
+
+ wfd_server->termination_timer = g_timeout_add(120000 /* 120 seconds*/, (GSourceFunc)wfd_termination_timeout_cb , NULL);
+
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+
+void wfd_termination_timer_cancel()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->termination_timer > 0)
+ g_source_remove(wfd_server->termination_timer);
+
+ wfd_server->termination_timer = 0;
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Termination timer is canceled..\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+static gboolean wfd_discovery_timeout_cb(void *user_data)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ wifi_direct_client_noti_s noti;
+ int ret;
+
+ g_source_remove(wfd_server->discovery_timer);
+ wfd_server->discovery_timer = 0;
+
+ if (wfd_oem_is_groupowner())
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_GROUP_OWNER);
+ }
+ else
+ {
+ wfd_server_set_state(WIFI_DIRECT_STATE_ACTIVATED);
+ }
+
+ ret = wfd_oem_cancel_discovery();
+ if (ret == false)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!! wfd_oem_cancel_discovery() failed..\n");
+ }
+
+#if 0
+ memset(¬i, 0, sizeof(wifi_direct_client_noti_s));
+
+ noti.event = WIFI_DIRECT_CLI_EVENT_DISCOVER_END;
+ noti.error = WIFI_DIRECT_ERROR_NONE;
+
+ __wfd_server_send_client_event(¬i);
+#endif
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return FALSE;
+}
+
+void wfd_timer_discovery_start(int seconds)
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->discovery_timer> 0)
+ g_source_remove(wfd_server->discovery_timer);
+
+ wfd_server->discovery_timer = 0;
+
+ wfd_server->discovery_timer = g_timeout_add((seconds*1000), (GSourceFunc)wfd_discovery_timeout_cb , NULL);
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+void wfd_timer_discovery_cancel()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ if (wfd_server->discovery_timer > 0)
+ g_source_remove(wfd_server->discovery_timer);
+
+ wfd_server->discovery_timer = 0;
+
+ __WFD_SERVER_FUNC_EXIT__;
+}
+
+int main(gint argc, gchar * argv[])
+{
+ GMainLoop *mainloop = NULL;
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ int i = -1;
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW,"========================================\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW,"= =\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW,"= WiFi Direct Server =\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW,"= =\n");
+ WFD_SERVER_LOG( WFD_LOG_LOW,"========================================\n");
+
+ for (i = 0; i < argc; i++)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "arg[%d]= %s\n", i, argv[i]);
+ }
+
+ if (!g_thread_supported())
+ {
+ g_thread_init(NULL);
+ }
+
+ g_type_init();
+
+ mainloop = g_main_loop_new(NULL, FALSE);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "gmainloop is initialized\n");
+
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Entering g_main_loop()...\n");
+
+ wfd_server_init();
+
+ if (wfd_server_create_socket() == -1)
+ {
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ GIOChannel* gio2 = g_io_channel_unix_new(wfd_server->async_sockfd);
+ g_io_add_watch(gio2, G_IO_IN, (GIOFunc)wfd_server_accept_client_socket, NULL);
+ g_io_channel_unref(gio2);
+
+
+ wfd_server->mainloop = mainloop;
+ wfd_termination_timer_start();
+
+ //////////////////////////////////
+ // Start g_main_loop
+ //
+ g_main_loop_run(mainloop);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Leave g_main_loop_run()...\n");
+
+ wfd_server_destroy();
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "WLAN engine is destroyed...\n");
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "=================================\n");
+ WFD_SERVER_LOG(WFD_LOG_LOW, " Quit WiFi Direct Manager main()\n");
+ WFD_SERVER_LOG(WFD_LOG_LOW, "=================================\n");
+ WFD_SERVER_LOG(WFD_LOG_LOW, "Bye...\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+
+ return 0;
+}
--- /dev/null
+/*\r
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved \r
+ *\r
+ * This file is part of <Wi-Fi Direct>\r
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>\r
+ *\r
+ * PROPRIETARY/CONFIDENTIAL\r
+ *\r
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").\r
+ * You shall not disclose such Confidential Information and shall use it only in accordance\r
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.\r
+ * SAMSUNG make no representations or warranties about the suitability of the software,\r
+ * either express or implied, including but not limited to the implied warranties of merchantability,\r
+ * fitness for a particular purpose, or non-infringement.\r
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,\r
+ * modifying or distributing this software or its derivatives.\r
+ *\r
+ */\r
+\r
+#include <glib.h>\r
+#include <errno.h>\r
+#include <stdio.h>\r
+#include <string.h>\r
+#include <stdbool.h>\r
+#include <unistd.h>\r
+\r
+#include "vconf-keys.h"\r
+\r
+#include "wifi-direct-service.h"\r
+#include "wifi-direct-utils.h"\r
+\r
+#include <app_service.h>\r
+\r
+int wfd_server_check_valid(wifi_direct_cmd_e cmd)\r
+{\r
+ int state;\r
+ int valid = false;\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ state = wfd_server->state;\r
+ switch (cmd)\r
+ {\r
+ case WIFI_DIRECT_CMD_ACTIVATE:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_DEACTIVATED)\r
+ valid = true;\r
+ else\r
+ valid = false;\r
+ }\r
+ break;\r
+ case WIFI_DIRECT_CMD_DEACTIVATE:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_DEACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DEACTIVATING ||\r
+ state == WIFI_DIRECT_STATE_ACTIVATING)\r
+ valid = false;\r
+ else\r
+ valid = true;\r
+ }\r
+ break;\r
+ case WIFI_DIRECT_CMD_START_DISCOVERY:\r
+ case WIFI_DIRECT_CMD_CANCEL_DISCOVERY:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING ||\r
+ state == WIFI_DIRECT_STATE_CONNECTED ||\r
+ state == WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ valid = true;\r
+ else\r
+ valid = false;\r
+ }\r
+ break;\r
+ case WIFI_DIRECT_CMD_CONNECT:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING ||\r
+ state == WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ valid = true;\r
+ else\r
+ valid = false;\r
+ }\r
+ break;\r
+ case WIFI_DIRECT_CMD_CREATE_GROUP:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DISCOVERING)\r
+ valid = true;\r
+ else\r
+ valid = false;\r
+ }\r
+ break;\r
+ case WIFI_DIRECT_CMD_ACTIVATE_PUSHBUTTON:\r
+ case WIFI_DIRECT_CMD_GET_SUPPORTED_WPS_MODE:\r
+ case WIFI_DIRECT_CMD_GET_GO_INTENT:\r
+ case WIFI_DIRECT_CMD_SET_GO_INTENT:\r
+ case WIFI_DIRECT_CMD_IS_DISCOVERABLE:\r
+ case WIFI_DIRECT_CMD_IS_LISTENING_ONLY:\r
+ case WIFI_DIRECT_CMD_GET_OWN_GROUP_CHANNEL:\r
+ case WIFI_DIRECT_CMD_GET_PERSISTENT_GROUP_INFO:\r
+ case WIFI_DIRECT_CMD_REMOVE_PERSISTENT_GROUP:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_DEACTIVATED ||\r
+ state == WIFI_DIRECT_STATE_DEACTIVATING ||\r
+ state == WIFI_DIRECT_STATE_ACTIVATING)\r
+ valid = false;\r
+ else\r
+ valid = true;\r
+ }\r
+ break;\r
+\r
+ case WIFI_DIRECT_CMD_CANCEL_GROUP:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ valid = true;\r
+ else if ((state == WIFI_DIRECT_STATE_CONNECTING) && (wfd_server->autonomous_group_owner == true))\r
+ valid = true;\r
+ else\r
+ valid = false;\r
+ }\r
+ break;\r
+\r
+ case WIFI_DIRECT_CMD_DISCONNECT:\r
+ {\r
+ if (state == WIFI_DIRECT_STATE_GROUP_OWNER ||\r
+ state == WIFI_DIRECT_STATE_CONNECTED ||\r
+ state == WIFI_DIRECT_STATE_CONNECTING)\r
+ valid = true;\r
+ else\r
+ valid = false;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ valid = true;\r
+ break;\r
+ }\r
+\r
+ __WFD_SERVER_FUNC_EXIT__;\r
+\r
+ return valid;\r
+}\r
+\r
+\r
+void start_wifi_direct_service()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ //system("launch_app com.samsung.fileshare-service");\r
+ service_h service;\r
+ service_create(&service);\r
+ service_set_operation(service, SERVICE_OPERATION_DEFAULT);\r
+ service_set_package(service, "com.samsung.fileshare-service");\r
+ service_send_launch_request(service, NULL, NULL);\r
+ service_destroy(service);\r
+\r
+ __WFD_SERVER_FUNC_EXIT__;\r
+ \r
+}\r
+\r
+void stop_wifi_direct_service()\r
+{\r
+ // 2012-01-04: Dongwook. Let ftm-serviced quit by itself for gracefull termination.\r
+ // system("killall ftm-serviced");\r
+}\r
+\r
+void start_wifi_direct_ui_appl()\r
+{\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ //system("launch_app com.samsung.wifi-direct-popup");\r
+ service_h service;\r
+ service_create(&service);\r
+ service_set_operation(service, SERVICE_OPERATION_DEFAULT);\r
+ service_set_package(service, "com.samsung.wifi-direct-popup");\r
+ service_send_launch_request(service, NULL, NULL);\r
+ service_destroy(service);\r
+\r
+ __WFD_SERVER_FUNC_EXIT__;\r
+\r
+}\r
+\r
+\r
+void stop_wifi_direct_ui_appl()\r
+{\r
+ // 2012-02-24: Dongwook. Let wifi-direct-popup quit by itself for gracefull termination.\r
+ // system("killall wifi-direct-popup");\r
+}\r
+\r
+\r
+\r
+void wfd_server_set_state(int state)\r
+{\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+\r
+ __WFD_SERVER_FUNC_ENTER__;\r
+\r
+ if (state < WIFI_DIRECT_STATE_DEACTIVATED\r
+ || state > WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "Error : Invalid State\n");\r
+ return;\r
+ }\r
+\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "State Change: [%d,%s] ---->[%d,%s]\n",\r
+ wfd_server->state, wfd_print_state(wfd_server->state),\r
+ state, wfd_print_state(state));\r
+\r
+ if (wfd_server->state != WIFI_DIRECT_STATE_CONNECTING &&\r
+ state == WIFI_DIRECT_STATE_CONNECTING)\r
+ {\r
+\r
+ // stop timer for discover\r
+ wfd_timer_discovery_cancel();\r
+\r
+ // start timer for connection\r
+ wfd_timer_connection_start();\r
+ }\r
+\r
+ if (wfd_server->state < WIFI_DIRECT_STATE_CONNECTED &&\r
+ state >= WIFI_DIRECT_STATE_CONNECTED)\r
+ {\r
+ start_wifi_direct_service();\r
+ }\r
+\r
+ if (wfd_server->state == WIFI_DIRECT_STATE_CONNECTING &&\r
+ state != WIFI_DIRECT_STATE_CONNECTING)\r
+ {\r
+ // stop timer for connection\r
+ wfd_timer_connection_cancel();\r
+ }\r
+\r
+ if (wfd_server->state >= WIFI_DIRECT_STATE_CONNECTED &&\r
+ state < WIFI_DIRECT_STATE_CONNECTED)\r
+ {\r
+ stop_wifi_direct_service();\r
+ }\r
+\r
+ if (wfd_server->state != WIFI_DIRECT_STATE_DEACTIVATED &&\r
+ state == WIFI_DIRECT_STATE_DEACTIVATED)\r
+ {\r
+ wfd_termination_timer_start();\r
+ wfd_timer_discovery_cancel();\r
+ }\r
+ else\r
+ {\r
+ wfd_termination_timer_cancel();\r
+ }\r
+\r
+ if (wfd_server->state < WIFI_DIRECT_STATE_ACTIVATED &&\r
+ state == WIFI_DIRECT_STATE_ACTIVATED)\r
+ {\r
+ start_wifi_direct_ui_appl();\r
+ }\r
+\r
+ // Reset autonomous group owner flag\r
+ if (wfd_server->state == WIFI_DIRECT_STATE_GROUP_OWNER &&\r
+ state != WIFI_DIRECT_STATE_GROUP_OWNER)\r
+ {\r
+ if (wfd_server->autonomous_group_owner == true)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "[Reset autonomous group owner flag]\n");\r
+ wfd_server->autonomous_group_owner = false;\r
+ }\r
+ }\r
+\r
+\r
+ wfd_server->state = state;\r
+\r
+#if 0\r
+ // Check discovery state...\r
+ if (state == WIFI_DIRECT_STATE_ACTIVATED\r
+ && wfd_oem_is_discovery_enabled() == true)\r
+ {\r
+ WFD_SERVER_LOG(WFD_LOG_LOW, "state is changed to [WIFI_DIRECT_STATE_DISCOVERING]\n");\r
+ wfd_server->state = WIFI_DIRECT_STATE_DISCOVERING;\r
+ }\r
+#endif\r
+\r
+ switch (wfd_server->state)\r
+ {\r
+ //if (wfd_check_wifi_direct_state() < 0)\r
+ //WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_check_wifi_direct_state() failed\n");\r
+\r
+ case WIFI_DIRECT_STATE_DEACTIVATED:\r
+ {\r
+ if (wfd_set_wifi_direct_state(VCONFKEY_WIFI_DIRECT_DEACTIVATED) < 0)\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");\r
+ else\r
+ stop_wifi_direct_ui_appl();\r
+ }\r
+ break;\r
+\r
+ case WIFI_DIRECT_STATE_ACTIVATED:\r
+ {\r
+ if (wfd_set_wifi_direct_state(VCONFKEY_WIFI_DIRECT_ACTIVATED) < 0)\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");\r
+ }\r
+ break;\r
+\r
+ case WIFI_DIRECT_STATE_DISCOVERING:\r
+ {\r
+ if (wfd_set_wifi_direct_state(VCONFKEY_WIFI_DIRECT_DISCOVERING) < 0)\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");\r
+ }\r
+ break;\r
+\r
+ case WIFI_DIRECT_STATE_CONNECTED:\r
+ {\r
+ if (wfd_set_wifi_direct_state(VCONFKEY_WIFI_DIRECT_CONNECTED) < 0)\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");\r
+ }\r
+ break;\r
+\r
+ case WIFI_DIRECT_STATE_GROUP_OWNER:\r
+ {\r
+ if (wfd_set_wifi_direct_state(VCONFKEY_WIFI_DIRECT_GROUP_OWNER) < 0)\r
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");
+ }
+ break;
+
+ // for Net-Config can check the status of wifi-direct
+ case WIFI_DIRECT_STATE_ACTIVATING:
+ {
+ if (wfd_set_wifi_direct_state(VCONFKEY_WIFI_DIRECT_ACTIVATED) < 0)
+ WFD_SERVER_LOG(WFD_LOG_ASSERT, "wfd_set_wifi_direct_state() failed\n");\r
+ }\r
+ break;\r
+\r
+ default:\r
+ break;\r
+ }\r
+\r
+ __WFD_SERVER_FUNC_EXIT__;\r
+\r
+ return;\r
+}\r
+\r
+int wfd_server_get_state()\r
+{\r
+ wfd_server_control_t *wfd_server = wfd_server_get_control();\r
+ return wfd_server->state;\r
+}\r
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#include <glib.h>
+#include <sys/poll.h>
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <sys/poll.h>
+
+#include "wifi-direct-client-handler.h"
+#include "wifi-direct-service.h"
+#include "wifi-direct-internal.h"
+#include "wifi-direct-stub.h"
+
+bool wfd_server_client_request_callback(GIOChannel* source, GIOCondition condition, gpointer data);
+
+
+int wfd_server_is_fd_writable(int fd)
+{
+ struct pollfd pevent;
+ int retval = 0;
+
+ pevent.fd = fd;
+ pevent.events = POLLERR | POLLHUP | POLLNVAL | POLLOUT;
+ retval = poll((struct pollfd *) &pevent, 1, 1);
+
+ if (retval < 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "fd [%d]: poll error ret=[%d] !!\n", fd, retval);
+ return -1;
+ }
+ else if (retval == 0)
+ {
+ // fd might be busy.
+ WFD_SERVER_LOG(WFD_LOG_LOW, "poll timeout. fd is busy\n");
+ return 0;
+ }
+
+ if (pevent.revents & POLLERR)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "fd [%d]: POLLERR !!\n", fd);
+ return -1;
+ }
+ else if (pevent.revents & POLLHUP)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "fd [%d]: POLLHUP !!\n", fd);
+ return -1;
+ }
+ else if (pevent.revents & POLLNVAL)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "fd [%d]: POLLNVAL !!\n", fd);
+ return -1;
+ }
+ else if (pevent.revents & POLLOUT)
+ {
+ // fd is writable..
+ // WFD_SERVER_LOG(WFD_LOG_LOW, "fd [%d]: POLLOUT !!\n", fd);
+ return 1;
+ }
+
+ return -1;
+}
+
+
+int wfd_server_read_socket_event(int sockfd, char *dataptr, int datalen)
+{
+ int pollret = 0;
+ struct pollfd pollfd;
+ int timeout = 1000; /* For 1 sec */
+ int retval = 0;
+ int total_data_recd = 0;
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ if (sockfd < 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! Invalid socket FD [%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ pollfd.fd = sockfd;
+ pollfd.events = POLLIN | POLLERR | POLLHUP;
+ pollret = poll(&pollfd, 1, timeout);
+
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLL ret = %d\n", pollret);
+
+ if (pollret > 0)
+ {
+ if (pollfd.revents == POLLIN)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLLIN \n");
+
+ while (datalen)
+ {
+ errno = 0;
+ retval = read(sockfd, (char*)dataptr, datalen);
+ WFD_SERVER_LOG( WFD_LOG_LOW, "sockfd %d retval %d\n",sockfd,retval);
+ if (retval <= 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! reading data, error [%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return retval;
+ }
+ total_data_recd += retval;
+ dataptr += retval;
+ datalen -= retval;
+ }
+ __WFD_SERVER_FUNC_EXIT__;
+ return total_data_recd;
+ }
+ else if (pollfd.revents & POLLHUP)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! POLLHUP: connection disconnected fd=[%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+ else if (pollfd.revents & POLLERR)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! POLLERR: error happens at the socket. fd=[%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+ }
+ else if (pollret == 0)
+ {
+ WFD_SERVER_LOG(WFD_LOG_LOW, "POLLing timeout fd=[%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! Polling unknown error fd=[%d]\n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return -1;
+ }
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return 0;
+}
+
+void wfd_server_reset_client(int sync_sockfd)
+{
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ int index = 0;
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ for (index = 0; index < WFD_MAX_CLIENTS; index++)
+ {
+ if ((wfd_server->client[index].isUsed == TRUE) &&
+ (wfd_server->client[index].sync_sockfd == sync_sockfd))
+ {
+ WFD_SERVER_LOG( WFD_LOG_HIGH,
+ "Reset client[%d]: ClientID=%d, socketfd=(%d,%d), handle=[%d] total active clients = [%d]\n",
+ index,
+ wfd_server->client[index].client_id,
+ wfd_server->client[index].sync_sockfd,
+ wfd_server->client[index].async_sockfd,
+ wfd_server->client[index].dev_handle,
+ wfd_server->active_clients-1);
+
+ g_source_remove(wfd_server->client[index].g_source_id);
+
+ // Protect standard input / output / error
+ if (wfd_server->client[index].async_sockfd > 2)
+ close(wfd_server->client[index].async_sockfd);
+
+ if (wfd_server->client[index].sync_sockfd > 2)
+ close(wfd_server->client[index].sync_sockfd);
+
+ /* Reset Entity */
+ wfd_server->client[index].isUsed = FALSE;
+ wfd_server->client[index].client_id = -1;
+ wfd_server->client[index].sync_sockfd = -1;
+ wfd_server->client[index].async_sockfd = -1;
+ wfd_server->client[index].g_source_id = -1;
+ wfd_server->client[index].dev_handle = -1;
+
+ wfd_server->active_clients--;
+
+ wfd_termination_timer_start();
+
+ wfd_server_print_client();
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+ }
+ }
+
+ WFD_SERVER_LOG( WFD_LOG_EXCEPTION,
+ "Error!!! Reset client fail: socketfd=%d is not found\n", sync_sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+}
+
+void wfd_server_print_client()
+{
+ __WFD_SERVER_FUNC_ENTER__;
+
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+ int index = 0;
+
+ WFD_SERVER_LOG( WFD_LOG_HIGH, "--------------------\n", wfd_server->active_clients-1);
+ for (index = 0; index < WFD_MAX_CLIENTS; index++)
+ {
+ if (wfd_server->client[index].isUsed == TRUE)
+ {
+ WFD_SERVER_LOG(WFD_LOG_HIGH,
+ "+ CLIENT[%d]: ClientID=%d, sktfd=(%d,%d), g_src_id= [%d]\n",
+ index,
+ wfd_server->client[index].client_id,
+ wfd_server->client[index].sync_sockfd,
+ wfd_server->client[index].async_sockfd,
+ wfd_server->client[index].g_source_id
+ );
+ }
+ }
+ WFD_SERVER_LOG( WFD_LOG_HIGH, "Total active client=[%d]\n", wfd_server->active_clients);
+ WFD_SERVER_LOG( WFD_LOG_HIGH, "--------------------\n");
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return;
+}
+
+
+
+bool wfd_server_client_request_callback(GIOChannel* source, GIOCondition condition, gpointer data)
+{
+ int sockfd = (int) data;
+ wifi_direct_client_request_s client_req;
+ int req_len = sizeof(wifi_direct_client_request_s);
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ memset(&client_req, 0, req_len);
+
+ if (wfd_server_read_socket_event(sockfd, (char *) &client_req, req_len) < 0)
+ {
+ wfd_server_reset_client(sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+ }
+
+ wfd_server_process_client_request(&client_req);
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return TRUE;
+}
+
+
+/* Function to connect client with wfd_server */
+bool wfd_server_register_client(int sockfd)
+{
+ int index = 0;
+ int status = 0;
+ wifi_direct_client_request_s register_req;
+ wifi_direct_client_response_s register_rsp;
+ wfd_server_control_t *wfd_server = wfd_server_get_control();
+
+ __WFD_SERVER_FUNC_ENTER__;
+
+ if (sockfd <= 0)
+ {
+ // invalid socket fd should not be closed!!
+ WFD_SERVER_LOG( WFD_LOG_ASSERT, "Error!!! Invalid sockfd argument = [%d] \n", sockfd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return TRUE;
+ }
+
+ /** Read the Register socket type*/
+ errno = 0;
+ status = read(sockfd, (char*)®ister_req, sizeof(wifi_direct_client_request_s));
+ if(status <= 0)
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! reading data, error [%s]\n", strerror(errno));
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+ }
+
+ if (register_req.cmd == WIFI_DIRECT_CMD_REGISTER)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Client socket for sync data transfer, from client [%d] \n", register_req.client_id);
+
+ for (index = 0; index < WFD_MAX_CLIENTS; index++)
+ {
+ if (wfd_server->client[index].isUsed == FALSE)
+ {
+ /*Send Client id to the application */
+ int datasent = 0;
+
+ memset(®ister_rsp, 0, sizeof(wifi_direct_client_response_s));
+ register_rsp.cmd = WIFI_DIRECT_CMD_REGISTER;
+ register_rsp.client_id = sockfd;
+ register_rsp.result = WIFI_DIRECT_ERROR_NONE;
+ errno = 0;
+ datasent = write(sockfd, (char*)®ister_rsp, sizeof(wifi_direct_client_response_s));
+
+ WFD_SERVER_LOG( WFD_LOG_LOW,
+ "Written RSP of [%d] data into client socket [%d], errinfo [%s] \n",
+ datasent, sockfd, strerror(errno));
+
+ /** register socket watcher to g_main_loop */
+ GIOChannel* gio;
+ gio = g_io_channel_unix_new(sockfd);
+ int source_id = g_io_add_watch(gio, G_IO_IN | G_IO_ERR | G_IO_HUP,
+ (GIOFunc)wfd_server_client_request_callback, (gpointer)sockfd);
+
+ /** Found Free Entity */
+ wfd_server->client[index].isUsed = TRUE;
+ wfd_server->client[index].client_id = sockfd;
+ wfd_server->client[index].sync_sockfd = sockfd;
+ wfd_server->client[index].g_source_id = source_id;
+
+ wfd_server->active_clients++;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Client stored in index [%d], total active clients = [%d]\n", index, wfd_server->active_clients);
+ __WFD_SERVER_FUNC_EXIT__;
+ return TRUE;
+ }
+ }
+
+ if (index == WFD_MAX_CLIENTS)
+ {
+ int datasent = 0;
+ memset(®ister_rsp, 0, sizeof(wifi_direct_client_response_s));
+ register_rsp.cmd = WIFI_DIRECT_CMD_REGISTER;
+ register_rsp.client_id = sockfd;
+ register_rsp.result = WIFI_DIRECT_ERROR_RESOURCE_BUSY;
+ errno = 0;
+ datasent = write(sockfd, (char*)®ister_rsp, sizeof(wifi_direct_client_response_s));
+
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! Too Many Client\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+ }
+ }
+ else if (register_req.cmd == WIFI_DIRECT_CMD_INIT_ASYNC_SOCKET)
+ {
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Client socket for Async Event notification from client [%d]\n", register_req.client_id);
+
+ for (index = 0; index < WFD_MAX_CLIENTS; index++)
+ {
+ if ((wfd_server->client[index].isUsed == TRUE)
+ && (wfd_server->client[index].client_id ==
+ register_req.client_id))
+ {
+ wfd_server->client[index].async_sockfd = sockfd;
+
+ WFD_SERVER_LOG( WFD_LOG_LOW, "Client stored in index [%d], total active clients = [%d]\n", index, wfd_server->active_clients);
+
+ wfd_server_print_client();
+
+ __WFD_SERVER_FUNC_EXIT__;
+ return TRUE;
+ }
+ }
+
+ if (index == WFD_MAX_CLIENTS)
+ {
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! Client not found \n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+ }
+ }
+ else
+ {
+ WFD_SERVER_LOG( WFD_LOG_ERROR, "Error!!! Received unknown command [%d] \n", register_req.cmd);
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+ }
+
+ WFD_SERVER_LOG(WFD_LOG_ERROR, "Error!!! Unknown...\n");
+ __WFD_SERVER_FUNC_EXIT__;
+ return FALSE;
+}
--- /dev/null
+/*
+ * Copyright (c) 2000 - 2012 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * This file is part of <Wi-Fi Direct>
+ * Written by Sungsik Jang<sngsik.jang@samsung.com>, Dongwook Lee<dwmax.lee@samsung.com>
+ *
+ * PROPRIETARY/CONFIDENTIAL
+ *
+ * This software is the confidential and proprietary information of SAMSUNG ELECTRONICS ("Confidential Information").
+ * You shall not disclose such Confidential Information and shall use it only in accordance
+ * with the terms of the license agreement you entered into with SAMSUNG ELECTRONICS.
+ * SAMSUNG make no representations or warranties about the suitability of the software,
+ * either express or implied, including but not limited to the implied warranties of merchantability,
+ * fitness for a particular purpose, or non-infringement.
+ * SAMSUNG shall not be liable for any damages suffered by licensee as a result of using,
+ * modifying or distributing this software or its derivatives.
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <errno.h>
+#include <sys/time.h>
+
+#define _GNU_SOURCE
+#include <unistd.h>
+#include <sys/syscall.h>
+
+
+#include "wifi-direct-utils.h"
+#include "wifi-direct-service.h"
+
+int wfd_gettid()
+{
+#ifdef __NR_gettid
+ return syscall(__NR_gettid);
+#else
+ fprintf(stderr,
+ "__NR_gettid is not defined, please include linux/unistd.h ");
+ return -1;
+#endif
+}
+
+char *wfd_trim_path(const char *filewithpath)
+{
+ static char *filename[100];
+ char *strptr = NULL;
+ int start = 0;
+ const char *space = " ";
+ int len = strlen(filewithpath);
+
+ if (len >= 20)
+ {
+ strptr = (char *) filewithpath + (len - 20);
+ start = 0;
+ }
+ else
+ {
+ strptr = (char *) filewithpath;
+ start = 20 - len;
+ }
+ strncpy((char *) filename, space, strlen(space));
+ strncpy((char *) filename + start, strptr, 50);
+
+ return (char *) filename;
+}
+
+char *wfd_debug_print(char *file, int line, char *format, ...)
+{
+ static char buffer_internal[512];
+ char prefix_buffer[64];
+ char *prefix;
+ va_list args;
+ char buf[512];
+ int header_max = 35;
+
+ va_start(args, format);
+ vsnprintf(buf, 512, format, args);
+ va_end(args);
+
+ snprintf(prefix_buffer, 64, "[%s:%d,%d]", file, line, wfd_gettid());
+ int len = 0;
+ len = strlen(prefix_buffer);
+ if (len > header_max)
+ {
+ prefix = prefix_buffer + (len - header_max);
+ }
+ else
+ {
+ prefix = prefix_buffer;
+ }
+
+ snprintf(buffer_internal, 512, "%s%s", prefix, buf);
+
+ return buffer_internal;
+}
+
+char *wfd_print_state(wifi_direct_state_e s)
+{
+ switch (s)
+ {
+ case WIFI_DIRECT_STATE_DEACTIVATED:
+ return "DEACTIVATED";
+ break;
+
+ case WIFI_DIRECT_STATE_DEACTIVATING:
+ return "DEACTIVATING";
+ break;
+ case WIFI_DIRECT_STATE_ACTIVATING:
+ return "ACTIVATING";
+ break;
+ case WIFI_DIRECT_STATE_ACTIVATED:
+ return "ACTIVATED";
+ break;
+ case WIFI_DIRECT_STATE_DISCOVERING:
+ return "DISCOVERING";
+ break;
+ case WIFI_DIRECT_STATE_CONNECTING:
+ return "CONNECTING";
+ break;
+ case WIFI_DIRECT_STATE_DISCONNECTING:
+ return "DISCONNECTING";
+ break;
+ case WIFI_DIRECT_STATE_CONNECTED:
+ return "CONNECTED";
+ break;
+ case WIFI_DIRECT_STATE_GROUP_OWNER:
+ return "GROUP OWNER";
+ break;
+ default:
+ return "Unknown";
+ }
+ return "Unknown";
+}
+
+int wfd_macaddr_atoe(char *p, unsigned char mac[])
+{
+ int i = 0;
+
+ printf("MAC [%s]\n", p);
+
+ for (;;)
+ {
+ mac[i++] = (char) strtoul(p, &p, 16);
+ if (!*p++ || i == 6)
+ break;
+ }
+
+ return (i == 6);
+}
+
--- /dev/null
+<manifest>
+ <define>
+ <domain name="wifi_direct_manager" policy="restricted" plist="wifi-direct-plugin-broadcom, wifi-direct-plugin-wpasupplicant"/>
+ </define>
+ <request>
+ <domain name="wifi_direct_manager"/>
+ </request>
+</manifest>
--- /dev/null
+<manifest>
+ <request>
+ <domain name="wifi_direct_manager"/>
+ </request>
+</manifest>
projects / platform / core / connectivity / wifi-direct-manager.git / commitdiff