#define WFD_MANAGER_SERVICE_INTERFACE WFD_MANAGER_SERVICE ".service"
#define WFD_MANAGER_DISPLAY_INTERFACE WFD_MANAGER_SERVICE ".display"
#if defined(TIZEN_FEATURE_ASP)
-#define WFD_MANAGER_ASP_INTERFACE WFD_MANAGER_SERVICE ".asp"
+#define WFD_MANAGER_ASP_INTERFACE WFD_MANAGER_SERVICE ".asp"
#endif
#define WFD_MANAGER_DBUS_REPLY_TIMEOUT 10 * 1000
char ssid[DEV_NAME_LEN+1];
unsigned char bssid[MACADDR_LEN];
unsigned char go_dev_addr[MACADDR_LEN];
- int flags; // Autonomous, Persistent
- int role; // local device role
- int freq; // MHz
+ int flags; /* Autonomous, Persistent */
+ int role; /* local device role */
+ int freq; /* MHz */
GList *members;
int member_count;
char passphrase[PASSPHRASE_LEN_MAX + 1];
/**
* Wi-Fi Direct configuration data structure for IPC
*/
-typedef struct
-{
+typedef struct {
char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN + 1];
int channel;
wfd_wps_type_e wps_config;
/**
* Wi-Fi Direct buffer structure to store result of peer discovery for IPC
*/
-typedef struct
-{
+typedef struct {
char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN + 1];
unsigned char mac_address[6];
unsigned char intf_address[6];
/**
* Wi-Fi Direct buffer structure to store information of connected peer
*/
-typedef struct
-{
+typedef struct {
char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN + 1];
unsigned char ip_address[4];
unsigned char mac_address[6];
} wfd_connected_peer_info_s;
-typedef struct
-{
+typedef struct {
int network_id;
char ssid[WIFI_DIRECT_MAX_SSID_LEN + 1];
unsigned char go_mac_address[6];
int max_station;
int autoconnection;
unsigned char autoconnection_peer[MACADDR_LEN];
- char auto_pin[PINSTR_LEN+1]; // for NFC Printer
+ char auto_pin[PINSTR_LEN+1]; /* for NFC Printer */
int scan_mode;
GList *peers;
typedef enum {
WFD_BONJOUR_RDATA_PTR = 0x0c,
WFD_BONJOUR_RDATA_TXT = 0x10,
-}wfd_bonjour_rdata_type_e;
+} wfd_bonjour_rdata_type_e;
typedef struct {
int version;
#define VCONFKEY_DHCPC_SERVER_IP "memory/private/wifi_direct_manager/dhcpc_server_ip"
#define VCONFKEY_LOCAL_IP "memory/private/wifi_direct_manager/p2p_local_ip"
#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]
+#define MAX_DHCP_DUMP_SIZE 64 /* Single lease format: [99:66:dd:00:11:aa 192.168.16.20 00:00:60] */
#define SOCK_FD_MIN 3
int wfd_oem_init(wfd_oem_ops_s *ops, wfd_oem_event_cb event_callback, void *user_data)
{
- if (!ops || !ops->init) {
+ if (!ops || !ops->init)
return -1;
- }
return ops->init(event_callback, user_data);
}
#if 0
int wfd_oem_deinit(wfd_oem_ops_s *ops)
{
- if (!ops || !ops->deinit) {
+ if (!ops || !ops->deinit)
return -1;
- }
return ops->deinit();
}
int wfd_oem_activate(wfd_oem_ops_s *ops, int concurrent)
{
- if (!ops || !ops->activate) {
+ if (!ops || !ops->activate)
return -1;
- }
return ops->activate(concurrent);
}
int wfd_oem_deactivate(wfd_oem_ops_s *ops, int concurrent)
{
- if (!ops || !ops->deactivate) {
+ if (!ops || !ops->deactivate)
return -1;
- }
return ops->deactivate(concurrent);
}
int wfd_oem_start_scan(wfd_oem_ops_s *ops, wfd_oem_scan_param_s *param)
{
- if (!ops || !ops->start_scan) {
+ if (!ops || !ops->start_scan)
return -1;
- }
return ops->start_scan(param);
}
int wfd_oem_stop_scan(wfd_oem_ops_s *ops)
{
- if (!ops || !ops->stop_scan) {
+ if (!ops || !ops->stop_scan)
return -1;
- }
return ops->stop_scan();
}
int wfd_oem_get_visibility(wfd_oem_ops_s *ops, int *visibility)
{
- if (!ops || !ops->get_visibility) {
+ if (!ops || !ops->get_visibility)
return -1;
- }
return ops->get_visibility(visibility);
}
int wfd_oem_set_visibility(wfd_oem_ops_s *ops, int visibility)
{
- if (!ops || !ops->set_visibility) {
+ if (!ops || !ops->set_visibility)
return -1;
- }
return ops->set_visibility(visibility);
}
int wfd_oem_get_scan_result(wfd_oem_ops_s *ops, GList **peers, int *peer_count)
{
- if (!ops || !ops->get_scan_result) {
+ if (!ops || !ops->get_scan_result)
return -1;
- }
return ops->get_scan_result(peers, peer_count);
}
int wfd_oem_get_peer_info(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_device_s **peer)
{
- if (!ops || !ops->get_peer_info) {
+ if (!ops || !ops->get_peer_info)
return -1;
- }
return ops->get_peer_info(peer_addr, peer);
}
int wfd_oem_prov_disc_req(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_wps_mode_e wps_mode, int join)
{
- if (!ops || !ops->prov_disc_req) {
+ if (!ops || !ops->prov_disc_req)
return -1;
- }
return ops->prov_disc_req(peer_addr, wps_mode, join);
}
int wfd_oem_connect(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_conn_param_s *param)
{
- if (!ops || !ops->connect) {
+ if (!ops || !ops->connect)
return -1;
- }
return ops->connect(peer_addr, param);
}
int wfd_oem_reject_connection(wfd_oem_ops_s *ops, unsigned char *peer_addr)
{
- if (!ops || !ops->reject_connection) {
+ if (!ops || !ops->reject_connection)
return -1;
- }
return ops->reject_connection(peer_addr);
}
int wfd_oem_cancel_connection(wfd_oem_ops_s *ops, unsigned char *peer_addr)
{
- if (!ops || !ops->cancel_connection) {
+ if (!ops || !ops->cancel_connection)
return -1;
- }
return ops->cancel_connection(peer_addr);
}
int wfd_oem_disconnect(wfd_oem_ops_s *ops, unsigned char *peer_addr)
{
- if (!ops || !ops->disconnect) {
+ if (!ops || !ops->disconnect)
return -1;
- }
return ops->disconnect(peer_addr);
}
int wfd_oem_get_connected_peers(wfd_oem_ops_s *ops, GList **peers, int *peer_count)
{
- if (!ops || !ops->get_connected_peers) {
+ if (!ops || !ops->get_connected_peers)
return -1;
- }
return ops->get_connected_peers(peers, peer_count);
}
int wfd_oem_get_pin(wfd_oem_ops_s *ops, char *pin)
{
- if (!ops || !ops->get_pin) {
+ if (!ops || !ops->get_pin)
return -1;
- }
return ops->get_pin(pin);
}
int wfd_oem_set_pin(wfd_oem_ops_s *ops, char *pin)
{
- if (!ops || !ops->set_pin) {
+ if (!ops || !ops->set_pin)
return -1;
- }
return ops->set_pin(pin);
}
int wfd_oem_generate_pin(wfd_oem_ops_s *ops, char **pin)
{
- if (!ops || !ops->generate_pin) {
+ if (!ops || !ops->generate_pin)
return -1;
- }
return ops->generate_pin(pin);
}
int wfd_oem_get_supported_wps_mode(wfd_oem_ops_s *ops, int *wps_mode)
{
- if (!ops || !ops->get_supported_wps_mode) {
+ if (!ops || !ops->get_supported_wps_mode)
return -1;
- }
return ops->get_supported_wps_mode(wps_mode);
}
int wfd_oem_create_group(wfd_oem_ops_s *ops, wfd_oem_group_param_s *param)
{
- if (!ops || !ops->create_group) {
+ if (!ops || !ops->create_group)
return -1;
- }
return ops->create_group(param);
}
int wfd_oem_destroy_group(wfd_oem_ops_s *ops, const char *ifname)
{
- if (!ops || !ops->destroy_group) {
+ if (!ops || !ops->destroy_group)
return -1;
- }
return ops->destroy_group(ifname);
}
int wfd_oem_invite(wfd_oem_ops_s *ops, unsigned char *peer_addr, wfd_oem_invite_param_s *param)
{
- if (!ops || !ops->invite) {
+ if (!ops || !ops->invite)
return -1;
- }
return ops->invite(peer_addr, param);
}
int wfd_oem_wps_start(wfd_oem_ops_s *ops, unsigned char *peer_addr, int wps_mode, const char *pin)
{
- if (!ops || !ops->wps_start) {
+ if (!ops || !ops->wps_start)
return -1;
- }
return ops->wps_start(peer_addr, wps_mode, pin);
}
int wfd_oem_enrollee_start(wfd_oem_ops_s *ops, unsigned char *peer_addr, int wps_mode, const char *pin)
{
- if (!ops || !ops->enrollee_start) {
+ if (!ops || !ops->enrollee_start)
return -1;
- }
return ops->enrollee_start(peer_addr, wps_mode, pin);
}
int wfd_oem_wps_cancel(wfd_oem_ops_s *ops)
{
- if (!ops) {
+ if (!ops || !ops->wps_cancel)
return -1;
- }
return ops->wps_cancel();
}
int wfd_oem_get_dev_name(wfd_oem_ops_s *ops, char *dev_name)
{
- if (!ops || !ops->get_dev_name) {
+ if (!ops || !ops->get_dev_name)
return -1;
- }
return ops->get_dev_name(dev_name);
}
int wfd_oem_set_dev_name(wfd_oem_ops_s *ops, char *dev_name)
{
- if (!ops || !ops->set_dev_name) {
+ if (!ops || !ops->set_dev_name)
return -1;
- }
return ops->set_dev_name(dev_name);
}
int wfd_oem_get_dev_mac(wfd_oem_ops_s *ops, char *dev_mac)
{
- if (!ops || !ops->get_dev_mac) {
+ if (!ops || !ops->get_dev_mac)
return -1;
- }
return ops->get_dev_mac(dev_mac);
}
int wfd_oem_get_dev_type(wfd_oem_ops_s *ops, int *pri_dev_type, int *sec_dev_type)
{
- if (!ops || !ops->get_dev_type) {
+ if (!ops || !ops->get_dev_type)
return -1;
- }
return ops->get_dev_type(pri_dev_type, sec_dev_type);
}
int wfd_oem_set_dev_type(wfd_oem_ops_s *ops, int pri_dev_type, int sec_dev_type)
{
- if (!ops || !ops->set_dev_type) {
+ if (!ops || !ops->set_dev_type)
return -1;
- }
return ops->set_dev_type(pri_dev_type, sec_dev_type);
}
int wfd_oem_get_go_intent(wfd_oem_ops_s *ops, int *go_intent)
{
- if (!ops || !ops->get_go_intent) {
+ if (!ops || !ops->get_go_intent)
return -1;
- }
return ops->get_go_intent(go_intent);
}
int wfd_oem_set_go_intent(wfd_oem_ops_s *ops, int go_intent)
{
- if (!ops || !ops->set_go_intent) {
+ if (!ops || !ops->set_go_intent)
return -1;
- }
return ops->set_go_intent(go_intent);
}
int wfd_oem_set_country(wfd_oem_ops_s *ops, char *ccode)
{
- if (!ops || !ops->set_country) {
+ if (!ops || !ops->set_country)
return -1;
- }
return ops->set_country(ccode);
}
int wfd_oem_get_persistent_groups(wfd_oem_ops_s *ops, wfd_oem_persistent_group_s **groups, int *group_count)
{
- if (!ops || !ops->get_persistent_groups) {
+ if (!ops || !ops->get_persistent_groups)
return -1;
- }
return ops->get_persistent_groups(groups, group_count);
}
int wfd_oem_remove_persistent_group(wfd_oem_ops_s *ops, char *ssid, unsigned char *bssid)
{
- if (!ops || !ops->remove_persistent_group) {
+ if (!ops || !ops->remove_persistent_group)
return -1;
- }
return ops->remove_persistent_group(ssid, bssid);
int wfd_oem_set_persistent_reconnect(wfd_oem_ops_s *ops, unsigned char *bssid, int reconnect)
{
- if (!ops || !ops->set_persistent_reconnect) {
+ if (!ops || !ops->set_persistent_reconnect)
return -1;
- }
return ops->set_persistent_reconnect(bssid, reconnect);
}
#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
int wfd_oem_start_service_discovery(wfd_oem_ops_s *ops, unsigned char *peer_addr, int service_type)
{
- if (!ops || !ops->start_service_discovery) {
+ if (!ops || !ops->start_service_discovery)
return -1;
- }
return ops->start_service_discovery(peer_addr, service_type);
}
int wfd_oem_cancel_service_discovery(wfd_oem_ops_s *ops, unsigned char *peer_addr, int service_type)
{
- if (!ops || !ops->cancel_service_discovery) {
+ if (!ops || !ops->cancel_service_discovery)
return -1;
- }
return ops->cancel_service_discovery(peer_addr, service_type);
}
int wfd_oem_serv_add(wfd_oem_ops_s *ops, wfd_oem_new_service_s *service)
{
- if (!ops || !ops->serv_add) {
+ if (!ops || !ops->serv_add)
return -1;
- }
return ops->serv_add(service);
}
int wfd_oem_serv_del(wfd_oem_ops_s *ops, wfd_oem_new_service_s *service)
{
- if (!ops || !ops->serv_del) {
+ if (!ops || !ops->serv_del)
return -1;
- }
return ops->serv_del(service);
}
int wfd_oem_serv_disc_start(wfd_oem_ops_s *ops, wfd_oem_new_service_s *service)
{
- if (!ops || !ops->serv_disc_start) {
+ if (!ops || !ops->serv_disc_start)
return -1;
- }
return ops->serv_disc_start(service);
}
int wfd_oem_serv_disc_stop(wfd_oem_ops_s *ops, int handle)
{
- if (!ops || !ops->serv_disc_stop) {
+ if (!ops || !ops->serv_disc_stop)
return -1;
- }
return ops->serv_disc_stop(handle);
}
#ifdef TIZEN_FEATURE_WIFI_DISPLAY
int wfd_oem_miracast_init(wfd_oem_ops_s *ops, int enable)
{
- if (!ops || !ops->miracast_init) {
+ if (!ops || !ops->miracast_init)
return -1;
- }
return ops->miracast_init(enable);
}
int wfd_oem_set_display(wfd_oem_ops_s *ops, wfd_oem_display_s *wifi_display)
{
- if (!ops || !ops->set_display) {
+ if (!ops || !ops->set_display)
return -1;
- }
+
return ops->set_display(wifi_display);
}
int wfd_oem_refresh(wfd_oem_ops_s *ops)
{
- if (!ops || !ops->refresh) {
+ if (!ops || !ops->refresh)
return -1;
- }
return ops->refresh();
}
#if defined(TIZEN_FEATURE_ASP)
int wfd_oem_advertise_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service, int replace)
{
- if (!ops || !ops->advertise_service) {
+ if (!ops || !ops->advertise_service)
return -1;
- }
return ops->advertise_service(service, replace);
}
int wfd_oem_cancel_advertise_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service)
{
- if (!ops || !ops->cancel_advertise_service) {
+ if (!ops || !ops->cancel_advertise_service)
return -1;
- }
return ops->cancel_advertise_service(service);
}
int wfd_oem_seek_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service)
{
- if (!ops || !ops->seek_service) {
+ if (!ops || !ops->seek_service)
return -1;
- }
return ops->seek_service(service);
}
int wfd_oem_cancel_seek_service(wfd_oem_ops_s *ops, wfd_oem_asp_service_s *service)
{
- if (!ops || !ops->cancel_seek_service) {
+ if (!ops || !ops->cancel_seek_service)
return -1;
- }
return ops->cancel_seek_service(service);
}
int wfd_oem_asp_prov_disc_req(wfd_oem_ops_s *ops, wfd_oem_asp_prov_s *params)
{
- if (!ops || !ops->asp_prov_disc_req) {
+ if (!ops || !ops->asp_prov_disc_req)
return -1;
- }
return ops->asp_prov_disc_req(params);
}
WFD_OEM_EVENT_PEER_DISAPPEARED,
WFD_OEM_EVENT_DISCOVERY_FINISHED,
- WFD_OEM_EVENT_PROV_DISC_REQ, // 5
+ WFD_OEM_EVENT_PROV_DISC_REQ, /* 5 */
WFD_OEM_EVENT_PROV_DISC_RESP,
WFD_OEM_EVENT_PROV_DISC_FAIL,
WFD_OEM_EVENT_GO_NEG_REQ,
WFD_OEM_EVENT_GO_NEG_FAIL,
- WFD_OEM_EVENT_GO_NEG_DONE, // 10
+ WFD_OEM_EVENT_GO_NEG_DONE, /* 10 */
WFD_OEM_EVENT_WPS_FAIL,
WFD_OEM_EVENT_WPS_DONE,
WFD_OEM_EVENT_KEY_NEG_FAIL,
WFD_OEM_EVENT_KEY_NEG_DONE,
- WFD_OEM_EVENT_CONN_FAIL, // 15
+ WFD_OEM_EVENT_CONN_FAIL, /* 15 */
WFD_OEM_EVENT_CONN_DONE,
WFD_OEM_EVENT_GROUP_CREATED,
WFD_OEM_EVENT_GROUP_DESTROYED,
WFD_OEM_EVENT_INVITATION_REQ,
- WFD_OEM_EVENT_INVITATION_RES, // 20
+ WFD_OEM_EVENT_INVITATION_RES, /* 20 */
WFD_OEM_EVENT_STA_CONNECTED,
WFD_OEM_EVENT_STA_DISCONNECTED,
- WFD_OEM_EVENT_TERMINATING, // 25
+ WFD_OEM_EVENT_TERMINATING, /* 23 */
#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
WFD_OEM_EVENT_SERV_DISC_RESP,
typedef struct {
int event_id;
- unsigned char dev_addr[OEM_MACADDR_LEN]; // device address
+ unsigned char dev_addr[OEM_MACADDR_LEN]; /* device address */
unsigned char intf_addr[OEM_MACADDR_LEN];
int wps_mode;
- char wps_pin[OEM_PINSTR_LEN+1]; // just for DISPLAY
+ char wps_pin[OEM_PINSTR_LEN+1]; /* just for DISPLAY */
char ifname[OEM_IFACE_NAME_LEN+1];
int dev_role;
unsigned char ip_addr_peer[OEM_IPADDR_LEN];
typedef struct {
int wps_mode;
- int conn_flags; // join, auth, persistent
+ int conn_flags; /* join, auth, persistent */
int go_intent;
int freq;
char wps_pin[OEM_PINSTR_LEN+1];
typedef enum {
WFD_OEM_BONJOUR_RDATA_PTR = 0x0c,
WFD_OEM_BONJOUR_RDATA_TXT = 0x10,
-}wfd_oem_bonjour_rdata_type_e;
+} wfd_oem_bonjour_rdata_type_e;
typedef struct {
/** Device address for which service discovery is requested */
typedef enum {
WFD_OEM_AUTH_ALG_OPEN = 0x01, /* OPEN */
-}wfd_oem_auth_alg_e;
+} wfd_oem_auth_alg_e;
typedef enum {
WFD_OEM_PERSISTENT_MODE_GC = 0x0,
} wfd_oem_persistent_mode_e;
#if defined(TIZEN_FEATURE_ASP)
-typedef enum
-{
+typedef enum {
WFD_OEM_TYPE_ADVERTISE,
WFD_OEM_TYPE_SEEK,
WFD_OEM_TYPE_MAX,
unsigned char ip_addr[OEM_IPADDR_LEN];
} wfd_oem_asp_prov_s;
#endif /* TIZEN_FEATURE_ASP */
-typedef struct
-{
+typedef struct {
int network_id;
char ssid[OEM_DEV_NAME_LEN + 1];
unsigned char go_mac_address[OEM_MACADDR_LEN];
int (*get_go_intent) (int *go_intent);
int (*set_go_intent) (int go_intent);
int (*set_country) (char *ccode);
-// int (*get_country) (char **ccode);
int (*get_persistent_groups) (wfd_oem_persistent_group_s **groups, int *group_count);
int (*remove_persistent_group) (char *ssid, unsigned char *bssid);
Name: wifi-direct-manager
Summary: Wi-Fi Direct manger
-Version: 1.2.167
+Version: 1.2.168
Release: 1
Group: Network & Connectivity/Wireless
License: Apache-2.0
{
__WDP_LOG_FUNC_ENTER__;
- if(params == NULL || connection == NULL || object_path == NULL ||
- method_name == NULL)
- {
+ if (params == NULL || connection == NULL || object_path == NULL ||
+ method_name == NULL) {
WDP_LOGE("Invalid Arguments!");
return -1;
}
GVariant *reply = NULL;
GError *error = NULL;
- if(!params || !params->connection) {
+ if (!params || !params->connection) {
WDP_LOGE("Invalid parameters");
__WDP_LOG_FUNC_EXIT__;
return -1;
WDP_LOGD("method [%s]", params->method_name);
- reply = g_dbus_connection_call_sync (
+ reply = g_dbus_connection_call_sync(
params->connection,
SUPPLICANT_SERVICE, /* bus name */
params->object_path, /* object path */
NULL, /* cancellable */
&error); /* error */
- if(error != NULL) {
- WDP_LOGE("Error! Failed to call method: [%s]",error->message);
+ if (error != NULL) {
+ WDP_LOGE("Error! Failed to call method: [%s]", error->message);
g_error_free(error);
- if(reply)
+ if (reply)
g_variant_unref(reply);
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- if(reply != NULL) {
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+ if (reply != NULL) {
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(reply);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
- if(function)
+ if (function)
function(reply, user_data);
g_variant_unref(reply);
} else {
gchar *key = NULL;
GVariant *value = NULL;
- while(g_variant_iter_loop(iter, "{sv}", &key, &value)) {
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
if (key) {
if (strcmp(key, "Properties") == 0) {
}
}
}
- if(function)
+ if (function)
function(NULL, NULL, user_data);
__WDP_LOG_FUNC_EXIT__;
return;
}
param = g_variant_new("(s)", interface);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(param);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
- reply = g_dbus_connection_call_sync (
+ reply = g_dbus_connection_call_sync(
connection,
SUPPLICANT_SERVICE, /* bus name */
path, /* object path */
NULL, /* cancellable */
&error); /* error */
- if(error != NULL) {
+ if (error != NULL) {
WDP_LOGE("Error! Failed to get properties: [%s]", error->message);
g_error_free(error);
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- if(reply != NULL) {
+ if (reply != NULL) {
g_variant_get(reply, "(a{sv})", &iter);
- if(iter != NULL){
+ if (iter != NULL) {
gchar *key = NULL;
GVariant *value = NULL;
- while(g_variant_iter_loop(iter, "{sv}", &key, &value)) {
+ while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
- if(strcmp(key, "Properties") == 0){
+ if (strcmp(key, "Properties") == 0) {
GVariantIter *iter_raw = NULL;
g_variant_get(value, "a{sv}", &iter_raw);
dbus_property_foreach(iter_raw, function, user_data);
} else{
WDP_LOGD("No properties");
}
- if(function)
+ if (function)
function(NULL, NULL, user_data);
__WDP_LOG_FUNC_EXIT__;
return 0;
#define SIGNAL_PROPERTIES_CHANGED "PropertiesChanged"
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
#define DEBUG_PARAMS(parameters) \
do {\
gchar *parameters_debug_str = NULL;\
WDP_LOGD("Key : [%s]", key);\
if (value) {\
DEBUG_PARAMS(value);\
- }\
+ } \
} while (0)
#define DEBUG_SIGNAL(sender_name, object_path, interface_name, signal_name, parameters)\
char object_path[DBUS_OBJECT_PATH_MAX];
char method_name[DBUS_METHOD_NAME_MAX];
GVariant *params;
-}dbus_method_param_s;
+} dbus_method_param_s;
int dbus_set_method_param(dbus_method_param_s *params, char *method_name,
char *object_path, GDBusConnection *connection);
void dbus_property_foreach(GVariantIter *iter,
dbus_property_function function, void *user_data);
-#endif //WFD_PLUGIN_SUPPLICANT_DBUS_H
+#endif /* WFD_PLUGIN_SUPPLICANT_DBUS_H */
#define CONF_FILE_PATH "/etc/wpa_supplicant/wpa_supplicant.conf"
-#if defined (TIZEN_MOBILE) || defined (TIZEN_COMMON)
+#if defined(TIZEN_MOBILE) || defined(TIZEN_COMMON)
#define COMMON_IFACE_NAME "wlan0"
# if defined TIZEN_WLAN_BOARD_SPRD
* obtained from the Registrar (via a display or other out-of-band
* method). This value may be further augmented with the optional
* "Identity" attribute in M1. */
- WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED = 0x0005, // ENTER-PIN
+ WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED = 0x0005, /* ENTER-PIN */
#if defined(TIZEN_FEATURE_ASP)
WS_DEV_PASSWD_ID_P2PS = 0x0008,
} ws_network_info_s;
typedef struct {
- int initialized; // check whether plugin is initialized or not. block init function if initialized
+ int initialized; /* check whether plugin is initialized or not. block init function if initialized */
int activated;
int concurrent;
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path,'/');
- if(loc != NULL)
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, dev_addr);
return -1;
}
- while (g_variant_iter_loop (iter, "y", &dst[length])) {
+ while (g_variant_iter_loop(iter, "y", &dst[length])) {
length++;
- if(length >= size)
+ if (length >= size)
break;
}
g_variant_iter_free(iter);
#ifdef TIZEN_FEATURE_WIFI_DISPLAY
static int __parsing_wfd_info(unsigned char *wfd_dev_info,
- wfd_oem_display_s *display )
+ wfd_oem_display_s* display)
{
__WDP_LOG_FUNC_ENTER__;
WDP_LOGD("type [%d],availability [%d],hdcp_support [%d],ctrl_port [%d] "
"max_tput[%d]", display->type, display->availability,
- display->hdcp_support, display->port,display->max_tput);
+ display->hdcp_support, display->port, display->max_tput);
__WDP_LOG_FUNC_EXIT__;
return 0;
errno = 0;
fd = fopen(file_path, "r");
if (!fd) {
- WDP_LOGE("Failed to open MAC info file [%s] (%s)",file_path, strerror(errno));
+ WDP_LOGE("Failed to open MAC info file [%s] (%s)", file_path, strerror(errno));
__WDP_LOG_FUNC_EXIT__;
return -1;
}
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return;
}
- if (!g_strcmp0(signal,"InterfaceAdded")) {
+ if (!g_strcmp0(signal, "InterfaceAdded")) {
WDP_LOGD("InterfaceAdded");
- } else if (!g_strcmp0(signal,"InterfaceRemoved")) {
+ } else if (!g_strcmp0(signal, "InterfaceRemoved")) {
WDP_LOGD("InterfaceRemoved");
static char interface_path[DBUS_OBJECT_PATH_MAX] = {'\0',};
const char *path = NULL;
memset(g_pd->iface_path, 0x0, DBUS_OBJECT_PATH_MAX);
}
#endif /* TIZEN_WLAN_CONCURRENT_ENABLE && TIZEN_MOBILE */
- } else if(!g_strcmp0(signal,"PropertiesChanged")){
+ } else if (!g_strcmp0(signal, "PropertiesChanged")) {
WDP_LOGD("PropertiesChanged");
}
}
__WDP_LOG_FUNC_ENTER__;
wfd_oem_device_s *peer = (wfd_oem_device_s *)user_data;
- if(!peer) {
+ if (!peer) {
__WDP_LOG_FUNC_EXIT__;
return;
}
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
} else if (g_strcmp0(key, "PrimaryDeviceType") == 0) {
unsigned char primarydevicetype[WS_DEVTYPE_LEN] = {0,};
- if(__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
+ if (__ws_unpack_ay(primarydevicetype, value, WS_DEVTYPE_LEN)) {
peer->pri_dev_type = primarydevicetype[1];
peer->sec_dev_type = primarydevicetype[WS_DEVTYPE_LEN -1];
}
} else if (g_strcmp0(key, "IEs") == 0) {
unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
- if(__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
+ if (__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
__parsing_wfd_info(ies, &(peer->display));
#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
} else if (g_strcmp0(key, "DeviceAddress") == 0) {
if (__ws_unpack_ay(peer->go_dev_addr, value, WS_MACADDR_LEN))
WDP_LOGD("GODevice address [" MACSTR "]", MAC2STR(peer->go_dev_addr));
- if(!ISZEROMACADDR(peer->go_dev_addr))
+ if (!ISZEROMACADDR(peer->go_dev_addr))
peer->dev_role = WFD_OEM_DEV_ROLE_GC;
} else {
WDP_LOGD("Unknown value");
static void __ws_peer_property(const char *key, GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
- if(!user_data) {
+ if (!user_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
wfd_oem_dev_data_s *peer = (wfd_oem_dev_data_s *)user_data;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "DeviceName") == 0) {
} else if (g_strcmp0(key, "IEs") == 0) {
unsigned char ies[WFD_SUBELEM_LEN_DEV_INFO + 3] = {0,};
- if(__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
+ if (__ws_unpack_ay(ies, value, WFD_SUBELEM_LEN_DEV_INFO + 3))
__parsing_wfd_info(ies, &(peer->display));
#endif /* TIZEN_FEATURE_WIFI_DISPLAY */
} else if (g_strcmp0(key, "DeviceAddress") == 0) {
if (__ws_unpack_ay(go_dev_addr, value, WS_MACADDR_LEN))
WDP_LOGD("[" MACSTR "]", MAC2STR(go_dev_addr));
- if(!ISZEROMACADDR(go_dev_addr))
+ if (!ISZEROMACADDR(go_dev_addr))
peer->dev_role = WFD_OEM_DEV_ROLE_GC;
#if defined(TIZEN_FEATURE_ASP)
} else if (g_strcmp0(key, "AdvertiseService") == 0) {
WDP_LOGD("size [%d]", g_variant_get_size(value));
- if (g_variant_get_size(value) != 0) {
+ if (g_variant_get_size(value) != 0)
peer->has_asp_services = 1;
- } else {
+ else
peer->has_asp_services = 0;
- }
+
#endif /* TIZEN_FEATURE_ASP */
} else {
WDP_LOGD("Unknown value");
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event)
+ if (!event)
return;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "Ifname") == 0) {
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "Role") == 0) {
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
wfd_oem_invite_data_s *invitation = (wfd_oem_invite_data_s *)event->edata;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "sa") == 0) {
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
if (!g_pd) {
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
wfd_oem_group_data_s *group = (wfd_oem_group_data_s *)event->edata;
#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "interface_object") == 0) {
event->dev_role = WFD_OEM_DEV_ROLE_GC;
} else if (g_strcmp0(key, "persistent") == 0) {
g_variant_get(value, "b", &group->is_persistent);
- WDP_LOGD("Is Persistent : [%s]", group->is_persistent?"YES":"NO");
+ WDP_LOGD("Is Persistent : [%s]", group->is_persistent ? "YES" : "NO");
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
} else if (g_strcmp0(key, "IpAddr") == 0) {
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
wfd_oem_conn_data_s *conn = (wfd_oem_conn_data_s *)event->edata;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "peer_object") == 0) {
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
wfd_oem_conn_data_s *edata = (wfd_oem_conn_data_s *)event->edata;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "peer_object") == 0) {
} else if (g_strcmp0(key, "passphrase") == 0) {
} else if (g_strcmp0(key, "role_go") == 0) {
- //local device role
+ /* local device role */
const char *role = NULL;
g_variant_get(value, "&s", &role);
} else if (g_strcmp0(key, "peer_device_addr") == 0) {
- if(__ws_unpack_ay(edata->peer_device_addr, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(edata->peer_device_addr, value, WS_MACADDR_LEN))
WDP_LOGD("Device address[" MACSTR "]", MAC2STR(edata->peer_device_addr));
- } else if(g_strcmp0(key, "peer_interface_addr") == 0) {
+ } else if (g_strcmp0(key, "peer_interface_addr") == 0) {
- if(__ws_unpack_ay(edata->peer_intf_addr, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(edata->peer_intf_addr, value, WS_MACADDR_LEN))
WDP_LOGD("Interface address [" MACSTR "]", MAC2STR(edata->peer_intf_addr));
} else if (g_strcmp0(key, "wps_method") == 0) {
int length = 0;
int res = 0;
- while(ptr + 2 < WS_MAX_SERVICE_LEN &&
+ while (ptr + 2 < WS_MAX_SERVICE_LEN &&
(length = (service_hex[ptr+1]*256) + service_hex[ptr]) > 0) {
segment = (char*) g_try_malloc0(length*2+1);
- if(segment) {
+ if (segment) {
__ws_byte_to_hex(segment, length * 2 + 1, &service_hex[ptr + 3], length);
res = __ws_segment_to_service(segment, &new_service);
if (res < 0) {
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event)
+ if (!event)
return;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "peer_object") == 0) {
char *loc = NULL;
g_variant_get(value, "&o", &path);
- if(path == NULL)
+ if (path == NULL)
return;
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
- if(loc != NULL)
+ loc = strrchr(path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
}
memset(service_hex, 0x0, WS_MAX_SERVICE_LEN);
- while (g_variant_iter_loop (iter, "y", &service_hex[byte_length]))
+ while (g_variant_iter_loop(iter, "y", &service_hex[byte_length]))
byte_length++;
g_variant_iter_free(iter);
{
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
- if(!event || !event->edata)
+ if (!event || !event->edata)
return;
wfd_oem_asp_service_s *service = (wfd_oem_asp_service_s *)event->edata;
char *loc = NULL;
g_variant_get(value, "o", &path);
- if(path == NULL)
+ if (path == NULL)
return;
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
- if(loc != NULL)
+ loc = strrchr(path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
} else if (g_strcmp0(key, "svc_str") == 0) {
const char *svc_str = NULL;
g_variant_get(value, "s", &svc_str);
- if(svc_str != NULL)
+ if (svc_str != NULL)
service->service_type = g_strdup(svc_str);
WDP_LOGD("Retrive srv_name [%s]", service->service_type);
} else if (g_strcmp0(key, "info") == 0) {
const char *info = NULL;
g_variant_get(value, "s", &info);
- if(info != NULL)
+ if (info != NULL)
service->service_info = g_strdup(info);
WDP_LOGD("Retrive srv_info [%s]", service->service_info);
}
}
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
+ loc = strrchr(path, '/');
if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
WDP_LOGD("Retrive conncap [%x]", asp_params->network_role);
} else if (g_strcmp0(key, "adv_mac") == 0) {
- if(__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
WDP_LOGD("Adv address[" MACSTR "]", MAC2STR(asp_params->service_mac));
} else if (g_strcmp0(key, "ses_mac") == 0) {
- if(__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
WDP_LOGD("session address[" MACSTR "]", MAC2STR(asp_params->session_mac));
} else if (g_strcmp0(key, "session_info") == 0) {
}
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
+ loc = strrchr(path, '/');
if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
WDP_LOGD("Retrive persist [%u]", asp_params->persistent_group_id);
} else if (g_strcmp0(key, "adv_mac") == 0) {
- if(__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(asp_params->service_mac, value, WS_MACADDR_LEN))
WDP_LOGD("Adv address[" MACSTR "]", MAC2STR(asp_params->service_mac));
} else if (g_strcmp0(key, "ses_mac") == 0) {
- if(__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(asp_params->session_mac, value, WS_MACADDR_LEN))
WDP_LOGD("session address[" MACSTR "]", MAC2STR(asp_params->session_mac));
} else if (g_strcmp0(key, "group_mac") == 0) {
- if(__ws_unpack_ay(asp_params->group_mac, value, WS_MACADDR_LEN))
+ if (__ws_unpack_ay(asp_params->group_mac, value, WS_MACADDR_LEN))
WDP_LOGD("group address[" MACSTR "]", MAC2STR(asp_params->group_mac));
}
__WDP_LOG_FUNC_EXIT__;
__WDP_LOG_FUNC_ENTER__;
wfd_oem_event_s *event = (wfd_oem_event_s *)user_data;
wfd_oem_asp_prov_s *asp_params = NULL;
- if(!event || !event->edata) {
+ if (!event || !event->edata) {
__WDP_LOG_FUNC_EXIT__;
return;
}
}
WDP_LOGD("Retrive Added path [%s]", path);
- loc = strrchr(path,'/');
+ loc = strrchr(path, '/');
if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event->dev_addr);
} else if (g_strcmp0(key, "deferred_session_resp") == 0) {
const char *session_info = NULL;
g_variant_get(value, "&s", &session_info);
- if(session_info != NULL)
+ if (session_info != NULL)
asp_params->session_information = g_strdup(session_info);
WDP_LOGD("Retrive deferred_session_resp [%s]", asp_params->session_information);
}
}
param = g_variant_new("(ss)", SUPPLICANT_P2P_PEER, "AdvertiseService");
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(param);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
- reply = g_dbus_connection_call_sync (
+ reply = g_dbus_connection_call_sync(
g_dbus,
SUPPLICANT_SERVICE, /* bus name */
peer_path, /* object path */
NULL, /* cancellable */
&error); /* error */
- if(error != NULL) {
+ if (error != NULL) {
WDP_LOGE("Error! Failed to get peer advertise service: [%s]",
error->message);
g_error_free(error);
- if(reply)
+ if (reply)
g_variant_unref(reply);
__WDP_LOG_FUNC_EXIT__;
return -1;
if (reply != NULL) {
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(reply);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
while (1) {
/* 4byte advertisement ID, 2 byte config method, 1byte length */
+
cnt = 0;
memset(desc, 0x0, 7);
- while (cnt < 7 && g_variant_iter_loop (iter, "y", &desc[cnt])) {
+ while (cnt < 7 && g_variant_iter_loop(iter, "y", &desc[cnt]))
cnt++;
- }
if (cnt != 7 || desc[6] == 0) {
WDP_LOGE("Invalid descriptor header length cnt [%d]", cnt);
WDP_LOGD("adv_id[%u] config_method[%u] length[%hhu]", adv_id, config_method, length);
cnt = 0;
- while (cnt < length && g_variant_iter_loop (iter, "y", &value[cnt])) {
+ while (cnt < length && g_variant_iter_loop(iter, "y", &value[cnt]))
cnt++;
- }
if (cnt != length) {
WDP_LOGE("Length doesn't matched with header value cnt [%d]", cnt);
seek = NULL;
}
GLIST_ITER_END()
- if(seek != NULL && seek->service_info != NULL) {
+ if (seek != NULL && seek->service_info != NULL) {
WDP_LOGD("service info exists, service discovery will be performed");
} else {
WDP_LOGD("service info doesn't exists. Add service to list");
__ws_peer_property, event.edata);
#if defined(TIZEN_FEATURE_ASP)
- if(edata->has_asp_services)
+ if (edata->has_asp_services)
ws_get_advertise_service(peer_path, (GList **)&(event.asp_services));
#endif /* TIZEN_FEATURE_ASP */
g_pd->callback(g_pd->user_data, &event);
#if defined(TIZEN_FEATURE_ASP)
- if(event.asp_services != NULL) {
+ if (event.asp_services != NULL) {
GList *l;
wfd_oem_advertise_service_s *service;
- for(l = (GList *)event.asp_services; l != NULL; l = l->next) {
+ for (l = (GList *)event.asp_services; l != NULL; l = l->next) {
service = (wfd_oem_advertise_service_s *)l->data;
g_free(service->service_type);
g_free(service);
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path,'/');
- if(loc != NULL)
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event.dev_addr);
WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path,'/');
- if(loc != NULL)
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event.dev_addr);
WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
WDP_LOGD("Retrive Added path [%s]", peer_path);
WDP_LOGD("Retrive Failure stateus [%d]", prov_status);
- loc = strrchr(peer_path,'/');
- if(loc != NULL)
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event.dev_addr);
WDP_LOGE("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
event.edata_type = WFD_OEM_EDATA_TYPE_GROUP;
event.event_id = WFD_OEM_EVENT_GROUP_CREATED;
- if(parameters != NULL){
+ if (parameters != NULL) {
g_variant_get(parameters, "(a{sv})", &iter);
if (iter != NULL) {
event.edata_type = WFD_OEM_EDATA_TYPE_CONN;
event.event_id = WFD_OEM_EVENT_GO_NEG_DONE;
- if (parameters != NULL){
+ if (parameters != NULL) {
g_variant_get(parameters, "(a{sv})", &iter);
if (iter != NULL) {
event.wps_mode = WFD_OEM_WPS_MODE_NONE;
edata->device_go_intent = device_go_intent;
- loc = strrchr(peer_path,'/');
- if(loc != NULL)
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, event.dev_addr);
WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(event.dev_addr));
wfd_oem_event_s event;
memset(&event, 0x0, sizeof(wfd_oem_event_s));
-// g_pd->callback(g_pd->user_data, event);
-
__WDP_LOG_FUNC_EXIT__;
}
event.event_id = WFD_OEM_EVENT_SERV_DISC_RESP;
- if(parameters != NULL) {
+ if (parameters != NULL) {
g_variant_get(parameters, "(a{sv})", &iter);
- if(iter != NULL) {
+ if (iter != NULL) {
dbus_property_foreach(iter, __ws_extract_servicediscoveryresponse_details, &event);
event.edata_type = WFD_OEM_EDATA_TYPE_NEW_SERVICE;
g_variant_iter_free(iter);
event.edata_type = WFD_OEM_EDATA_TYPE_ASP_SERVICE;
event.event_id = WFD_OEM_EVENT_ASP_SERV_RESP;
- if(parameters != NULL) {
+ if (parameters != NULL) {
g_variant_get(parameters, "(a{sv})", &iter);
- if(iter != NULL) {
+ if (iter != NULL) {
dbus_property_foreach(iter, __ws_extract_serviceaspresponse_details, &event);
g_variant_iter_free(iter);
}
WDP_LOGE("No Properties");
}
GLIST_ITER_START(seek_list, tmp)
- if(tmp->tran_id == service->tran_id) {
+ if (tmp->tran_id == service->tran_id) {
WDP_LOGD("srv_trans_id matched [%d] search_id [%llu]"
- ,tmp->tran_id, tmp->search_id);
+ , tmp->tran_id, tmp->search_id);
service->search_id = tmp->search_id;
break;
} else {
}
GLIST_ITER_END()
- if(tmp->service_info != NULL)
+ if (tmp->service_info != NULL)
g_pd->callback(g_pd->user_data, &event);
else
WDP_LOGD("service info is not required, don't notify to user");
wfd_oem_event_s event;
memset(&event, 0x0, sizeof(wfd_oem_event_s));
-// g_pd->callback(g_pd->user_data, &event);
-
__WDP_LOG_FUNC_EXIT__;
}
wfd_oem_event_s event;
memset(&event, 0x0, sizeof(wfd_oem_event_s));
-// g_pd->callback(g_pd->user_data, &event);
-
__WDP_LOG_FUNC_EXIT__;
}
GVariant *value = NULL;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
}
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
CHECK_KEY_VALUE(key, value);
- if(g_strcmp0(key, "sa") == 0)
+ if (g_strcmp0(key, "sa") == 0)
if (__ws_unpack_ay(event.dev_addr, value, WS_MACADDR_LEN))
WDP_LOGI("[" MACSTR "]", MAC2STR(event.dev_addr));
}
static struct {
const char *interface;
const char *member;
- void (*function) (GDBusConnection *connection,const gchar *object_path,
+ void (*function) (GDBusConnection *connection, const gchar *object_path,
GVariant *parameters);
} ws_p2pdevice_signal_map[] = {
{
const gchar *signal, GVariant *parameters, gpointer user_data)
{
int i = 0;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
static struct {
const char *interface;
const char *member;
- void (*function) (GDBusConnection *connection,const gchar *object_path,
+ void (*function) (GDBusConnection *connection, const gchar *object_path,
GVariant *parameters);
} ws_interface_signal_map[] = {
{
const gchar *signal, GVariant *parameters, gpointer user_data)
{
int i = 0;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
g_strlcpy(peer_path, path, DBUS_OBJECT_PATH_MAX);
WDP_LOGD("Retrive Added path [%s]", peer_path);
- loc = strrchr(peer_path,'/');
- if(loc != NULL)
+ loc = strrchr(peer_path, '/');
+ if (loc != NULL)
__ws_mac_compact_to_normal(loc + 1, peer_dev);
__ws_txt_to_mac(peer_dev, dev_addr);
WDP_LOGD("peer mac [" MACSTR "]", MAC2STR(dev_addr));
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- for(i = 0; i < OEM_IPADDR_LEN; i++)
- g_variant_iter_loop (iter, "y", &ip_addr[i]);
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
+ g_variant_iter_loop(iter, "y", &ip_addr[i]);
g_variant_iter_free(iter);
WDP_LOGD("peer ip [" IPSTR "]", IP2STR(ip_addr));
const gchar *sender, const gchar *object_path, const gchar *interface,
const gchar *signal, GVariant *parameters, gpointer user_data)
{
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_SIGNAL(sender, object_path, interface, signal, parameters);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return;
}
- if (!g_strcmp0(signal,"PeerJoined")) {
+ if (!g_strcmp0(signal, "PeerJoined")) {
wfd_oem_event_s event;
wfd_oem_dev_data_s *edata = NULL;
g_free(edata);
- } else if (!g_strcmp0(signal,"PeerDisconnected")) {
+ } else if (!g_strcmp0(signal, "PeerDisconnected")) {
wfd_oem_event_s event;
dbus_set_method_param(¶ms, "CreateInterface", SUPPLICANT_PATH, g_dbus);
- builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}"));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "Ifname", g_variant_new_string(iface_name));
g_variant_builder_add(builder, "{sv}", "ConfigFile", g_variant_new_string(CONF_FILE_PATH));
params.params = g_variant_new("(a{sv})", builder);
SUPPLICANT_PATH, g_pd->g_dbus);
params.params = g_variant_new("(s)", iface_name);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return res;
}
-#if defined (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
+#if defined(TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
static void __ws_remove_interface(GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
if (conn == NULL) {
- if(error != NULL){
+ if (error != NULL) {
WDP_LOGE("Error! Failed to connect to the D-BUS daemon: [%s]",
error->message);
g_error_free(error);
G_DBUS_SIGNAL_FLAGS_NONE,
_supplicant_signal_cb,
NULL, NULL);
-#if defined (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
- if(_ws_get_interface(COMMON_IFACE_NAME, NULL, NULL) < 0)
+#if defined(TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
+ if (_ws_get_interface(COMMON_IFACE_NAME, NULL, NULL) < 0)
_ws_create_interface(COMMON_IFACE_NAME, NULL, NULL);
- if(_ws_get_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
+ if (_ws_get_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
res = _ws_create_interface(P2P_IFACE_NAME, __register_p2pdevice_signal, NULL);
#else /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
- if(_ws_get_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
+ if (_ws_get_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL) < 0)
res = _ws_create_interface(COMMON_IFACE_NAME, __register_p2pdevice_signal, NULL);
#endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
_ws_reset_plugin(g_pd);
errno = 0;
- g_pd = (ws_dbus_plugin_data_s*) g_try_malloc0 (sizeof(ws_dbus_plugin_data_s));
+ g_pd = (ws_dbus_plugin_data_s*) g_try_malloc0(sizeof(ws_dbus_plugin_data_s));
if (!g_pd) {
WDP_LOGE("Failed to allocate memory for plugin data. [%s]", strerror(errno));
return -1;
} else if (pid > 0) {
if (waitpid(pid, &rv, 0) == -1)
WDP_LOGD("wait pid (%u) rv (%d)", pid, rv);
- if (WIFEXITED(rv)) {
+ if (WIFEXITED(rv))
WDP_LOGD("exited, rv=%d", WEXITSTATUS(rv));
- } else if (WIFSIGNALED(rv)) {
+ else if (WIFSIGNALED(rv))
WDP_LOGD("killed by signal %d", WTERMSIG(rv));
- } else if (WIFSTOPPED(rv)) {
+ else if (WIFSTOPPED(rv))
WDP_LOGD("stopped by signal %d", WSTOPSIG(rv));
- } else if (WIFCONTINUED(rv)) {
+ else if (WIFCONTINUED(rv))
WDP_LOGD("continued");
- }
return TRUE;
}
const char *path = "/usr/bin/wlan.sh";
char *const args[] = { "/usr/bin/wlan.sh", "stop", NULL };
char *const envs[] = { NULL };
-
rv = _ws_util_execute_file(path, args, envs);
if (rv < 0)
return -1;
NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
if (dbus_error_is_set(&error) == TRUE) {
if (NULL != strstr(error.message, ".AlreadyExists")) {
- // p2p already enabled
+ /* p2p already enabled */
} else {
WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
"DBus error [%s: %s]", error.name, error.message);
NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
if (dbus_error_is_set(&error) == TRUE) {
if (NULL != strstr(error.message, ".AlreadyExists")) {
- // p2p already disabled
+ /* p2p already disabled */
} else {
WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
"DBus error [%s: %s]", error.name, error.message);
if (!g_pd) {
WDP_LOGE("ws_dbus_plugin_data_s is not created yet");
return -1;
- }
+ }
- for(i = 0; i < WS_DEVTYPE_LEN; i++)
+ for (i = 0; i < WS_DEVTYPE_LEN; i++)
WDP_LOGD("device type[%02x]", primary_device_type[i]);
g_dbus = g_pd->g_dbus;
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "DeviceName",
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "DeviceName",
g_variant_new_string(DEFAULT_DEVICE_NAME));
- g_variant_builder_add (builder, "{sv}", "GOIntent",
+ g_variant_builder_add(builder, "{sv}", "GOIntent",
g_variant_new_uint32(DEFAULT_GO_INTENT));
- g_variant_builder_add (builder, "{sv}", "PersistentReconnect",
+ g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
g_variant_new_boolean(DEFAULT_PERSISTENT_RECONNECT));
- g_variant_builder_add (builder, "{sv}", "ListenRegClass",
+ g_variant_builder_add(builder, "{sv}", "ListenRegClass",
g_variant_new_uint32(DEFAULT_LISTEN_REG_CLASS));
- g_variant_builder_add (builder, "{sv}", "ListenChannel",
+ g_variant_builder_add(builder, "{sv}", "ListenChannel",
g_variant_new_uint32(DEFAULT_LISTEN_CHANNEL));
- g_variant_builder_add (builder, "{sv}", "OperRegClass",
+ g_variant_builder_add(builder, "{sv}", "OperRegClass",
g_variant_new_uint32(DEFAULT_OPER_REG_CLASS));
- g_variant_builder_add (builder, "{sv}", "OperChannel",
+ g_variant_builder_add(builder, "{sv}", "OperChannel",
g_variant_new_uint32(DEFAULT_OPER_CHANNEL));
- g_variant_builder_add (builder, "{sv}", "SsidPostfix",
+ g_variant_builder_add(builder, "{sv}", "SsidPostfix",
g_variant_new_string(DEFAULT_DEVICE_NAME));
- g_variant_builder_add (builder, "{sv}", "NoGroupIface",
+ g_variant_builder_add(builder, "{sv}", "NoGroupIface",
g_variant_new_boolean(DEFAULT_NO_GROUP_IFACE));
- type_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < WS_DEVTYPE_LEN; i++)
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < WS_DEVTYPE_LEN; i++)
g_variant_builder_add(type_builder, "y", primary_device_type[i]);
- g_variant_builder_add (builder, "{sv}", "PrimaryDeviceType",
- g_variant_new ("ay", type_builder));
- g_variant_builder_unref (type_builder);
+ g_variant_builder_add(builder, "{sv}", "PrimaryDeviceType",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- type_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < OEM_IPADDR_LEN; i++)
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
g_variant_builder_add(type_builder, "y", ip_addr_go[i]);
- g_variant_builder_add (builder, "{sv}", "IpAddrGO",
- g_variant_new ("ay", type_builder));
- g_variant_builder_unref (type_builder);
+ g_variant_builder_add(builder, "{sv}", "IpAddrGO",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
- type_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < OEM_IPADDR_LEN; i++)
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
g_variant_builder_add(type_builder, "y", ip_addr_mask[i]);
- g_variant_builder_add (builder, "{sv}", "IpAddrMask",
- g_variant_new ("ay", type_builder));
- g_variant_builder_unref (type_builder);
+ g_variant_builder_add(builder, "{sv}", "IpAddrMask",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
- type_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < OEM_IPADDR_LEN; i++)
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
g_variant_builder_add(type_builder, "y", ip_addr_start[i]);
- g_variant_builder_add (builder, "{sv}", "IpAddrStart",
- g_variant_new ("ay", type_builder));
- g_variant_builder_unref (type_builder);
+ g_variant_builder_add(builder, "{sv}", "IpAddrStart",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
- type_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < OEM_IPADDR_LEN; i++)
+ type_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < OEM_IPADDR_LEN; i++)
g_variant_builder_add(type_builder, "y", ip_addr_end[i]);
- g_variant_builder_add (builder, "{sv}", "IpAddrEnd",
- g_variant_new ("ay", type_builder));
- g_variant_builder_unref (type_builder);
+ g_variant_builder_add(builder, "{sv}", "IpAddrEnd",
+ g_variant_new("ay", type_builder));
+ g_variant_builder_unref(type_builder);
#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
#ifndef TIZEN_WIFI_MODULE_BUNDLE
while (retry_count < WS_CONN_RETRY_COUNT) {
/* load wlan driver */
- if(concurrent == 0)
+ if (concurrent == 0)
res = __ws_p2p_firmware_start();
if (res < 0) {
WDP_LOGE("Failed to load driver [ret=%d]", res);
WDP_LOGI("P2P firmware started with error %d", res);
if (__ws_check_net_interface(COMMON_IFACE_NAME) < 0) {
- usleep(150000); // wait for 150ms
+ usleep(150000); /* wait for 150ms */
concurrent = 0;
retry_count++;
WDP_LOGE("interface is not up: retry, %d", retry_count);
return -1;
}
if (retry_count > 0) {
- // Give driver marginal time to config net
+ /* Give driver marginal time to config net */
WDP_LOGE("Driver loading is done. Wait marginal time for driver");
- sleep(1); // 1s
+ sleep(1); /* 1s */
}
g_pd->concurrent = concurrent;
ws_stop_scan();
g_pd->concurrent = concurrent;
-#if defined (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
+#if defined(TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD)
_ws_get_interface(P2P_IFACE_NAME, __ws_remove_interface, NULL);
- if(concurrent == 0)
+ if (concurrent == 0)
_ws_get_interface(COMMON_IFACE_NAME, __ws_remove_interface, NULL);
#endif /* (TIZEN_MOBILE) && (TIZEN_WLAN_BOARD_SPRD) */
_ws_deinit_dbus_connection();
- if(concurrent == 0) {
+ if (concurrent == 0) {
res = __ws_p2p_supplicant_stop();
WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
#ifndef TIZEN_WIFI_MODULE_BUNDLE
int len = 0;
int i = 0;
- if(seek_list == NULL || g_list_length(seek_list) == 0) {
+ if (seek_list == NULL || g_list_length(seek_list) == 0) {
WDP_LOGD("seek list is NULL");
return;
}
len = strlen(data->service_type) + 1;
WDP_LOGD("data [%s] len [%d]", data->service_type, len);
inner = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for(i = 0; i < len; i++)
+ for (i = 0; i < len; i++)
g_variant_builder_add(inner, "y", data->service_type[i]);
g_variant_builder_add(outter, "ay", inner);
g_variant_builder_unref(inner);
}
GLIST_ITER_END()
- g_variant_builder_add (builder, "{sv}", "Seek", g_variant_new ("aay", outter));
+ g_variant_builder_add(builder, "{sv}", "Seek", g_variant_new("aay", outter));
g_variant_builder_unref(outter);
return;
dbus_set_method_param(¶ms, "Find", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
if (param->scan_time)
- g_variant_builder_add (builder, "{sv}", "Timeout",
+ g_variant_builder_add(builder, "{sv}", "Timeout",
g_variant_new_int32(param->scan_time));
if (param->scan_type == WFD_OEM_SCAN_TYPE_SOCIAL)
- g_variant_builder_add (builder, "{sv}", "DiscoveryType",
+ g_variant_builder_add(builder, "{sv}", "DiscoveryType",
g_variant_new_string("social"));
#if defined(TIZEN_FEATURE_ASP)
- if(seek_list != NULL)
+ if (seek_list != NULL)
__ws_add_seek_params(builder);
#endif /* TIZEN_FEATURE_ASP */
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
} else {
dbus_set_method_param(¶ms, "Listen", g_pd->iface_path, g_dbus);
- value = g_variant_new ("(i)", param->scan_time);
+ value = g_variant_new("(i)", param->scan_time);
}
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, "Find", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "Timeout", g_variant_new_int32(2));
- g_variant_builder_add (builder, "{sv}", "DiscoveryType",
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "Timeout", g_variant_new_int32(2));
+ g_variant_builder_add(builder, "{sv}", "DiscoveryType",
g_variant_new_string("social"));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
WDP_LOGD("get peer path [%s]", peer_path);
- value = g_variant_new ("(os)", peer_path, __ws_wps_to_txt(wps_mode));
+ value = g_variant_new("(os)", peer_path, __ws_wps_to_txt(wps_mode));
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
WDP_LOGD("get peer path [%s]", peer_path);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
if (param->conn_flags & WFD_OEM_CONN_TYPE_PERSISTENT)
- g_variant_builder_add (builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
+ g_variant_builder_add(builder, "{sv}", "persistent", g_variant_new_boolean(TRUE));
if (param->conn_flags & WFD_OEM_CONN_TYPE_JOIN)
- g_variant_builder_add (builder, "{sv}", "join", g_variant_new_boolean(TRUE));
+ g_variant_builder_add(builder, "{sv}", "join", g_variant_new_boolean(TRUE));
- if (param->conn_flags& WFD_OEM_CONN_TYPE_AUTH)
- g_variant_builder_add (builder, "{sv}", "autorize_only", g_variant_new_boolean(TRUE));
+ if (param->conn_flags & WFD_OEM_CONN_TYPE_AUTH)
+ g_variant_builder_add(builder, "{sv}", "autorize_only", g_variant_new_boolean(TRUE));
if (param->wps_pin[0] != '\0')
- g_variant_builder_add (builder, "{sv}", "pin", g_variant_new_string(param->wps_pin));
+ g_variant_builder_add(builder, "{sv}", "pin", g_variant_new_string(param->wps_pin));
- g_variant_builder_add (builder, "{sv}", "wps_method",
+ g_variant_builder_add(builder, "{sv}", "wps_method",
g_variant_new_string(__ws_wps_to_txt(param->wps_mode)));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "RemoveClient", g_pd->iface_path ,g_dbus);
+ dbus_set_method_param(¶ms, "RemoveClient", g_pd->iface_path, g_dbus);
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
WDP_LOGE("get peer path [%s]", peer_path);
- value = g_variant_new ("(oi)", peer_path, 0);
+ value = g_variant_new("(oi)", peer_path, 0);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "RejectPeer", g_pd->iface_path ,g_dbus);
+ dbus_set_method_param(¶ms, "RejectPeer", g_pd->iface_path, g_dbus);
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
WDP_LOGE("get peer path [%s]", peer_path);
- value = g_variant_new ("(o)", peer_path);
+ value = g_variant_new("(o)", peer_path);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
}
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
- dbus_set_method_param(¶ms, "GeneratePin", g_pd->iface_path ,g_dbus);
+ dbus_set_method_param(¶ms, "GeneratePin", g_pd->iface_path, g_dbus);
params.params = NULL;
res = dbus_method_call(¶ms, SUPPLICANT_WPS, __ws_get_pin, (void *)n_pin);
WDP_LOGD("Persistent Group Count=%d", persistent_group_count);
for (counter = 0; counter < persistent_group_count ; counter++) {
- if(!memcmp(go_dev_mac, plist[counter].go_mac_address, WS_MACADDR_LEN)) {
+ if (!memcmp(go_dev_mac, plist[counter].go_mac_address, WS_MACADDR_LEN)) {
*persistent_network_id = plist[counter].network_id;
break;
} else {
return 0;
}
-static void __store_group_iface_path(GVariant *value, void *user_data) {
+static void __store_group_iface_path(GVariant* value, void* user_data)
+{
__WDP_LOG_FUNC_ENTER__;
ws_dbus_plugin_data_s * pd_data;
const char *path = NULL;
dbus_set_method_param(¶ms, "GroupAdd", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
if (param->persistent > 0) {
unsigned char mac_address[WS_MACADDR_LEN] = {0x00, };
}
res = _ws_get_persistent_net_id(&persistent_group_id, mac_address);
- if(res < 0) {
+ if (res < 0) {
WDP_LOGE("failed to get persistent group ID");
__WDP_LOG_FUNC_EXIT__;
return -1;
g_variant_builder_add(builder, "{sv}", "persistent",
g_variant_new_boolean(TRUE));
- if(persistent_group_id > -1) {
+ if (persistent_group_id > -1) {
g_snprintf(persistent_group_obj_path, OBJECT_PATH_MAX,
"%s/" SUPPLICANT_PERSISTENT_GROUPS_PART "/%d",
g_pd->iface_path, persistent_group_id);
g_variant_builder_add(builder, "{sv}", "frequency",
g_variant_new_int32(param->freq));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(peer_addr));
WDP_LOGE("get peer path [%s]", peer_path);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return 0;
}
-// Only group owner can use this command
+/* Only group owner can use this command */
int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
{
__WDP_LOG_FUNC_ENTER__;
dbus_set_method_param(¶ms, "Start", g_pd->group_iface_path, g_dbus);
if (peer_addr != NULL) {
- builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < WS_MACADDR_LEN; i++)
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < WS_MACADDR_LEN; i++)
g_variant_builder_add(builder, "y", peer_addr[i]);
- dev_addr = g_variant_new ("ay", builder);
- g_variant_builder_unref (builder);
+ dev_addr = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
}
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "Role", g_variant_new_string("enrollee"));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "Role", g_variant_new_string("enrollee"));
if (peer_addr != NULL)
- g_variant_builder_add (builder, "{sv}", "P2PDeviceAddress", dev_addr);
+ g_variant_builder_add(builder, "{sv}", "P2PDeviceAddress", dev_addr);
if (pin != NULL && pin[0] != '\0') {
- g_variant_builder_add (builder, "{sv}", "Type", g_variant_new_string("pin"));
- g_variant_builder_add (builder, "{sv}", "Pin", g_variant_new_string(pin));
+ g_variant_builder_add(builder, "{sv}", "Type", g_variant_new_string("pin"));
+ g_variant_builder_add(builder, "{sv}", "Pin", g_variant_new_string(pin));
} else {
- g_variant_builder_add (builder, "{sv}", "Type", g_variant_new_string("pbc"));
+ g_variant_builder_add(builder, "{sv}", "Type", g_variant_new_string("pbc"));
}
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "DeviceName",
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "DeviceName",
g_variant_new_string(dev_name));
- g_variant_builder_add (builder, "{sv}", "SsidPostfix",
+ g_variant_builder_add(builder, "{sv}", "SsidPostfix",
g_variant_new_string(dev_name));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE,
"P2PDeviceConfig", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
}
param = g_variant_new("(ss)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig");
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(param);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
- reply = g_dbus_connection_call_sync (
+ reply = g_dbus_connection_call_sync(
g_dbus,
SUPPLICANT_SERVICE, /* bus name */
g_pd->iface_path, /* object path */
NULL, /* cancellable */
&error); /* error */
- if(error != NULL) {
+ if (error != NULL) {
WDP_LOGE("Error! Failed to get interface State: [%s]",
error->message);
g_error_free(error);
- if(reply)
+ if (reply)
g_variant_unref(reply);
__WDP_LOG_FUNC_EXIT__;
return -1;
GVariant *value = NULL;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
- if(g_strcmp0(key, "GOIntent") == 0)
+ if (g_strcmp0(key, "GOIntent") == 0)
g_variant_get(value, "u", go_intent);
}
g_variant_iter_free(iter);
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "GOIntent",
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "GOIntent",
g_variant_new_uint32(go_intent));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
param = g_variant_new("(ssv)", SUPPLICANT_IFACE, "Country", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return res;
}
-void __parsing_networks (const char *key, GVariant *value, void *user_data)
+void __parsing_networks(const char* key, GVariant* value, void* user_data)
{
__WDP_LOG_FUNC_ENTER__;
- if(!user_data) {
+ if (!user_data) {
__WDP_LOG_FUNC_EXIT__;
return;
}
ws_network_info_s *network = (ws_network_info_s *)user_data;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "ssid") == 0) {
void __ws_extract_p2pdevice_details(const char *key, GVariant *value, void *user_data)
{
__WDP_LOG_FUNC_ENTER__;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
CHECK_KEY_VALUE(key, value);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
if (g_strcmp0(key, "PersistentGroups") == 0) {
ws_network_info_s *networks = NULL;
networks = (ws_network_info_s *)user_data;
- if(!networks) {
+ if (!networks) {
WDP_LOGE("network is NULL");
__WDP_LOG_FUNC_EXIT__;
return;
}
g_variant_get(value, "ao", &iter);
- while(g_variant_iter_loop(iter, "&o", &path)) {
+ while (g_variant_iter_loop(iter, "&o", &path)) {
char *loc = NULL;
- if(num >= WS_MAX_PERSISTENT_COUNT)
+ if (num >= WS_MAX_PERSISTENT_COUNT)
break;
WDP_LOGD("Retrive persistent path [%s]", path);
return -1;
}
- if(cnt == 0) {
+ if (cnt == 0) {
WDP_LOGE("Persistent group count zero");
*group_count = 0;
*groups = NULL;
WDP_LOGD("ssid [%s]", networks[i].ssid);
WDP_LOGD("bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
WDP_LOGD("p2p_client_num [%d]", networks[i].p2p_client_num);
- for(j = 0; j < networks[i].p2p_client_num; j++)
+ for (j = 0; j < networks[i].p2p_client_num; j++)
WDP_LOGD("p2p_client_list ["MACSTR"]", MAC2STR(networks[i].p2p_client_list[j]));
wfd_persistent_groups[i].network_id = networks[i].network_id;
WDP_LOGD("network ssid [%s]", networks[i].ssid);
WDP_LOGD("network bssid ["MACSTR"]", MAC2STR(networks[i].bssid));
WDP_LOGD("network p2p_client_num [%d]", networks[i].p2p_client_num);
- for(j = 0; j < networks[i].p2p_client_num; j++)
+ for (j = 0; j < networks[i].p2p_client_num; j++)
WDP_LOGD("network p2p_client_list ["MACSTR"]",
MAC2STR(networks[i].p2p_client_list[j]));
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
dbus_set_method_param(¶ms, "RemovePersistentGroup",
g_pd->iface_path, g_dbus);
- params.params = g_variant_new ("(o)", networks[i].persistent_path);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+ params.params = g_variant_new("(o)", networks[i].persistent_path);
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path,
g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "PersistentReconnect",
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "PersistentReconnect",
g_variant_new_boolean(reconnect));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
} else if (!strncmp(token, "_tcp", 4)) {
memcpy(&compressed[length], WS_TCP_PTR_HEX, 2);
- length+=2;
+ length += 2;
} else if (!strncmp(token, "_udp", 4)) {
memcpy(&compressed[length], WS_UDP_PTR_HEX, 2);
- length+=2;
+ length += 2;
} else {
WDP_LOGD("Token: [%s]", token);
length++;
memcpy(&compressed[length], token, token_len);
- length+=token_len;
+ length += token_len;
}
token_num++;
token = strtok_r(NULL, ".", &temp);
}
- if(qtype == WS_QTYPE_PTR || token_num == 2) {
+ if (qtype == WS_QTYPE_PTR || token_num == 2)
memcpy(&compressed[length], WS_PTR_TYPE_HEX, 3);
- } else if (qtype == WS_QTYPE_TXT || token_num == 3) {
+ else if (qtype == WS_QTYPE_TXT || token_num == 3)
memcpy(&compressed[length], WS_TXT_TYPE_HEX, 3);
- }
- length+=3;
+
+ length += 3;
WDP_LOGD("converted query length [%d] token num [%d]", length, token_num);
return length;
length++;
memcpy(&compressed[length], token, token_len);
- length+=token_len;
+ length += token_len;
}
compressed[length] = 0xc0;
compressed[length+1] = 0x27;
- length+=2;
+ length += 2;
} else if (qtype == WS_QTYPE_TXT) {
- token = strtok_r(rdata, ",", &temp);
+ token = strtok_r(rdata, ", ", &temp);
while (token) {
WDP_LOGD("Token: [%s]", token);
length++;
memcpy(&compressed[length], token, token_len);
- length+=token_len;
+ length += token_len;
- token = strtok_r(NULL, ",", &temp);
+ token = strtok_r(NULL, ", ", &temp);
}
} else {
WDP_LOGD("RDATA is NULL");
} else {
temp = strstr(rdata, query);
- if(temp != NULL && temp - rdata > 0)
+ if (temp != NULL && temp - rdata > 0)
qtype = WS_QTYPE_PTR;
else
qtype = WS_QTYPE_TXT;
temp = NULL;
}
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("bonjour"));
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("bonjour"));
/* compress query */
length = __ws_compress_query(compressed, query, qtype);
- args = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
+ args = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < length; i++)
g_variant_builder_add(args, "y", compressed[i]);
- g_variant_builder_add(builder, "{sv}", "query", g_variant_new ("ay", args));
- g_variant_builder_unref (args);
+ g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", args));
+ g_variant_builder_unref(args);
memset(compressed, 0x0, 256);
length = 0;
args = NULL;
- if(qtype != 0) {
+ if (qtype != 0) {
length = __ws_compress_rdata(compressed, rdata, qtype);
- args = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
+ args = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < length; i++)
g_variant_builder_add(args, "y", compressed[i]);
- g_variant_builder_add(builder, "{sv}", "response", g_variant_new ("ay", args));
- g_variant_builder_unref (args);
+ g_variant_builder_add(builder, "{sv}", "response", g_variant_new("ay", args));
+ g_variant_builder_unref(args);
}
return 0;
int count = 0;
wfd_oem_service_s *data = NULL;
- for (count = 0; count < g_list_length(service_list); count ++) {
+ for (count = 0; count < g_list_length(service_list); count++) {
data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
if (strncmp(service->query_id, data->query_id, OEM_QUERY_ID_LEN) == 0) {
WDP_LOGD("Query already exists");
int count = 0;
wfd_oem_service_s *data = NULL;
- for (count = 0; count < g_list_length(service_list); count ++) {
+ for (count = 0; count < g_list_length(service_list); count++) {
data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
if (data && !strncmp(data->service_type, s_type, SERVICE_TYPE_LEN) &&
memcmp(data->dev_addr, mac_str, OEM_MACSTR_LEN - 1) == 0) {
return NULL;
}
- WDP_LOGD("query id :[0x%s]",query_id);
+ WDP_LOGD("query id :[0x%s]", query_id);
return data;
}
g_snprintf(service->query_id, OEM_QUERY_ID_LEN + 1, "0x%llx", ref);
res = _check_service_query_exists(service);
- if(res) {
+ if (res)
free(service);
- } else {
+ else
service_list = g_list_append(service_list, service);
- }
__WDP_LOG_FUNC_EXIT__;
return;
int i = 0;
int res = 0;
- if (!mac_addr ) {
+ if (!mac_addr) {
WDP_LOGE("Invalid parameter");
__WDP_LOG_FUNC_EXIT__;
return -1;
dbus_set_method_param(¶ms, "ServiceDiscoveryRequest", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- if(mac_addr) {
+ if (mac_addr) {
g_snprintf(peer_path, DBUS_OBJECT_PATH_MAX, "%s/Peers/"
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(mac_addr));
WDP_LOGD("get peer path [%s]", peer_path);
- g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
}
if (service_type == WFD_OEM_SERVICE_TYPE_ALL) {
char *service_all = "\x02\x00\x00\x01";
GVariantBuilder *query = NULL;
- query = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
+ query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < SERVICE_QUERY_LEN; i++)
g_variant_builder_add(query, "y", service_all[i]);
- g_variant_builder_add (builder, "{sv}", "query", g_variant_new ("ay", query));
- g_variant_builder_unref (query);
+ g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
+ g_variant_builder_unref(query);
} else if (service_type == WFD_OEM_SERVICE_TYPE_UPNP) {
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
} else if (service_type == WFD_OEM_SERVICE_TYPE_BONJOUR) {
char *service_bonjour = "\x02\x00\x01\x01";
GVariantBuilder *query = NULL;
- query = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
+ query = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < SERVICE_QUERY_LEN; i++)
g_variant_builder_add(query, "y", service_bonjour[i]);
- g_variant_builder_add (builder, "{sv}", "query", g_variant_new ("ay", query));
- g_variant_builder_unref (query);
+ g_variant_builder_add(builder, "{sv}", "query", g_variant_new("ay", query));
+ g_variant_builder_unref(query);
}
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_method_param_s params;
wfd_oem_service_s *data = NULL;
char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
- char s_type[OEM_SERVICE_TYPE_LEN + 1] ={0, };
+ char s_type[OEM_SERVICE_TYPE_LEN + 1] = {0, };
char mac_str[18] = {0, };
int res = 0;
- if (!mac_addr ) {
+ if (!mac_addr) {
WDP_LOGE("Invalid parameter");
__WDP_LOG_FUNC_EXIT__;
return -1;
snprintf(mac_str, WS_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
}
- switch(service_type) {
- case WFD_OEM_SERVICE_TYPE_ALL:
- strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
- break;
- case WFD_OEM_SERVICE_TYPE_BONJOUR:
- strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
- break;
- case WFD_OEM_SERVICE_TYPE_UPNP:
- strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
- break;
- default:
- WDP_LOGE("Invalid Service type");
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ switch (service_type) {
+ case WFD_OEM_SERVICE_TYPE_ALL:
+ strncpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN);
+ break;
+ case WFD_OEM_SERVICE_TYPE_BONJOUR:
+ strncpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN);
+ break;
+ case WFD_OEM_SERVICE_TYPE_UPNP:
+ strncpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN);
+ break;
+ default:
+ WDP_LOGE("Invalid Service type");
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
WDP_LOGD("Cancel service discovery service_type [%d]", service_type);
dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest", g_pd->iface_path, g_dbus);
- params.params = g_variant_new ("(t)", strtoul(query_id, NULL, 16));
+ params.params = g_variant_new("(t)", strtoul(query_id, NULL, 16));
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
if (res < 0)
dbus_set_method_param(¶ms, "AddService", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
service->data.bonjour.rdata, builder);
if (res < 0) {
WDP_LOGE("Failed to convert Key string");
- g_variant_builder_unref (builder);
+ g_variant_builder_unref(builder);
return -1;
}
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
- g_variant_builder_add (builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, "DeleteService", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
NULL, builder);
if (res < 0) {
WDP_LOGE("Failed to convert Key string");
- g_variant_builder_unref (builder);
+ g_variant_builder_unref(builder);
return -1;
}
} else if (service->protocol == WFD_OEM_SERVICE_TYPE_UPNP) {
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("upnp"));
- g_variant_builder_add (builder, "{sv}", "version", g_variant_new_uint16(TRUE));
- g_variant_builder_add (builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("upnp"));
+ g_variant_builder_add(builder, "{sv}", "version", g_variant_new_uint16(TRUE));
+ g_variant_builder_add(builder, "{sv}", "service", g_variant_new_string(service->data.upnp.service));
}
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
params.params = value;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, SUPPLICANT_PATH,
g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- value = g_variant_new ("ay", builder);
- g_variant_builder_unref (builder);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ value = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return -1;
}
- if(!enable) {
+ if (!enable) {
res = _ws_disable_display();
if (res < 0)
WDP_LOGE("Failed to disable wifi display");
ies[7] = wifi_display->max_tput>>8;
ies[8] = wifi_display->max_tput&0xff;
- builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
- for(i = 0; i < WFD_SUBELEM_LEN_DEV_INFO + 3; i++)
+ builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
+ for (i = 0; i < WFD_SUBELEM_LEN_DEV_INFO + 3; i++)
g_variant_builder_add(builder, "y", ies[i]);
- value = g_variant_new ("ay", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("ay", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_INTERFACE, "WFDIEs", value);
params.params = param;
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
DEBUG_PARAMS(params.params);
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, DBUS_PROPERTIES_METHOD_SET, g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "OperChannel", g_variant_new_uint32(channel));
- value = g_variant_new ("a{sv}", builder);
- g_variant_builder_unref (builder);
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "OperChannel", g_variant_new_uint32(channel));
+ value = g_variant_new("a{sv}", builder);
+ g_variant_builder_unref(builder);
param = g_variant_new("(ssv)", SUPPLICANT_P2PDEVICE, "P2PDeviceConfig", value);
params.params = param;
param = g_variant_new("(s)", SUPPLICANT_IFACE);
- reply = g_dbus_connection_call_sync (
+ reply = g_dbus_connection_call_sync(
g_pd->g_dbus,
SUPPLICANT_SERVICE, /* bus name */
g_pd->iface_path, /* object path */
NULL, /* cancellable */
&error); /* error */
- if(error != NULL) {
+ if (error != NULL) {
WDP_LOGE("Error! Failed to get properties: [%s]",
error->message);
g_error_free(error);
WDP_LOGE("reply [%s]", reply_str ? reply_str : "NULL");
g_free(reply_str);
- if(reply != NULL) {
+ if (reply != NULL) {
GVariantIter *iter = NULL;
g_variant_get(reply, "(a{sv})", &iter);
GVariant *value = NULL;
while (g_variant_iter_loop(iter, "{sv}", &key, &value)) {
- if(g_strcmp0(key, "State") == 0) {
+ if (g_strcmp0(key, "State") == 0) {
const gchar *state = NULL;
g_variant_get(value, "&s", &state);
WDP_LOGI("state : [%s]", state);
config_method = WS_CONFIG_METHOD_KEYPAD;
}
- if(service->auto_accept) {
- if(service->role == 0)
+ if (service->auto_accept) {
+ if (service->role == 0)
auto_accept = 1;
else
auto_accept = 2;
dbus_set_method_param(¶ms, "AddService", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
-
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("asp"));
- g_variant_builder_add (builder, "{sv}", "auto_accept", g_variant_new_int32(auto_accept));
- g_variant_builder_add (builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
- g_variant_builder_add (builder, "{sv}", "svc_state", g_variant_new_uint32(service->status));
- g_variant_builder_add (builder, "{sv}", "config_method", g_variant_new_uint32(config_method));
- g_variant_builder_add (builder, "{sv}", "replace", g_variant_new_boolean(rep));
- if(service->service_type != NULL)
- g_variant_builder_add (builder, "{sv}", "adv_str", g_variant_new_string(service->service_type));
- if(service->service_info != NULL)
- g_variant_builder_add (builder, "{sv}", "svc_info", g_variant_new_string(service->service_info));
-
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("asp"));
+ g_variant_builder_add(builder, "{sv}", "auto_accept", g_variant_new_int32(auto_accept));
+ g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
+ g_variant_builder_add(builder, "{sv}", "svc_state", g_variant_new_uint32(service->status));
+ g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new_uint32(config_method));
+ g_variant_builder_add(builder, "{sv}", "replace", g_variant_new_boolean(rep));
+ if (service->service_type != NULL)
+ g_variant_builder_add(builder, "{sv}", "adv_str", g_variant_new_string(service->service_type));
+ if (service->service_info != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_info", g_variant_new_string(service->service_info));
+
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
WDP_LOGE("params [%s]", g_variant_print(value, TRUE));
#endif /* TIZEN_DEBUG_DBUS_VALUE */
dbus_set_method_param(¶ms, "DeleteService", g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}"));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "service_type", g_variant_new_string("asp"));
- g_variant_builder_add (builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
+ g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new_string("asp"));
+ g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(service->adv_id));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
#endif /* TIZEN_DEBUG_DBUS_VALUE */
params.params = value;
service->search_id = (intptr_t)seek;
memcpy(seek, service, sizeof(wfd_oem_asp_service_s));
- if(service->service_type)
+ if (service->service_type)
seek->service_type = strdup(service->service_type);
seek_list = g_list_prepend(seek_list, seek);
wfd_oem_asp_service_s *seek = NULL;
GList *list = NULL;
- for(list = seek_list; list != NULL; list = list->next) {
+ for (list = seek_list; list != NULL; list = list->next) {
seek = list->data;
- if(seek && (seek->search_id == search_id)) {
+ if (seek && (seek->search_id == search_id)) {
WDP_LOGD("List found");
break;
} else {
wfd_oem_asp_service_s *seek = NULL;
GList *list = NULL;
- for(list = seek_list; list != NULL; list = list->next) {
+ for (list = seek_list; list != NULL; list = list->next) {
seek = list->data;
if (seek && (seek->search_id == service->search_id)) {
service->search_id = search_id;
memcpy(seek, service, sizeof(wfd_oem_asp_service_s));
- if(service->service_type)
+ if (service->service_type)
seek->service_type = strdup(service->service_type);
- if(service->service_info)
+ if (service->service_info)
seek->service_info = strdup(service->service_info);
seek_list = g_list_append(seek_list, seek);
return -1;
}
list = g_list_last(seek_list);
- if(list == NULL) {
+ if (list == NULL) {
service->tran_id = 1;
} else {
seek = list->data;
- if(seek)
+ if (seek)
service->tran_id = seek->tran_id + 1;
else
service->tran_id = 1;
}
- if(service->service_info) {
+ if (service->service_info) {
GVariantBuilder *builder = NULL;
GVariant *value = NULL;
dbus_method_param_s params;
dbus_set_method_param(¶ms, "ServiceDiscoveryRequest",
g_pd->iface_path, g_dbus);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
- g_variant_builder_add (builder, "{sv}", "service_type",
+ g_variant_builder_add(builder, "{sv}", "service_type",
g_variant_new_string("asp"));
- g_variant_builder_add (builder, "{sv}", "transaction_id",
+ g_variant_builder_add(builder, "{sv}", "transaction_id",
g_variant_new_byte(service->tran_id));
- if(service->service_type != NULL)
- g_variant_builder_add (builder, "{sv}", "svc_str",
+ if (service->service_type != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_str",
g_variant_new_string(service->service_type));
- if(service->service_info != NULL)
- g_variant_builder_add (builder, "{sv}", "svc_info",
+ if (service->service_info != NULL)
+ g_variant_builder_add(builder, "{sv}", "svc_info",
g_variant_new_string(service->service_info));
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
#endif /* TIZEN_DEBUG_DBUS_VALUE */
return -1;
}
- if(seek->service_info) {
+ if (seek->service_info) {
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
dbus_set_method_param(¶ms, "ServiceDiscoveryCancelRequest",
g_pd->iface_path, g_dbus);
- params.params = g_variant_new ("(t)", service->search_id);
+ params.params = g_variant_new("(t)", service->search_id);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
WDP_LOGD("params [%s]", g_variant_print(params.params, TRUE));
#endif /* TIZEN_DEBUG_DBUS_VALUE */
res = dbus_method_call(¶ms, SUPPLICANT_P2PDEVICE, NULL, NULL);
- if (res < 0) {
+ if (res < 0)
WDP_LOGE("Failed to send command to wpa_supplicant");
- } else {
+ else
WDP_LOGD("Succeeded to cancel seek service");
- }
}
- if(res == 0)
+ if (res == 0)
__ws_remove_seek(seek);
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- if(asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_DISPLAY)
+ if (asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_DISPLAY)
config_method = 0x8;
- else if(asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_KEYPAD)
+ else if (asp_params->network_config == WFD_OEM_ASP_WPS_TYPE_PIN_KEYPAD)
config_method = 0x100;
memset(¶ms, 0x0, sizeof(dbus_method_param_s));
COMPACT_MACSTR, g_pd->iface_path, MAC2STR(asp_params->service_mac));
WDP_LOGD("get peer path [%s]", peer_path);
- builder = g_variant_builder_new (G_VARIANT_TYPE ("a{sv}") );
- g_variant_builder_add (builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
+ g_variant_builder_add(builder, "{sv}", "peer", g_variant_new_object_path(peer_path));
- g_variant_builder_add (builder, "{sv}", "adv_id", g_variant_new_uint32(asp_params->adv_id));
- g_variant_builder_add (builder, "{sv}", "session_id", g_variant_new_uint32(asp_params->session_id));
- g_variant_builder_add (builder, "{sv}", "role", g_variant_new_byte(asp_params->network_role));
- g_variant_builder_add (builder, "{sv}", "method", g_variant_new_int32(config_method));
+ g_variant_builder_add(builder, "{sv}", "adv_id", g_variant_new_uint32(asp_params->adv_id));
+ g_variant_builder_add(builder, "{sv}", "session_id", g_variant_new_uint32(asp_params->session_id));
+ g_variant_builder_add(builder, "{sv}", "role", g_variant_new_byte(asp_params->network_role));
+ g_variant_builder_add(builder, "{sv}", "method", g_variant_new_int32(config_method));
if (asp_params->status > 0)
- g_variant_builder_add (builder, "{sv}", "status", g_variant_new_int32(asp_params->status));
+ g_variant_builder_add(builder, "{sv}", "status", g_variant_new_int32(asp_params->status));
if (asp_params->session_information)
- g_variant_builder_add (builder, "{sv}", "info", g_variant_new_string(asp_params->session_information));
+ g_variant_builder_add(builder, "{sv}", "info", g_variant_new_string(asp_params->session_information));
- mac_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
+ mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < OEM_MACADDR_LEN; i++)
g_variant_builder_add(mac_builder, "y", asp_params->service_mac[i]);
- g_variant_builder_add (builder, "{sv}", "adv_mac",
- g_variant_new ("ay", mac_builder));
- g_variant_builder_unref (mac_builder);
+ g_variant_builder_add(builder, "{sv}", "adv_mac",
+ g_variant_new("ay", mac_builder));
+ g_variant_builder_unref(mac_builder);
- mac_builder = g_variant_builder_new (G_VARIANT_TYPE ("ay"));
+ mac_builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
for (i = 0; i < OEM_MACADDR_LEN; i++)
g_variant_builder_add(mac_builder, "y", asp_params->session_mac[i]);
- g_variant_builder_add (builder, "{sv}", "session_mac",
- g_variant_new ("ay", mac_builder));
- g_variant_builder_unref (mac_builder);
+ g_variant_builder_add(builder, "{sv}", "session_mac",
+ g_variant_new("ay", mac_builder));
+ g_variant_builder_unref(mac_builder);
- value = g_variant_new ("(a{sv})", builder);
- g_variant_builder_unref (builder);
-#if defined (TIZEN_DEBUG_DBUS_VALUE)
+ value = g_variant_new("(a{sv})", builder);
+ g_variant_builder_unref(builder);
+#if defined(TIZEN_DEBUG_DBUS_VALUE)
WDP_LOGD("params [%s]", g_variant_print(value, TRUE));
#endif /* TIZEN_DEBUG_DBUS_VALUE */
WS_EVENT_FIND_STOPED,
WS_EVENT_PROV_DISC_PBC_REQ,
WS_EVENT_PROV_DISC_SHOW_PIN,
- WS_EVENT_PROV_DISC_ENTER_PIN, // 5
+ WS_EVENT_PROV_DISC_ENTER_PIN, /* 5 */
WS_EVENT_PROV_DISC_PBC_RESP,
WS_EVENT_PROV_DISC_FAILURE,
WS_EVENT_GO_NEG_REQUEST,
WS_EVENT_GO_NEG_FAILURE,
- WS_EVENT_GO_NEG_SUCCESS, // 10
+ WS_EVENT_GO_NEG_SUCCESS, /* 10*/
WS_EVENT_WPS_FAIL,
WS_EVENT_GROUP_FORMATION_FAILURE,
WS_EVENT_WPS_SUCCESS,
WS_EVENT_WPS_REG_SUCCESS,
- WS_EVENT_GROUP_FORMATION_SUCCESS, // 15
+ WS_EVENT_GROUP_FORMATION_SUCCESS, /* 15*/
WS_EVENT_STA_CONNECTED,
WS_EVENT_STA_DISCONNECTED,
- WS_EVENT_GROUP_STARTED,
+ WS_EVENT_GROUP_STARTED, /* 20 */
WS_EVENT_GROUP_REMOVED,
- WS_EVENT_TERMINATING, // 24
+ WS_EVENT_TERMINATING,
#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
WS_EVENT_SERV_DISC_RESP,
typedef enum {
WS_DEV_INFO_NONE = -1,
- WS_DEV_INFO_P2P_DEV_ADDR, // p2p_dev_addr=
- WS_DEV_INFO_DEV_NAME, // name=
- WS_DEV_INFO_DEV_TYPE, // pri_dev_type=
- WS_DEV_INFO_CONFIG_METHODS, // config_methods=
- WS_DEV_INFO_DEV_CAP, // dev_capab=
- WS_DEV_INFO_GROUP_CAP, // group_capab=
- WS_DEV_INFO_P2P_GO_ADDR, // p2p_go_addr=
+ WS_DEV_INFO_P2P_DEV_ADDR, /* p2p_dev_addr= */
+ WS_DEV_INFO_DEV_NAME, /* name= */
+ WS_DEV_INFO_DEV_TYPE, /* pri_dev_type= */
+ WS_DEV_INFO_CONFIG_METHODS, /* config_methods= */
+ WS_DEV_INFO_DEV_CAP, /* dev_capab= */
+ WS_DEV_INFO_GROUP_CAP, /* group_capab= */
+ WS_DEV_INFO_P2P_GO_ADDR, /* p2p_go_addr= */
#ifdef TIZEN_FEATURE_WIFI_DISPLAY
- WS_DEV_INFO_WFD_DEV_INFO, // wfd_dev_info=
+ WS_DEV_INFO_WFD_DEV_INFO, /* wfd_dev_info= */
#endif
WS_DEV_INFO_LIMIT,
} ws_dev_info_id_e;
typedef enum {
WS_CONN_INFO_NONE = -1,
- WS_CONN_INFO_DEV_PWD_ID, // dev_passwd_id=
- WS_CONN_INFO_STATUS, // status=
- WS_CONN_INFO_ERROR, // config_error=
+ WS_CONN_INFO_DEV_PWD_ID, /* dev_passwd_id= */
+ WS_CONN_INFO_STATUS, /* status= */
+ WS_CONN_INFO_ERROR, /* config_error= */
WS_CONN_INFO_LIMIT,
} ws_conn_info_id_e;
typedef enum {
WS_INVITE_INFO_NONE = -1,
- WS_INVITE_INFO_SRC_ADDR, // sa=
- WS_INVITE_INFO_GO_DEV_ADDR, // go_dev_addr=
- WS_INVITE_INFO_BSSID, // bssid=
- WS_INVITE_INFO_LISTEN, // listen=
- WS_INVITE_INFO_FREQ, // op_freq=
- WS_INVITE_INFO_PERSISTENT_ID, // persistent_id=
- WS_INVITE_INFO_STATUS, // status=
+ WS_INVITE_INFO_SRC_ADDR, /* sa= */
+ WS_INVITE_INFO_GO_DEV_ADDR, /* go_dev_addr= */
+ WS_INVITE_INFO_BSSID, /* bssid= */
+ WS_INVITE_INFO_LISTEN, /* listen= */
+ WS_INVITE_INFO_FREQ, /* op_freq= */
+ WS_INVITE_INFO_PERSISTENT_ID, /* persistent_id= */
+ WS_INVITE_INFO_STATUS, /* status= */
WS_INVITE_INFO_LIMIT,
} ws_invite_info_id_e;
typedef enum {
WS_GROUP_INFO_NONE = -1,
- WS_GROUP_INFO_SSID, // ssid=
- WS_GROUP_INFO_FREQ, // freq=
- WS_GROUP_INFO_PASS, // passphrase=
- WS_GROUP_INFO_GO_DEV_ADDR, // go_dev_addr=
- WS_GROUP_INFO_STATUS, // status=
- WS_GROUP_INFO_PERSISTENT, // [PERSISTENT]
+ WS_GROUP_INFO_SSID, /* ssid= */
+ WS_GROUP_INFO_FREQ, /* freq= */
+ WS_GROUP_INFO_PASS, /* passphrase= */
+ WS_GROUP_INFO_GO_DEV_ADDR, /* go_dev_addr= */
+ WS_GROUP_INFO_STATUS, /* status= */
+ WS_GROUP_INFO_PERSISTENT, /* [PERSISTENT] */
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
- WS_GROUP_INFO_IP_ADDR, //ip_addr=
- WS_GROUP_INFO_IP_MASK, //ip_mask=
- WS_GROUP_INFO_GO_IP_ADDR, //go_ip_addr=
+ WS_GROUP_INFO_IP_ADDR, /* ip_addr= */
+ WS_GROUP_INFO_IP_MASK, /* ip_mask= */
+ WS_GROUP_INFO_GO_IP_ADDR, /* go_ip_addr= */
#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
WS_GROUP_INFO_LIMIT,
} ws_group_info_id_e;
-enum
-{
+enum {
WS_PEER_INFO_NONE = -1,
WS_PEER_INFO_AGE,
* obtained from the Registrar (via a display or other out-of-band
* method). This value may be further augmented with the optional
* "Identity" attribute in M1. */
- WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED = 0x0005, // ENTER-PIN
+ WS_DEV_PASSWD_ID_REGISTRAR_SPECIFIED = 0x0005, /* ENTER-PIN */
} ws_dev_passwd_id_e;
typedef enum {
} ws_sock_data_s;
typedef struct {
- int initialized; // check whether plugin is initialized or not. block init function if initialized
+ int initialized; /* check whether plugin is initialized or not. block init function if initialized */
int activated;
int concurrent;
int global_sock;
#endif
ws_string_s ws_event_strs[] = {
- // discovery
+ /* discovery */
{"P2P-DEVICE-FOUND", WS_EVENT_DEVICE_FOUND},
{"P2P-DEVICE-LOST", WS_EVENT_DEVICE_LOST},
{"P2P-FIND-STOPPED", WS_EVENT_FIND_STOPED},
- // provision discovery
+ /* provision discovery */
{"P2P-PROV-DISC-PBC-REQ", WS_EVENT_PROV_DISC_PBC_REQ},
{"P2P-PROV-DISC-SHOW-PIN", WS_EVENT_PROV_DISC_SHOW_PIN},
{"P2P-PROV-DISC-ENTER-PIN", WS_EVENT_PROV_DISC_ENTER_PIN},
{"P2P-PROV-DISC-PBC-RESP", WS_EVENT_PROV_DISC_PBC_RESP},
{"P2P-PROV-DISC-FAILURE", WS_EVENT_PROV_DISC_FAILURE},
- // connection
+ /* connection */
{"P2P-GO-NEG-REQUEST", WS_EVENT_GO_NEG_REQUEST},
{"P2P: Received GO Negotiation Request from", WS_EVENT_GO_NEG_REQUEST},
{"P2P-GO-NEG-FAILURE", WS_EVENT_GO_NEG_FAILURE},
{"AP-STA-CONNECTED", WS_EVENT_STA_CONNECTED},
- // invite
+ /* invite */
{"P2P-INVITATION-RECEIVED", WS_EVENT_INVITATION_RECEIVED},
{"P2P-INVITATION-RESULT", WS_EVENT_INVITATION_RESULT},
{"AP-STA-DISCONNECTED", WS_EVENT_STA_DISCONNECTED},
- // group
+ /* group */
{"P2P-GROUP-STARTED", WS_EVENT_GROUP_STARTED},
{"P2P-GROUP-REMOVED", WS_EVENT_GROUP_REMOVED},
return -1;
}
- for (i=0; i<length/unit; i++)
- memcpy(dest + length - (i+1)*unit, src + i*unit, unit);
+ for (i = 0; i < (length / unit); i++)
+ memcpy(dest + length - (i + 1) * unit, src + (i * unit), unit);
return 0;
}
#if 0
static int _ws_hex_to_txt(char *src, int length, char *dest)
{
- // TODO: check it is good to change dest parameter as double pointer.
- // It could be better to allocate memory for dest parameter here.
char *temp = NULL;
char *ptr = NULL;
int len = 0;
return -1;
}
- // TODO: flush destination memory
-
ptr = src;
temp = dest;
else
len = length;
- for (i=0; i<len/2 && *ptr!=0; i++) {
+ for (i = 0; i < (len / 2) && *ptr != 0; i++) {
temp[i] = (char) _ws_hex_to_num(ptr, 2);
if (temp[i] < 0) {
WDP_LOGE("Failed to convert hexa string to num");
} else if (pid > 0) {
if (waitpid(pid, &rv, 0) == -1)
WDP_LOGD("wait pid (%u) rv (%d)", pid, rv);
- if (WIFEXITED(rv)) {
+ if (WIFEXITED(rv))
WDP_LOGD("exited, rv=%d", WEXITSTATUS(rv));
- } else if (WIFSIGNALED(rv)) {
+ else if (WIFSIGNALED(rv))
WDP_LOGD("killed by signal %d", WTERMSIG(rv));
- } else if (WIFSTOPPED(rv)) {
+ else if (WIFSTOPPED(rv))
WDP_LOGD("stopped by signal %d", WSTOPSIG(rv));
- } else if (WIFCONTINUED(rv)) {
+ else if (WIFCONTINUED(rv))
WDP_LOGD("continued");
- }
return TRUE;
}
WDP_LOGE("Polling error from socket[%d]. [%s]", sock, strerror(errno));
return -1;
} else if (res == 0) {
- WDP_LOGD( "poll timeout. socket is busy\n");
+ WDP_LOGD("poll timeout. socket is busy\n");
return 1;
} else {
int p_ret = 0;
int rbytes = 0;
- if(sock < SOCK_FD_MIN || !data || data_len <= 0) {
+ if (sock < SOCK_FD_MIN || !data || data_len <= 0) {
WDP_LOGE("Invalid parameter");
return -1;
}
{
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res = 0;
if (!sock) {
{
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res = 0;
if (!sock) {
int sock = 0;
int res = 0;
- if(!ctrl_intf_path || !supp_path) {
+ if (!ctrl_intf_path || !supp_path) {
WDP_LOGE("Invalid parameter");
return -1;
}
__WDP_LOG_FUNC_EXIT__;
return -1;
}
- WDP_LOGI( "Succeeded to create socket [%d]\n", sock);
+ WDP_LOGI("Succeeded to create socket [%d]\n", sock);
memset(&srv_addr, 0, sizeof(srv_addr));
srv_addr.sun_family = AF_UNIX;
snprintf(local_addr.sun_path, sizeof(local_addr.sun_path), "%s", ctrl_intf_path);
res = bind(sock, (struct sockaddr*) &local_addr, sizeof(local_addr));
- if (res < 0)
- {
+ if (res < 0) {
WDP_LOGE("Failed to bind local socket [%s]. Try again...", strerror(errno));
unlink(ctrl_intf_path);
{
__WDP_LOG_FUNC_ENTER__;
char cmd[8] = {0};
- char reply[8]={0,};
- int res= 0;
+ char reply[8] = {0,};
+ int res = 0;
if (sock < SOCK_FD_MIN) {
WDP_LOGE("Invalid parameter");
res = _ws_send_cmd(sock, cmd, reply, sizeof(reply));
if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
- __WDP_LOG_FUNC_EXIT__;
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
if (strstr(reply, "FAIL")) {
- WDP_LOGE( "Failed to operate command(wpa_supplicant)");
- __WDP_LOG_FUNC_EXIT__;
+ WDP_LOGE("Failed to operate command(wpa_supplicant)");
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
g_snprintf(suppl_path, sizeof(suppl_path), "%s%s", supp_group_iface_path, ifname);
- for(i = 0; i < WS_CONN_RETRY_COUNT; i++) {
+ for (i = 0; i < WS_CONN_RETRY_COUNT; i++) {
ctrl_sock = _create_ctrl_intf(ctrl_path, suppl_path);
if (ctrl_sock < SOCK_FD_MIN) {
WDP_LOGE("Failed to create control interface socket for %s", ifname);
return -1;
}
- // detach monitor interface
+ /* detach monitor interface */
g_snprintf(cmd, sizeof(cmd), WS_CMD_DETACH);
res = _ws_send_cmd(sock_data->mon_sock, cmd, reply, sizeof(reply));
if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant. Keep going to close socket.");
} else {
if (!strncmp(reply, "FAIL", 4)) {
- WDP_LOGE( "Failed to detach monitor sock [%d]", sock_data->mon_sock);
- // TODO: I think there is no need to exit
- __WDP_LOG_FUNC_EXIT__;
- return -1;
+ WDP_LOGE("Failed to detach monitor sock [%d]", sock_data->mon_sock);
+ /* TODO: I think there is no need to exit */
+ __WDP_LOG_FUNC_EXIT__;
+ return -1;
}
WDP_LOGD("Succeeded to detach monitor sock for %s", ifname ? ifname : "NULL");
}
g_idle_add(_remove_event_source, (gpointer) sock_data);
sock_data->gsource = 0;
- // close control interface
+ /* close control interface */
g_snprintf(ctrl_path, sizeof(ctrl_path), "/tmp/%s_control", ifname);
snprintf(mon_path, sizeof(mon_path), "/tmp/%s_monitor", ifname);
int count = 0;
wfd_oem_service_s *data = NULL;
- for (count = 0; count < g_list_length(service_list); count ++) {
+ for (count = 0; count < g_list_length(service_list); count++) {
data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
if (strncmp(service->query_id, data->query_id, OEM_QUERY_ID_LEN) == 0) {
WDP_LOGD("Query already exists");
int count = 0;
wfd_oem_service_s *data = NULL;
- for (count = 0; count < g_list_length(service_list); count ++) {
+ for (count = 0; count < g_list_length(service_list); count++) {
data = (wfd_oem_service_s*) g_list_nth_data(service_list, count);
if (data && !strncmp(data->service_type, s_type, SERVICE_TYPE_LEN) &&
memcmp(data->dev_addr, mac_str, OEM_MACSTR_LEN - 1) == 0) {
return NULL;
}
- WDP_LOGD("query id :[0x%s]",query_id);
+ WDP_LOGD("query id :[0x%s]", query_id);
return data;
{
int i = 0;
- if(!data || !value) {
+ if (!data || !value) {
WDP_LOGE("Invalid parameter");
return -1;
}
- for(i = 0; data[i]; i++) {
- if(data[i] == '\n' || data[i] == '\r' || data[i] == ' ' || data[i] == '\t') {
+ for (i = 0; data[i]; i++)
+ if (data[i] == '\n' || data[i] == '\r' || data[i] == ' ' || data[i] == '\t')
break;
- }
- }
if (i > 0) {
*value = (char*) g_try_malloc0(i + 1);
- if(!(*value)) {
+ if (!(*value)) {
WDP_LOGE("Failed to allocate memory for value");
return -1;
}
char *tmp_str = NULL;
int i = 0;
- if(!data || !key || !value) {
+ if (!data || !key || !value) {
WDP_LOGE("Invalid parameter");
return -1;
}
tmp_str = strstr(data, key);
- if(!tmp_str) {
+ if (!tmp_str) {
WDP_LOGE("Key[%s] is not found", key);
return -1;
}
tmp_str = tmp_str + strlen(key) + 1;
if (tmp_str[0] == '\'' || tmp_str[0] == '\"') {
- tmp_str +=1;
- for(i = 0; tmp_str[i]; i++) {
- if(tmp_str[i] == '\'' || tmp_str[i] == '\"')
+ tmp_str += 1;
+ for (i = 0; tmp_str[i]; i++) {
+ if (tmp_str[i] == '\'' || tmp_str[i] == '\"')
break;
}
} else {
- for(i = 0; tmp_str[i]; i++) {
- if(tmp_str[i] == '\n' || tmp_str[i] == '\r' || tmp_str[i] == ' ')
+ for (i = 0; tmp_str[i]; i++) {
+ if (tmp_str[i] == '\n' || tmp_str[i] == '\r' || tmp_str[i] == ' ')
break;
}
}
if (i > 0) {
*value = (char*) g_try_malloc0(i + 1);
- if(!(*value)) {
+ if (!(*value)) {
WDP_LOGE("Failed to allocate memory for value");
return -1;
}
char *tmp_str = NULL;
int i = 0;
- if(!data || !key || !value) {
+ if (!data || !key || !value) {
WDP_LOGE("Invalid parameter");
return -1;
}
tmp_str = strstr(data, key);
- if(!tmp_str) {
+ if (!tmp_str) {
WDP_LOGE("Key[%s] is not found", key);
return -1;
}
tmp_str = tmp_str + strlen(key) + 1;
- for(i = 0; tmp_str[i]; i++) {
- if(tmp_str[i] == '\n' || tmp_str[i] == '\r')
+ for (i = 0; tmp_str[i]; i++) {
+ if (tmp_str[i] == '\n' || tmp_str[i] == '\r')
break;
}
if (i > 0) {
*value = (char*) g_try_malloc0(i + 1);
- if(!(*value)) {
+ if (!(*value)) {
WDP_LOGE("Failed to allocate memory for value");
return -1;
}
#endif
#ifdef TIZEN_FEATURE_WIFI_DISPLAY
-static int _parsing_wfd_info(char *msg, wfd_oem_display_s *display )
+static int _parsing_wfd_info(char *msg, wfd_oem_display_s *display)
{
__WDP_LOG_FUNC_ENTER__;
display->max_tput = strtoul(max_tput_msg, NULL, 16);
WDP_LOGE("type [%d],availability [%d],hdcp_support [%d],ctrl_port [%d] max_tput[%d]",
- display->type,display->availability,display->hdcp_support,
- display->port,display->max_tput);
+ display->type, display->availability, display->hdcp_support,
+ display->port, display->max_tput);
__WDP_LOG_FUNC_EXIT__;
return 0;
}
for (i = 0; i < info_cnt; i++) {
- switch (infos[i].index){
+ switch (infos[i].index) {
case WS_PEER_INFO_AGE:
peer->age = (int) strtoul(infos[i].string, NULL, 10);
break;
break;
#ifdef TIZEN_FEATURE_WIFI_DISPLAY
case WS_PEER_INFO_WFD_SUBELEMS:
- res = _parsing_wfd_info(infos[i].string+6,&peer->display);
+ res = _parsing_wfd_info(infos[i].string+6, &peer->display);
if (res < 0)
memset(&peer->display, 0x00, sizeof(wfd_oem_display_s));
break;
}
}
- for(i = 0; i < info_cnt; i++) {
+ for (i = 0; i < info_cnt; i++) {
if (infos[i].string)
free(infos[i].string);
}
#ifdef TIZEN_FEATURE_WIFI_DISPLAY
case WS_DEV_INFO_WFD_DEV_INFO:
/* wfd_dev_info=0x00 0006 015d 022a0032 */
- res = _parsing_wfd_info(infos[i].string+2,&edata->display);
+ res = _parsing_wfd_info(infos[i].string+2, &edata->display);
if (res < 0)
memset(&edata->display, 0x00, sizeof(wfd_oem_display_s));
break;
break;
case WS_GROUP_INFO_PERSISTENT:
edata->is_persistent = TRUE;
- WDP_LOGD("Is Persistent : [%s]", edata->is_persistent?"YES":"NO");
+ WDP_LOGD("Is Persistent : [%s]", edata->is_persistent ? "YES" : "NO");
break;
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
case WS_GROUP_INFO_IP_ADDR:
WDP_LOGD("Extracted peer ip = %s", infos[i].string);
res = inet_aton(infos[i].string, (struct in_addr *)&addr);
- if(res == 1)
+ if (res == 1)
memcpy(&(edata->ip_addr), &addr, sizeof(edata->ip_addr));
break;
case WS_GROUP_INFO_IP_MASK:
WDP_LOGD("Extracted ip mask= %s", infos[i].string);
res = inet_aton(infos[i].string, (struct in_addr *)&addr);
- if(res == 1)
+ if (res == 1)
memcpy(&(edata->ip_addr_mask), &addr, sizeof(edata->ip_addr_mask));
break;
case WS_GROUP_INFO_GO_IP_ADDR:
WDP_LOGD("Extracted peer go ip = %s", infos[i].string);
res = inet_aton(infos[i].string, (struct in_addr *)&addr);
- if(res == 1)
+ if (res == 1)
memcpy(&(edata->ip_addr_go), &addr, sizeof(edata->ip_addr_go));
break;
#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
while (*ptr != 0 && strncmp(ptr, "c0", 2)) {
len = _ws_hex_to_num(ptr, 2);
- ptr +=2;
+ ptr += 2;
if (len) {
temp = (char*) g_try_malloc0(len + 2);
if (!temp) {
return -1;
}
temp[0] = '.';
- for (i=0; i<len; i++) {
+ for (i = 0; i < len; i++) {
temp[i+1] = (char) _ws_hex_to_num(ptr, 2);
ptr += 2;
}
return -1;
}
temp[0] = '.';
- for (i=0; i<len; i++) {
- temp[i+1] = (char) _ws_hex_to_num(ptr, 2);
+ for (i = 0; i < len; i++) {
+ temp[i + 1] = (char) _ws_hex_to_num(ptr, 2);
ptr += 2;
}
strncat(rdata, temp, len+1);
WDP_SECLOGD("Event message [%s]", msg);
/* parsing event string */
- for(i = 0; ws_event_strs[i].index < WS_EVENT_LIMIT; i++) {
- if (!strncmp(ws_event_strs[i].string, msg, strlen(ws_event_strs[i].string))) {
+ for (i = 0; ws_event_strs[i].index < WS_EVENT_LIMIT; i++) {
+ if (!strncmp(ws_event_strs[i].string, msg, strlen(ws_event_strs[i].string)))
break;
- }
}
if (i == sizeof(ws_event_strs)) {
info_str += OEM_PINSTR_LEN +1;
}
- WDP_LOGD("info string left [%s]", info_str ? info_str:"NULL");
+ WDP_LOGD("info string left [%s]", info_str ? info_str : "NULL");
data->edata_type = WFD_OEM_EDATA_TYPE_NONE;
}
break;
case WS_EVENT_PROV_DISC_FAILURE:
- case WS_EVENT_WPS_FAIL: // M_id(msg), error(config_error)
+ case WS_EVENT_WPS_FAIL: /* M_id(msg), error(config_error) */
break;
case WS_EVENT_GO_NEG_FAILURE:
{
data->edata = (void*) edata;
}
break;
- case WS_EVENT_GROUP_FORMATION_FAILURE: // No incofmation sring
+ case WS_EVENT_GROUP_FORMATION_FAILURE: /* No incofmation sring */
case WS_EVENT_GO_NEG_SUCCESS:
case WS_EVENT_WPS_SUCCESS:
case WS_EVENT_GROUP_FORMATION_SUCCESS:
/* No information string */
data->edata_type = WFD_OEM_EDATA_TYPE_NONE;
break;
- case WS_EVENT_WPS_REG_SUCCESS: // "intf_addr"
+ case WS_EVENT_WPS_REG_SUCCESS: /* "intf_addr" */
/* Interface address of peer will come up */
break;
- case WS_EVENT_STA_CONNECTED: // "intf_addr", dev_addr(dev_addr)
+ case WS_EVENT_STA_CONNECTED: /* "intf_addr", dev_addr(dev_addr) */
case WS_EVENT_STA_DISCONNECTED:
{
/* Interface address of connected peer will come up */
free(temp);
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
res = _extract_value_str(info_str, "ip_addr", &temp);
- if(res > 0 && temp) {
+ if (res > 0 && temp) {
unsigned int addr = 0;
WDP_LOGD("Extracted peer ip = %s", temp);
res = inet_aton(temp, (struct in_addr *)&addr);
- if(res == 1)
+ if (res == 1)
memcpy(&(data->ip_addr_peer), &addr, sizeof(data->ip_addr_peer));
}
#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
}
wfd_oem_group_data_s* edata = NULL;
- edata= _convert_msg_to_group_info(info_str);
+ edata = _convert_msg_to_group_info(info_str);
if (!edata) {
WDP_LOGE("Failed to convert information string to group data");
data->edata_type = WFD_OEM_EDATA_TYPE_NONE;
#ifdef TIZEN_FEATURE_SERVICE_DISCOVERY
case WS_EVENT_SERV_DISC_RESP:
{
- char mac_addr[OEM_MACSTR_LEN] ={0, };
+ char mac_addr[OEM_MACSTR_LEN] = {0, };
char *up_indic = NULL;
int len = 0;
int ret = 0;
g_snprintf(mac_addr, OEM_MACSTR_LEN, MACSTR, MAC2STR(data->dev_addr));
ret = _extract_word(info_str, &up_indic);
- if (ret < 0) {
+ if (ret < 0)
WDP_LOGE("_extract_word is failed");
- }
+
if (up_indic) {
WDP_LOGD("Update indicator: %s", up_indic);
info_str += strlen(up_indic) + 1;
if (!sd) {
WDP_LOGE("Invalid parameter");
- // TODO: if error count is more than 10, disconnect this interface and reset sock data
+ /* TODO: if error count is more than 10, disconnect this interface and reset sock data */
return FALSE;
}
return FALSE;
}
- if (res == 1) {
- // This means event->event_data is NULL
- }
+ if (res == 1)
+ WDP_LOGD("This means event->event_data is NULL");
/* Converting WS event to OEM event */
switch (event.event_id) {
case WS_EVENT_WPS_REG_SUCCESS:
case WS_EVENT_GROUP_FORMATION_SUCCESS:
event_id = WFD_OEM_EVENT_WPS_DONE;
- // TODO: connect to supplicant via group interface
+ /* TODO: connect to supplicant via group interface */
break;
case WS_EVENT_STA_CONNECTED:
event_id = WFD_OEM_EVENT_STA_CONNECTED;
res = _connect_to_supplicant(GROUP_IFACE_NAME, &g_pd->group);
if (res < 0) {
WDP_LOGE("Failed to connect to group interface of supplicant");
- // goto done;
+ /* goto done; */
}
break;
case WS_EVENT_GROUP_REMOVED:
res = _disconnect_from_supplicant(GROUP_IFACE_NAME, g_pd->group);
if (res < 0) {
WDP_LOGE("Failed to disconnect from group interface of supplicant");
- // goto done;
+ /* goto done; */
}
g_pd->group = NULL;
_ws_flush();
if (ioctl(fd, SIOCGIFFLAGS, &ifr) < 0) {
close(fd);
- WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s", strerror(errno)); // interface is not found..
+ WDP_LOGE("ioctl error: SIOCGIFFLAGS: %s", strerror(errno)); /* interface is not found.. */
return -3;
}
NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
if (dbus_error_is_set(&error) == TRUE) {
if (NULL != strstr(error.message, ".AlreadyExists")) {
- // p2p already enabled
+ /* p2p already enabled */
} else {
WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
"DBus error [%s: %s]", error.name, error.message);
NETCONFIG_DBUS_REPLY_TIMEOUT, &error);
if (dbus_error_is_set(&error) == TRUE) {
if (NULL != strstr(error.message, ".AlreadyExists")) {
- // p2p already disabled
+ /* p2p already disabled */
} else {
WDP_LOGE("dbus_connection_send_with_reply_and_block() failed. "
"DBus error [%s: %s]", error.name, error.message);
errno = 0;
fd = fopen(file_path, "r");
if (!fd) {
- WDP_LOGE("Failed to open MAC info file [%s] (%s)",file_path, strerror(errno));
+ WDP_LOGE("Failed to open MAC info file [%s] (%s)", file_path, strerror(errno));
__WDP_LOG_FUNC_EXIT__;
return -1;
}
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
WDP_LOGI("P2P firmware started with error %d", res);
if (__ws_check_net_interface(COMMON_IFACE_NAME) < 0) {
- usleep(150000); // wait for 150ms
+ usleep(150000); /* wait for 150ms */
retry_count++;
WDP_LOGE("interface is not up: retry, %d", retry_count);
} else {
return -1;
}
if (retry_count > 0) {
- // Give driver marginal time to config net
+ /* Give driver marginal time to config net */
WDP_LOGE("Driver loading is done. Wait marginal time for driver");
- sleep(1); // 1s
+ sleep(1); /* 1s */
}
g_pd->concurrent = concurrent;
{
__WDP_LOG_FUNC_ENTER__;
char cmd[32] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res = 0;
if (!g_pd->activated) {
g_pd->group = NULL;
}
- // terminate wpasupplicant
+ /* terminate wpasupplicant */
snprintf(cmd, sizeof(cmd), WS_CMD_TERMINATE);
res = _ws_send_cmd(g_pd->common->ctrl_sock, cmd, reply, sizeof(reply));
if (res < 0) {
}
if (!strncmp(reply, "FAIL", 4)) {
- WDP_LOGE( "Failed to terminate wpa_supplicant");
+ WDP_LOGE("Failed to terminate wpa_supplicant");
res = __ws_p2p_supplicant_stop();
WDP_LOGI("[/usr/sbin/p2p_supp.sh stop] returns %d", res);
goto done;
}
*peers = g_list_prepend(*peers, peer);
- } while(1);
+ } while (1);
__WDP_LOG_FUNC_EXIT__;
return 0;
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[64] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[64] = {0, };
- char freq_str[11] ={0, };
+ char freq_str[11] = {0, };
char reply[1024] = {0, };
int res = 0;
if (param->conn_flags & WFD_OEM_CONN_TYPE_JOIN)
strncat(cmd, WS_STR_JOIN, 5);
- else if (param->conn_flags& WFD_OEM_CONN_TYPE_AUTH)
+ else if (param->conn_flags & WFD_OEM_CONN_TYPE_AUTH)
strncat(cmd, WS_STR_AUTH, 5);
if (param->conn_flags & WFD_OEM_CONN_TYPE_PERSISTENT)
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[48] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!peer_addr) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[64] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
char cmd[44] = {0, };
char freq_str[11] = {0, };
char passphrase[21] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res = 0;
if (!sock) {
}
if (param->persistent) {
- if(param->persistent == 2)
+ if (param->persistent == 2)
snprintf(cmd, sizeof(cmd), WS_CMD_P2P_GROUP_ADD WS_STR_PERSISTENT "=%d",
param->persistent_group_id);
else
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[32] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res = 0;
if (!ifname) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[128] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res = 0;
if (!peer_addr || !param) {
return 0;
}
-// Only group owner can use this command
+/* Only group owner can use this command */
int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
{
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->group;
char cmd[40] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!peer_addr || !pin) {
else
g_snprintf(cmd, sizeof(cmd), WS_CMD_WPS_PIN MACSTR " %s", MAC2STR(peer_addr), pin);
- res = _ws_send_cmd(sock->ctrl_sock, cmd,reply, sizeof(reply));
+ res = _ws_send_cmd(sock->ctrl_sock, cmd, reply, sizeof(reply));
if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
__WDP_LOG_FUNC_EXIT__;
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->group;
char cmd[64] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!peer_addr || !pin) {
g_snprintf(cmd, sizeof(cmd), WS_CMD_WPS_ENROLLEE MACSTR " %s%s",
MAC2STR(peer_addr), pin, _ws_wps_to_txt(wps_mode));
- res = _ws_send_cmd(sock->ctrl_sock, cmd,reply, sizeof(reply));
+ res = _ws_send_cmd(sock->ctrl_sock, cmd, reply, sizeof(reply));
if (res < 0) {
WDP_LOGE("Failed to send command to wpa_supplicant");
__WDP_LOG_FUNC_EXIT__;
{
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->group;
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[128] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!dev_name || !strlen(dev_name)) {
- WDP_LOGE( "Invalid parameter");
- __WDP_LOG_FUNC_EXIT__;
- return 1;
+ WDP_LOGE("Invalid parameter");
+ __WDP_LOG_FUNC_EXIT__;
+ return 1;
}
if (!sock) {
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
return -1;
}
- if (go_intent == NULL)
- {
+ if (go_intent == NULL) {
WDP_LOGE("p2p_go_intent is NULL");
- __WDP_LOG_FUNC_EXIT__;
+ __WDP_LOG_FUNC_EXIT__;
return -1;
}
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
char *tmp_str = NULL;
int res = 0;
- // Passing first line : "network id / ssid / bssid / flags"
- while (*ptr != '\n') {
+ /* Passing first line : "network id / ssid / bssid / flags" */
+ while (*ptr != '\n')
ptr++;
- }
+
ptr++;
count = 0;
- while(*ptr != '\0') {
+ while (*ptr != '\0') {
res = _extract_word(ptr, &tmp_str);
if (res > 0) {
networks[count].network_id = atoi(tmp_str);
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
wfd_oem_persistent_group_s *wfd_persistent_groups = NULL;
int res;
return -1;
}
- if(cnt == 0) {
+ if (cnt == 0) {
*group_count = cnt;
*groups = wfd_persistent_groups;
return -1;
}
- for(i = 0; i < cnt; i++) {
+ for (i = 0; i < cnt; i++) {
WDP_LOGD("----persistent group [%d]----", i);
WDP_LOGD("network_id=%d", networks[i].network_id);
WDP_LOGD("ssid=%s", networks[i].ssid);
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
int i;
ws_network_info_s networks[WS_MAX_PERSISTENT_COUNT];
_parsing_networks(reply, networks, &network_count);
- for(i=0;i<network_count;i++) {
+ for (i = 0; i < network_count; i++) {
WDP_LOGD("----persistent group [%d]----", i);
WDP_LOGD("network_id=%d", networks[i].network_id);
WDP_LOGD("ssid=%s", networks[i].ssid);
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
- char query[30] = {'0','2','0','0','F','F','0','1'};
+ char query[30] = {'0', '2', '0', '0', 'F', 'F', '0', '1'};
char mac_str[18] = {0, };
wfd_oem_service_s *service = NULL;
g_snprintf(mac_str, OEM_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
}
- switch(service_type) {
- case WFD_OEM_SERVICE_TYPE_ALL:
- g_snprintf(cmd, sizeof(cmd), WS_CMD_SERV_DISC_REQ " %s %s", mac_str, SERV_DISC_REQ_ALL);
- g_strlcpy(service->service_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
- break;
- case WFD_OEM_SERVICE_TYPE_BONJOUR:
- g_snprintf(cmd, sizeof(cmd), WS_CMD_SERV_DISC_REQ " %s %s", mac_str, SERV_DISC_REQ_BONJOUR);
- g_strlcpy(service->service_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
- break;
- case WFD_OEM_SERVICE_TYPE_UPNP:
- g_snprintf(cmd, sizeof(cmd), WS_CMD_SERV_DISC_REQ " %s %s", mac_str, SERV_DISC_REQ_UPNP);
- g_strlcpy(service->service_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
- break;
- default:
- WDP_LOGE("Invalid Service type");
- __WDP_LOG_FUNC_EXIT__;
- g_free(service);
- return -1;
+ switch (service_type) {
+ case WFD_OEM_SERVICE_TYPE_ALL:
+ {
+ g_snprintf(cmd, sizeof(cmd), WS_CMD_SERV_DISC_REQ " %s %s", mac_str, SERV_DISC_REQ_ALL);
+ g_strlcpy(service->service_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
+ }
+ break;
+ case WFD_OEM_SERVICE_TYPE_BONJOUR:
+ {
+ g_snprintf(cmd, sizeof(cmd), WS_CMD_SERV_DISC_REQ " %s %s", mac_str, SERV_DISC_REQ_BONJOUR);
+ g_strlcpy(service->service_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
+ }
+ break;
+ case WFD_OEM_SERVICE_TYPE_UPNP:
+ {
+ g_snprintf(cmd, sizeof(cmd), WS_CMD_SERV_DISC_REQ " %s %s", mac_str, SERV_DISC_REQ_UPNP);
+ g_strlcpy(service->service_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
+ }
+ break;
+ default:
+ WDP_LOGE("Invalid Service type");
+ __WDP_LOG_FUNC_EXIT__;
+ g_free(service);
+ return -1;
}
res = _ws_send_cmd(sock->ctrl_sock, cmd, (char*) reply, sizeof(reply));
WDP_LOGD("Succeeded to start service discovery");
g_strlcpy(service->dev_addr, mac_str, OEM_MACSTR_LEN);
- WDP_LOGD("query id :[0x%s]",reply);
+ WDP_LOGD("query id :[0x%s]", reply);
g_strlcpy(service->query_id, reply, OEM_QUERY_ID_LEN + 1);
res = _check_service_query_exists(service);
- if(res)
+ if (res)
g_free(service);
else
service_list = g_list_append(service_list, service);
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
char query_id[OEM_QUERY_ID_LEN + 1] = {0, };
char mac_str[18] = {0, };
wfd_oem_service_s *data = NULL;
- char s_type[OEM_SERVICE_TYPE_LEN + 1] ={0, };
+ char s_type[OEM_SERVICE_TYPE_LEN + 1] = {0, };
if (!sock) {
WDP_LOGE("Socket is NULL");
g_snprintf(mac_str, OEM_MACSTR_LEN, MACSTR, MAC2STR(mac_addr));
}
- switch(service_type) {
- case WFD_OEM_SERVICE_TYPE_ALL:
- g_strlcpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
+ switch (service_type) {
+ case WFD_OEM_SERVICE_TYPE_ALL:
+ g_strlcpy(s_type, SERV_DISC_REQ_ALL, OEM_SERVICE_TYPE_LEN + 1);
break;
- case WFD_OEM_SERVICE_TYPE_BONJOUR:
- g_strlcpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
+ case WFD_OEM_SERVICE_TYPE_BONJOUR:
+ g_strlcpy(s_type, SERV_DISC_REQ_BONJOUR, OEM_SERVICE_TYPE_LEN + 1);
break;
- case WFD_OEM_SERVICE_TYPE_UPNP:
- g_strlcpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
+ case WFD_OEM_SERVICE_TYPE_UPNP:
+ g_strlcpy(s_type, SERV_DISC_REQ_UPNP, OEM_SERVICE_TYPE_LEN + 1);
break;
- default:
- __WDP_LOG_FUNC_EXIT__;
- WDP_LOGE("Invalid Service type");
- return -1;
+ default:
+ __WDP_LOG_FUNC_EXIT__;
+ WDP_LOGE("Invalid Service type");
+ return -1;
}
WDP_LOGD("Cancel service discovery service_type [%d]", service_type);
WDP_LOGD("Token: %s", token);
len = strlen(token);
sprintf(temp_str, "%02x", len);
- for (i=0; i<len; i++) {
- sprintf(temp_str+i*2+2, "%02x", token[i]);
- }
+ for (i = 0; i < len; i++)
+ sprintf(temp_str + i * 2 + 2, "%02x", token[i]);
+
strncat(hex_key, temp_str, 2+2*len);
WDP_LOGD("Converting: %s", hex_key);
memset(temp_str, 0x0, 256);
WDP_LOGD("Token: %s", token);
len = strlen(token);
sprintf(temp_str, "%02x", len);
- for (i=0; i<len; i++) {
- sprintf(temp_str+i*2+2, "%02x", token[i]);
- }
+ for (i = 0; i < len; i++)
+ sprintf(temp_str + i * 2 + 2, "%02x", token[i]);
+
strncat(hex_value, temp_str, 2+2*len);
WDP_LOGD("Converting: %s", hex_value);
memset(temp_str, 0x0, 256);
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[256] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[256] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
if (!sock) {
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
unsigned int length = 0x0006;
unsigned int dev_info = 0x0110;
unsigned int ctrl_port = 0x07E6;
unsigned int max_tput = 0x0028;
- //unsigned int bssid = 0x00;
+ /* unsigned int bssid = 0x00; */
unsigned int cpled_sink_status = 0x00;
/* param : enable or disable*/
__WDP_LOG_FUNC_ENTER__;
ws_sock_data_s *sock = g_pd->common;
char cmd[80] = {0, };
- char reply[1024]={0,};
+ char reply[1024] = {0,};
int res;
unsigned int device_info = 0;
WDP_LOGD("Wi-Fi Display sync: [%d]", wifi_display->max_tput);
device_info = wifi_display->type;
- device_info+= (wifi_display->hdcp_support)<<8;
- device_info+= (wifi_display->availability)<<4; //for availability bit
+ device_info += (wifi_display->hdcp_support) << 8;
+ device_info += (wifi_display->availability) << 4; /* for availability bit */
g_snprintf(cmd, sizeof(cmd), WS_CMD_SUBELEM_SET "%d %04x%04x%04x%04x",
WFD_SUBELM_ID_DEV_INFO, WFD_SUBELEM_LEN_DEV_INFO,
return -1;
}
-// Only group owner can use this command
int ws_wps_start(unsigned char *peer_addr, int wps_mode, const char *pin)
{
__WDP_LOG_FUNC_ENTER__;
#include "wifi-direct-log.h"
static GDBusConnection *g_connection = NULL;
-static guint g_owner_id = 0; //Name Owner ID
+static guint g_owner_id = 0; /* Name Owner ID */
static GDBusConnection *__dbus_get_gdbus_conn(void)
{
return FALSE;
}
- if(reg_id > 0) {
- if(g_dbus_connection_unregister_object (connection, reg_id) == FALSE)
+ if (reg_id > 0) {
+ if (g_dbus_connection_unregister_object(connection, reg_id) == FALSE)
WDS_LOGE("netconfig network migration unregister object");
}
return TRUE;
}
g_connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &Error);
- if(g_connection == NULL) {
+ if (g_connection == NULL) {
WDS_LOGE("Failed to get connection, Error[%s]", Error->message);
g_error_free(Error);
return FALSE;
builder = g_variant_builder_new(G_VARIANT_TYPE("ay"));
- for(i = 0; i < size; i++)
+ for (i = 0; i < size; i++)
g_variant_builder_add(builder, "y", src[i]);
iter = g_variant_new("ay", builder);
- g_variant_builder_unref (builder);
+ g_variant_builder_unref(builder);
return iter;
}
#include "wifi-direct-dbus.h"
#include "wifi-direct-log.h"
-#define WFD_MANAGER_QUARK (g_quark_from_string ("wifi-direct-error-quark"))
+#define WFD_MANAGER_QUARK (g_quark_from_string("wifi-direct-error-quark"))
static void wfd_error_invalid_parameter(GError **error)
{
*/
}
-void wfd_error_set_gerror(wifi_direct_error_e error_code, GError **error) {
- switch(error_code) {
+void wfd_error_set_gerror(wifi_direct_error_e error_code, GError **error)
+{
+ switch (error_code) {
case WIFI_DIRECT_ERROR_INVALID_PARAMETER:
wfd_error_invalid_parameter(error);
break;
return 0;
}
- gboolean _wfd_connection_retry(gpointer *data)
+gboolean _wfd_connection_retry(gpointer *data)
{
wfd_session_s *session = (wfd_session_s*) data;
if (!session) {
}
switch (session->state) {
- case SESSION_STATE_STARTED:
- WDS_LOGD("PD again");
- wfd_session_start(session);
- break;
- case SESSION_STATE_GO_NEG:
- WDS_LOGD("Negotiation again");
- wfd_session_connect(session);
- break;
- case SESSION_STATE_WPS:
- WDS_LOGD("WPS again");
- wfd_session_wps(session);
- break;
- default:
- WDS_LOGE("Invalid session state [%d]", session->state);
- break;
+ case SESSION_STATE_STARTED:
+ WDS_LOGD("PD again");
+ wfd_session_start(session);
+ break;
+ case SESSION_STATE_GO_NEG:
+ WDS_LOGD("Negotiation again");
+ wfd_session_connect(session);
+ break;
+ case SESSION_STATE_WPS:
+ WDS_LOGD("WPS again");
+ wfd_session_wps(session);
+ break;
+ default:
+ WDS_LOGE("Invalid session state [%d]", session->state);
+ break;
}
__WDS_LOG_FUNC_EXIT__;
return G_SOURCE_REMOVE;
static void __wfd_process_deactivated(wfd_manager_s *manager, wfd_oem_event_s *event)
{
- __WDS_LOG_FUNC_ENTER__;
+ __WDS_LOG_FUNC_ENTER__;
wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
"Deactivation",
GVariant *params = NULL;
wfd_oem_advertise_service_s *service;
- for(list = (GList *)event->asp_services; list != NULL; list = list->next) {
+ for (list = (GList *)event->asp_services; list != NULL; list = list->next) {
service = (wfd_oem_advertise_service_s *)list->data;
- builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}"));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "search_id", g_variant_new("t", service->search_id));
g_variant_builder_add(builder, "{sv}", "service_mac", g_variant_new("s", peer_mac_address));
g_variant_builder_add(builder, "{sv}", "device_name", g_variant_new("s", edata->name));
g_variant_builder_add(builder, "{sv}", "advertisement_id", g_variant_new("u", service->adv_id));
g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new("u", service->config_method));
- if(service->service_type)
+ if (service->service_type)
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new("s", service->service_type));
params = g_variant_new("(a{sv})", builder);
g_variant_builder_unref(builder);
params);
}
#endif
- __WDS_LOG_FUNC_EXIT__;
+ __WDS_LOG_FUNC_EXIT__;
return;
}
static void __wfd_process_peer_disappeared(wfd_manager_s *manager, wfd_oem_event_s *event)
{
- __WDS_LOG_FUNC_ENTER__;
+ __WDS_LOG_FUNC_ENTER__;
wfd_session_s *session = NULL;
wfd_device_s *peer = NULL;
char peer_mac_address[MACSTR_LEN+1] = {0, };
session = manager->session;
- if(session != NULL && session->peer != NULL) {
+ if (session != NULL && session->peer != NULL) {
peer = session->peer;
WDS_LOGD("session peer [" MACSTR "] lost peer [" MACSTR "]", MAC2STR(peer->dev_addr),
MAC2STR(event->dev_addr));
- if(memcmp(peer->dev_addr, event->dev_addr, MACADDR_LEN) == 0) {
+ if (memcmp(peer->dev_addr, event->dev_addr, MACADDR_LEN) == 0) {
WDS_LOGD("peer already in connection");
return;
}
"PeerLost",
g_variant_new("(s)", peer_mac_address));
- __WDS_LOG_FUNC_EXIT__;
- return;
+ __WDS_LOG_FUNC_EXIT__;
+ return;
}
static void __wfd_process_discovery_finished(wfd_manager_s *manager, wfd_oem_event_s *event)
{
- __WDS_LOG_FUNC_ENTER__;
+ __WDS_LOG_FUNC_ENTER__;
if (manager->state != WIFI_DIRECT_STATE_DISCOVERING &&
manager->state != WIFI_DIRECT_STATE_ACTIVATED) {
static void __wfd_process_prov_disc_req(wfd_manager_s *manager, wfd_oem_event_s *event)
{
- __WDS_LOG_FUNC_ENTER__;
+ __WDS_LOG_FUNC_ENTER__;
wfd_device_s *peer = NULL;
- int res = 0;
+ int res = 0;
wfd_group_s *group = (wfd_group_s*) manager->group;
if (group && group->role == WFD_DEV_ROLE_GC) {
}
if (peer) {
- if (WFD_PEER_STATE_DISCOVERED < peer->state)
- {
+ if (WFD_PEER_STATE_DISCOVERED < peer->state) {
WDS_LOGD("Peer already connected/connecting, ignore this provision request");
__WDS_LOG_FUNC_EXIT__;
return;
static void __wfd_process_prov_disc_resp(wfd_manager_s *manager, wfd_oem_event_s *event)
{
- __WDS_LOG_FUNC_ENTER__;
+ __WDS_LOG_FUNC_ENTER__;
wfd_device_s *peer = NULL;
int res = 0;
return;
}
- static void __wfd_process_go_neg_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
- {
+static void __wfd_process_go_neg_fail(wfd_manager_s *manager, wfd_oem_event_s *event)
+{
__WDS_LOG_FUNC_ENTER__;
wfd_session_s *session = NULL;
}
session = (wfd_session_s*) manager->session;
- if(session && session->peer) {
+ if (session && session->peer) {
peer = session->peer;
memcpy(peer->intf_addr, edata->peer_intf_addr, MACADDR_LEN);
}
if (group->role == WFD_DEV_ROLE_GC && session) {
#ifdef TIZEN_FEATURE_IP_OVER_EAPOL
wfd_device_s *peer = session->peer;
- if(peer == NULL) {
+ if (peer == NULL) {
WDS_LOGE("Unexpected event. Peer doesn't exist");
return;
}
wfd_update_peer(manager, peer);
- if(peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
+ if (peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
char peer_mac_address[MACSTR_LEN+1] = {0, };
wfd_util_ip_over_eap_assign(peer, event->ifname);
WFD_EVENT_DISCONNECTION_RSP,
peer_mac_address));
- } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING && manager->session){
+ } else if (manager->state == WIFI_DIRECT_STATE_CONNECTING && manager->session) {
wfd_manager_dbus_emit_signal(WFD_MANAGER_MANAGE_INTERFACE,
"Connection",
g_variant_new("(iis)", WIFI_DIRECT_ERROR_CONNECTION_FAILED,
{
__WDS_LOG_FUNC_ENTER__;
- __WDS_LOG_FUNC_EXIT__;
+ __WDS_LOG_FUNC_EXIT__;
return;
}
wfd_device_s *peer = NULL;
char peer_mac_address[MACSTR_LEN+1] = {0, };
- // FIXME: Move this code to plugin
+ /* FIXME: Move this code to plugin */
if (!memcmp(event->intf_addr, manager->local->intf_addr, MACADDR_LEN)) {
WDS_LOGD("Ignore this event");
__WDS_LOG_FUNC_EXIT__;
memcpy(peer->go_ip_addr, manager->local->ip_addr, IPADDR_LEN);
WDS_LOGE("Peer's GO IP [" IPSTR "]", IP2STR((char*) &peer->go_ip_addr));
}
- if(peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
+ if (peer->ip_type == WFD_IP_TYPE_OVER_EAPOL) {
char peer_mac_address[MACSTR_LEN+1] = {0,};
char assigned_ip_address[IPSTR_LEN+1] = {0,};
WDS_LOGD("%d service data found", event->dev_role);
temp = g_list_first(services);
- while(temp && count < event->dev_role) {
+ while (temp && count < event->dev_role) {
service = (wfd_oem_new_service_s*) temp->data;
service_type = service->protocol;
if (service->protocol == WFD_OEM_SERVICE_TYPE_BONJOUR) {
} else if (event->edata_type == WFD_OEM_EDATA_TYPE_SERVICE) {
wfd_oem_service_data_s *edata = (wfd_oem_service_data_s*) event->edata;
- if(!edata) {
+ if (!edata) {
service_type = -1;
} else {
service_type = edata->type;
g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(event->dev_addr));
- switch(edata->type) {
+ switch (edata->type) {
WDS_LOGE("Unknown type [type ID: %d]", edata->type);
}
}
#if defined(TIZEN_FEATURE_ASP)
static void __wfd_process_asp_serv_resp(wfd_manager_s *manager, wfd_oem_event_s *event)
- {
+{
__WDS_LOG_FUNC_ENTER__;
wfd_oem_asp_service_s *service = NULL;
GVariant *params = NULL;
service = (wfd_oem_asp_service_s *)event->edata;
- if(service == NULL) {
+ if (service == NULL) {
WDS_LOGE("P2P service found event has NULL information");
__WDS_LOG_FUNC_EXIT__;
return;
}
- builder = g_variant_builder_new(G_VARIANT_TYPE ("a{sv}"));
+ builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
g_variant_builder_add(builder, "{sv}", "search_id", g_variant_new("u", service->search_id));
g_variant_builder_add(builder, "{sv}", "service_mac", g_variant_new("s", event->dev_addr));
g_variant_builder_add(builder, "{sv}", "advertisement_id", g_variant_new("u", service->adv_id));
g_variant_builder_add(builder, "{sv}", "config_method", g_variant_new("u", service->config_method));
- if(service->service_type)
+ if (service->service_type)
g_variant_builder_add(builder, "{sv}", "service_type", g_variant_new("s", service->service_type));
- if(service->service_info)
+ if (service->service_info)
g_variant_builder_add(builder, "{sv}", "service_info", g_variant_new("s", service->service_info));
g_variant_builder_add(builder, "{sv}", "status", g_variant_new("y", service->status));
params = g_variant_new("(a{sv})", builder);
__WDS_LOG_FUNC_EXIT__;
return;
- }
+}
#endif /* TIZEN_FEATURE_ASP */
static struct {
- const int event_id;
- void (*function) (wfd_manager_s *manager, wfd_oem_event_s *event);
+ const int event_id;
+ void (*function) (wfd_manager_s *manager, wfd_oem_event_s *event);
} wfd_oem_event_map[] = {
{
WFD_OEM_EVENT_NONE,
WFD_OEM_EVENT_MAX,
NULL
}
- };
+};
- int wfd_process_event(void *user_data, void *data)
- {
+int wfd_process_event(void *user_data, void *data)
+{
__WDS_LOG_FUNC_ENTER__;
wfd_manager_s *manager = NULL;
wfd_oem_event_s *event = NULL;
WDS_LOGD("Event[%d] from " MACSECSTR, event->event_id,
MAC2SECSTR(event->dev_addr));
- if(event->event_id > WFD_OEM_EVENT_NONE &&
+ if (event->event_id > WFD_OEM_EVENT_NONE &&
event->event_id < WFD_OEM_EVENT_MAX)
wfd_oem_event_map[event->event_id].function(manager, event);
else
__WDS_LOG_FUNC_EXIT__;
return 0;
- }
+}
#include "wifi-direct-log.h"
-// Check the group instance which has same interface name, before using this function
+/* Check the group instance which has same interface name,
+ * before using this function */
wfd_group_s *wfd_create_group(void *data, wfd_oem_event_s *group_info)
{
__WDS_LOG_FUNC_ENTER__;
return group;
}
-// Used for CTRL-EVENT_CONNECTED event that comes before group created
+/* Used for CTRL-EVENT_CONNECTED event that comes before group created */
wfd_group_s *wfd_create_pending_group(void *data, unsigned char * bssid)
{
__WDS_LOG_FUNC_ENTER__;
WDS_LOGE("Peer's GO IP [" IPSTR "]", IP2STR((char*) &peer->go_ip_addr));
}
- if(peer->ip_type != WFD_IP_TYPE_OVER_EAPOL)
+ if (peer->ip_type != WFD_IP_TYPE_OVER_EAPOL)
#endif /* TIZEN_FEATURE_IP_OVER_EAPOL */
wfd_util_dhcpc_start(group->ifname, peer);
}
memset(manager->local->ip_addr, 0x0, IPADDR_LEN);
temp = g_list_first(group->members);
- while(temp && count < group->member_count) {
+ while (temp && count < group->member_count) {
member = temp->data;
WDS_LOGD("%dth member[%s] will be removed", count, member->dev_name);
g_free(member);
}
member = wfd_peer_find_by_addr(manager, addr);
- if (!member) {
+ if (!member)
WDS_LOGE("Peer not found");
- }
group->members = g_list_prepend(group->members, member);
group->member_count++;
return (i == 6);
}
-// introspection xml to register interfaces
+/* introspection xml to register interfaces */
const gchar wfd_manager_introspection_xml[] = {
"<node name='/net/wifidirect'>"
"<interface name='net.wifidirect'>"
builder_peers = g_variant_builder_new(G_VARIANT_TYPE("aa{sv}"));
- // even though status is not CONNECTED, this command can be excuted only when group exist
+ /* even though status is not CONNECTED,
+ * this command can be excuted only when group exist */
if (!manager->group && manager->state < WIFI_DIRECT_STATE_CONNECTED) {
WDS_LOGD("It's not connected state [%d]", manager->state);
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
failed:
-//g_dbus_method_invocation_return_dbus_error(invocation, WFD_MANAGER_SERVICE ".Error", ".OperationFailed");
+/*g_dbus_method_invocation_return_dbus_error
+ * (invocation, WFD_MANAGER_SERVICE ".Error", ".OperationFailed"); */
wfd_error_set_gerror(ret, &err);
dbus_error_name = g_dbus_error_encode_gerror(err);
g_variant_get(parameters, "(i)", &type);
ret = wfd_manager_set_req_wps_mode(type);
- if(ret < 0) {
+ if (ret < 0) {
WDS_LOGE("Failed to set request wps mode");
ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
goto failed;
g_variant_get(parameters, "(i)", &go_intent);
ret = wfd_manager_set_go_intent(go_intent);
- if(ret < 0) {
+ if (ret < 0) {
WDS_LOGE("Failed to set GO intent");
ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
goto failed;
g_variant_get(parameters, "(i)", &max_client);
ret = wfd_manager_set_max_station(max_client);
- if(ret < 0) {
+ if (ret < 0) {
WDS_LOGE("Failed to set max station");
ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
goto failed;
g_variant_get(parameters, "(b)", &mode);
ret = wfd_manager_set_autoconnection(mode);
- if(ret < 0) {
+ if (ret < 0) {
WDS_LOGE("Failed to set autoconnection");
ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
goto failed;
WDS_LOGD("type %d port %d hdcp %d", type, port, hdcp);
ret = wfd_manager_set_display_device(type, port, hdcp);
- if(ret < 0) {
+ if (ret < 0) {
WDS_LOGE("Failed to set display device settings");
ret = WIFI_DIRECT_ERROR_OPERATION_FAILED;
goto failed;
int availability;
g_variant_get(parameters, "(i)", &availability);
- if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
+ if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
goto failed;
}
g_variant_get(parameters, "(&s)", &mac_address);
macaddr_atoe(mac_address, mac_addr);
- if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
+ if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
goto failed;
}
peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
- if(!peer) {
+ if (!peer) {
WDS_LOGE("Failed to get peer");
ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
goto failed;
g_variant_get(parameters, "(&s)", &mac_address);
macaddr_atoe(mac_address, mac_addr);
- if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
+ if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
goto failed;
}
peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
- if(!peer) {
+ if (!peer) {
WDS_LOGE("Failed to get peer");
ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
goto failed;
g_variant_get(parameters, "(&s)", &mac_address);
macaddr_atoe(mac_address, mac_addr);
- if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
+ if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
goto failed;
}
peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
- if(!peer) {
+ if (!peer) {
WDS_LOGE("Failed to get peer");
ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
goto failed;
g_variant_get(parameters, "(&s)", &mac_address);
macaddr_atoe(mac_address, mac_addr);
- if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
+ if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
goto failed;
}
peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
- if(!peer) {
+ if (!peer) {
WDS_LOGE("Failed to get peer");
ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
goto failed;
g_variant_get(parameters, "(&s)", &mac_address);
macaddr_atoe(mac_address, mac_addr);
- if(manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
+ if (manager->state < WIFI_DIRECT_STATE_ACTIVATED) {
ret = WIFI_DIRECT_ERROR_NOT_PERMITTED;
goto failed;
}
peer = wfd_manager_get_peer_by_addr(manager, mac_addr);
- if(!peer) {
+ if (!peer) {
WDS_LOGE("Failed to get peer");
ret = WIFI_DIRECT_ERROR_INVALID_PARAMETER;
goto failed;
static struct {
guint reg_id;
const gchar *iface_name;
- void (*function) (const gchar *method_name,
- GVariant *parameters,
- GDBusMethodInvocation *invocation);
+ void (*function) (const gchar *method_name,
+ GVariant *parameters,
+ GDBusMethodInvocation *invocation);
} wfd_manager_iface_map[] = {
{
0,
}
};
-// GDBus method handler
+/* GDBus method handler */
static void wfd_manager_method_call_handler (GDBusConnection *connection,
const gchar *sender,
const gchar *object_path,
}
}
-static const GDBusInterfaceVTable wfd_manager_interface_vtable =
- {wfd_manager_method_call_handler, NULL, NULL};
+static const GDBusInterfaceVTable wfd_manager_interface_vtable = {
+ wfd_manager_method_call_handler, NULL, NULL};
void wfd_manager_dbus_unregister(void)
{
wfd_util_set_dev_name_notification();
res = wfd_util_get_local_dev_mac(local->dev_addr);
- if (res < 0) {
+ if (res < 0)
WDS_LOGE("Failed to get local device MAC address");
- }
memcpy(local->intf_addr, local->dev_addr, MACADDR_LEN);
local->intf_addr[4] ^= 0x80;
local->services = NULL;
local->service_count = 0;
#endif /* TIZEN_FEATURE_SERVICE_DISCOVERY */
- // TODO: initialize other local device datas
+ /* TODO: initialize other local device datas */
manager->local = local;
__WDS_LOG_FUNC_EXIT__;
wfd_util_unset_dev_name_notification();
- // TODO: free member of local device
+ /* TODO: free member of local device */
g_free(manager->local);
__WDS_LOG_FUNC_EXIT__;
wfd_oem_set_dev_name(g_manager->oem_ops, dev_name);
WDS_LOGD("Device name changed.");
} else {
- WDS_LOGE("Device name can't changed: state is %d",g_manager->state);
+ WDS_LOGE("Device name can't changed: state is %d", g_manager->state);
}
__WDS_LOG_FUNC_EXIT__;
}
*autoconnection = g_manager->autoconnection;
- WDS_LOGD("Local autoconnection [%s]", *autoconnection ? "TRUE":"FALSE");
+ WDS_LOGD("Local autoconnection [%s]", *autoconnection ? "TRUE" : "FALSE");
__WDS_LOG_FUNC_EXIT__;
return 0;
#endif /* TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT */
res = wfd_util_get_local_dev_mac(manager->local->dev_addr);
- if (res < 0) {
+ if (res < 0)
WDS_LOGE("Failed to get local device MAC address");
- }
memcpy(manager->local->intf_addr, manager->local->dev_addr, MACADDR_LEN);
manager->local->intf_addr[4] ^= 0x80;
}
#if defined(TIZEN_WLAN_CONCURRENT_ENABLE) && defined(TIZEN_MOBILE)
} else {
- // FIXME: We should do something to stop p2p feature of Driver
+ /* FIXME: We should do something to stop p2p feature of Driver */
res = wfd_oem_deactivate(manager->oem_ops, res);
if (res < 0) {
WDS_LOGE("Failed to deactivate");
return WIFI_DIRECT_ERROR_OPERATION_FAILED;
}
- // TODO: check peer_addr with session's peer_addr
+ /* TODO: check peer_addr with session's peer_addr */
if (manager->local->dev_role == WFD_DEV_ROLE_GO) {
WDS_LOGD("My device is GO and peer want to join my group, so WPS will be started");
res = wfd_session_reject(session, peer_addr);
if (res < 0) {
WDS_LOGE("Failed to reject connection");
- // TODO: check whether set state and break
+ /* TODO: check whether set state and break */
}
wfd_destroy_session(manager);
}
peer_dev = wfd_peer_find_by_addr(manager, addr);
- if(!peer_dev) {
+ if (!peer_dev) {
peer_dev = (wfd_device_s*) g_try_malloc0(sizeof(wfd_device_s));
if (!peer_dev) {
WDS_LOGE("Failed to allocate memory for peer device. [%s]", strerror(errno));
{
__WDS_LOG_FUNC_ENTER__;
wfd_device_s *peer = NULL;
- if(manager->group) {
+ if (manager->group)
peer = wfd_group_find_member_by_addr(manager->group, peer_addr);
- }
- if(peer) {
+ if (peer)
return peer;
- }
peer = wfd_peer_find_by_addr(manager, peer_addr);
if (res < 0) {
WDS_LOGE("Failed to initialize local device");
g_free(manager);
- return NULL; // really stop manager?
+ return NULL; /* really stop manager? */
}
WDS_LOGD("Succeeded to initialize local device");
int (*plugin_load)(wfd_oem_ops_s **ops) = NULL;
plugin_load = (int (*)(wfd_oem_ops_s **ops)) dlsym(handle, "wfd_plugin_load");
if (!plugin_load) {
- WDS_LOGE( "Failed to load symbol. Error = [%s]", strerror(errno));
+ WDS_LOGE("Failed to load symbol. Error = [%s]", strerror(errno));
dlclose(handle);
__WDS_LOG_FUNC_EXIT__;
return NULL;
__WDS_LOG_FUNC_ENTER__;
GMainLoop *main_loop = NULL;
-#if !GLIB_CHECK_VERSION(2,32,0)
+#if !GLIB_CHECK_VERSION(2, 32, 0)
if (!g_thread_supported())
g_thread_init(NULL);
#endif
-#if !GLIB_CHECK_VERSION(2,36,0)
+#if !GLIB_CHECK_VERSION(2, 36, 0)
g_type_init();
#endif
- // TODO: Parsing argument
+ /* TODO: Parsing argument */
/* Wi-Fi direct connection for S-Beam can be optimized using argument */
/**
}
temp = g_list_first(manager->peers);
- while(temp) {
+ while (temp) {
peer = (wfd_device_s*) temp->data;
g_free(peer);
temp = g_list_next(temp);
manager->peer_count--;
}
- if(manager->peers) {
+ if (manager->peers) {
g_list_free(manager->peers);
manager->peers = NULL;
}
- if (manager->peer_count){
+ if (manager->peer_count) {
WDS_LOGE("Peer count is not synced. left count=%d", manager->peer_count);
manager->peer_count = 0;
return 1;
__WDS_LOG_FUNC_ENTER__;
wfd_manager_s *manager = wfd_get_manager();
wfd_service_s *service = NULL;
-// wfd_oem_new_service_s *oem_service = NULL;
char *info1 = NULL;
char *info2 = NULL;
char *sep = NULL;
return -1;
}
- if (type < WIFI_DIRECT_SERVICE_TYPE_BONJOUR || type > WIFI_DIRECT_SERVICE_TYPE_VENDOR){
+ if (type < WIFI_DIRECT_SERVICE_TYPE_BONJOUR ||
+ type > WIFI_DIRECT_SERVICE_TYPE_VENDOR) {
WDS_LOGE("Invalid service type");
return -1;
}
service->type = type;
service->id = (intptr_t) service;
-
info1 = g_strndup(info_str, strlen(info_str));
- if(info1 == NULL) {
+ if (info1 == NULL) {
WDS_LOGE("Failed to allocate memory for service");
g_free(service);
return -1;
}
sep = strchr(info1, '|');
- if(sep == NULL) {
+ if (sep == NULL) {
WDS_LOGE("Failed to find delimiter");
g_free(info1);
g_free(service);
info2 = sep + 1;
switch (service->type) {
- case WIFI_DIRECT_SERVICE_TYPE_BONJOUR:
- service->data.bonjour.query = info1;
- if(strstr(info2, "ptr")){
- service->data.bonjour.rdata_type = WFD_BONJOUR_RDATA_PTR;
- } else {
- service->data.bonjour.rdata_type = WFD_BONJOUR_RDATA_TXT;
- }
- service->data.bonjour.rdata = info2 +3;
- break;
- case WIFI_DIRECT_SERVICE_TYPE_UPNP:
- service->data.upnp.version = info1;
- service->data.upnp.service = info2;
- break;
- case WIFI_DIRECT_SERVICE_TYPE_WS_DISCOVERY:
- case WIFI_DIRECT_SERVICE_TYPE_WIFI_DISPLAY:
- WDS_LOGE("Not supported yet");
- g_free(info1);
- g_free(service);
- return-1;
- break;
- case WIFI_DIRECT_SERVICE_TYPE_VENDOR:
- service->data.vendor.info1 = info1;
- service->data.vendor.info2 = info2;
- break;
- default:
- WDS_LOGE("Invalid service type");
- g_free(info1);
- g_free(service);
- return-1;
- break;
+ case WIFI_DIRECT_SERVICE_TYPE_BONJOUR:
+ service->data.bonjour.query = info1;
+ if (strstr(info2, "ptr"))
+ service->data.bonjour.rdata_type = WFD_BONJOUR_RDATA_PTR;
+ else
+ service->data.bonjour.rdata_type = WFD_BONJOUR_RDATA_TXT;
+
+ service->data.bonjour.rdata = info2 +3;
+ break;
+ case WIFI_DIRECT_SERVICE_TYPE_UPNP:
+ service->data.upnp.version = info1;
+ service->data.upnp.service = info2;
+ break;
+ case WIFI_DIRECT_SERVICE_TYPE_WS_DISCOVERY:
+ case WIFI_DIRECT_SERVICE_TYPE_WIFI_DISPLAY:
+ WDS_LOGE("Not supported yet");
+ g_free(info1);
+ g_free(service);
+ return -1;
+ break;
+ case WIFI_DIRECT_SERVICE_TYPE_VENDOR:
+ service->data.vendor.info1 = info1;
+ service->data.vendor.info2 = info2;
+ break;
+ default:
+ WDS_LOGE("Invalid service type");
+ g_free(info1);
+ g_free(service);
+ return -1;
}
-// oem_service = (wfd_oem_new_service_s*) calloc(1, sizeof(wfd_oem_new_service_s));
-// oem_service->protocol = service->type;
-// oem_service->data = service->data;
-
res = wfd_oem_serv_add(manager->oem_ops, (wfd_oem_new_service_s*) service);
if (res < 0) {
WDS_LOGE("Failed to add service");
return -1;
}
-// free(oem_service);
-
service->str_ptr = info1;
manager->local->services = g_list_prepend(manager->local->services, service);
*service_id = service->id;
{
__WDS_LOG_FUNC_ENTER__;
int handle = 0;
- // TODO: return identifier(handle) for the pending query
+ /* TODO: return identifier(handle) for the pending query */
if (!addr) {
WDS_LOGE("Invalid parameter");
return -1;
}
- if (type < WFD_SERVICE_TYPE_ALL || type > WFD_SERVICE_TYPE_VENDOR){
+ if (type < WFD_SERVICE_TYPE_ALL ||
+ type > WFD_SERVICE_TYPE_VENDOR) {
WDS_LOGE("Invalid service type");
return -1;
}
- // TODO: call oem function
- // TODO: add service information into service list
+ /* TODO: call oem function */
+ /* TODO: add service information into service list */
__WDS_LOG_FUNC_EXIT__;
return handle;
WDS_LOGD("Session timer expired");
peer_addr = wfd_session_get_peer_addr(session);
- if(peer_addr != NULL)
+ if (peer_addr != NULL)
g_snprintf(peer_mac_address, MACSTR_LEN, MACSTR, MAC2STR(peer_addr));
else
g_snprintf(peer_mac_address, MACSTR_LEN, "%s", "");
return 0;
}
-// Check the session instance which has same peer address, before using this function
+/* Check the session instance which has same peer address,
+ * before using this function */
wfd_session_s *wfd_create_session(void *data, unsigned char *peer_addr, int wps_mode, int direction)
{
__WDS_LOG_FUNC_ENTER__;
session = (wfd_session_s*) manager->session;
if (!session) {
- WDS_LOGE("Session not found"); // self prevent 13029
+ WDS_LOGE("Session not found"); /* self prevent */
return -1;
}
wfd_session_timer(session, 0);
peer = session->peer;
- if(peer) {
+ if (peer) {
if (session->state == SESSION_STATE_COMPLETED)
peer->state = WFD_PEER_STATE_CONNECTED;
else
return -1;
}
- // Check: Invitation Received in Incomming case -> send prov_disc join
- // Check: User select peer to connect with in Outgoing case -> send prov_disc wps_mdde
+ /* Check: Invitation Received in Incomming case ->
+ * send prov_disc join
+ *
+ * Check: User select peer to connect with in Outgoing case ->
+ * send prov_disc wps_mode */
wfd_oem_stop_scan(manager->oem_ops);
WDS_LOGD("Failed to send provision discovery request to peer [" MACSECSTR "]",
MAC2SECSTR(peer->dev_addr));
wfd_destroy_session(manager);
- // TODO: send notification to App
+ /* TODO: send notification to App */
__WDS_LOG_FUNC_EXIT__;
return -1;
}
if (session->state > SESSION_STATE_CREATED) {
peer = session->peer;
- if (session->direction == SESSION_DIRECTION_INCOMING) {
+ if (session->direction == SESSION_DIRECTION_INCOMING)
res = wfd_oem_reject_connection(manager->oem_ops, peer->dev_addr);
- } else if (session->direction == SESSION_DIRECTION_OUTGOING) {
+ else if (session->direction == SESSION_DIRECTION_OUTGOING)
res = wfd_oem_cancel_connection(manager->oem_ops, peer->dev_addr);
- }
- if (res < 0) {
+
+ if (res < 0) {
WDS_LOGE("Failed to reject or cancel connection");
__WDS_LOG_FUNC_EXIT__;
return -1;
param.conn_flags |= WFD_OEM_CONN_TYPE_JOIN;
param.go_intent = session->go_intent;
param.freq = session->freq;
- if(manager->local->group_flags & WFD_GROUP_FLAG_PERSISTENT)
+ if (manager->local->group_flags & WFD_GROUP_FLAG_PERSISTENT)
param.conn_flags |= WFD_OEM_CONN_TYPE_PERSISTENT;
- if (session->wps_pin[0] != '\0') {
+ if (session->wps_pin[0] != '\0')
g_strlcpy(param.wps_pin, session->wps_pin, OEM_PINSTR_LEN + 1);
- }
/* To connect with windows phone,set go_intent value to 2.
* As windows phone does not connect when local device act as GO.
if ((peer->pri_dev_type == 1) ||
((peer->pri_dev_type == 10) && (peer->sec_dev_type == 1))) {
param.go_intent = 2;
- WDS_LOGD("go_intent set to %d, Windows device",param.go_intent);
+ WDS_LOGD("go_intent set to %d, Windows device", param.go_intent);
}
WDS_LOGD("connection go_intent: %d", param.go_intent);
}
wfd_destroy_session(manager);
- // TODO: send notification to App
+ /* TODO: send notification to App */
__WDS_LOG_FUNC_EXIT__;
return 0;
memset(¶m, 0x00, sizeof(wfd_oem_conn_param_s));
param.wps_mode = session->wps_mode;
param.conn_flags |= WFD_OEM_CONN_TYPE_JOIN;
- param.freq = session->freq; // currently not used
+ param.freq = session->freq; /* currently not used */
g_strlcpy(param.wps_pin, session->wps_pin, OEM_PINSTR_LEN + 1);
res = wfd_oem_connect(manager->oem_ops, peer->dev_addr, ¶m);
}
break;
case WFD_OEM_EVENT_PROV_DISC_RESP:
{
- if (!session) { // TODO: check validity of Event
+ if (!session) { /* TODO: check validity of Event */
WDS_LOGE("Unexpected event. Session is NULL [peer: " MACSECSTR "]",
MAC2SECSTR(event->dev_addr));
break;
static char *_wfd_state_string(int state)
{
switch (state) {
- case WIFI_DIRECT_STATE_DEACTIVATED:
- return "DEACTIVATED";
- case WIFI_DIRECT_STATE_DEACTIVATING:
- return "DEACTIVATING";
- case WIFI_DIRECT_STATE_ACTIVATING:
- return "ACTIVATING";
- case WIFI_DIRECT_STATE_ACTIVATED:
- return "ACTIVATED";
- case WIFI_DIRECT_STATE_DISCOVERING:
- return "DISCOVERING";
- case WIFI_DIRECT_STATE_CONNECTING:
- return "CONNECTING";
- case WIFI_DIRECT_STATE_DISCONNECTING:
- return "DISCONNECTING";
- case WIFI_DIRECT_STATE_CONNECTED:
- return "CONNECTED";
- case WIFI_DIRECT_STATE_GROUP_OWNER:
- return "GROUP_OWNER";
- default:
- return "Unknown State";
+ case WIFI_DIRECT_STATE_DEACTIVATED:
+ return "DEACTIVATED";
+ case WIFI_DIRECT_STATE_DEACTIVATING:
+ return "DEACTIVATING";
+ case WIFI_DIRECT_STATE_ACTIVATING:
+ return "ACTIVATING";
+ case WIFI_DIRECT_STATE_ACTIVATED:
+ return "ACTIVATED";
+ case WIFI_DIRECT_STATE_DISCOVERING:
+ return "DISCOVERING";
+ case WIFI_DIRECT_STATE_CONNECTING:
+ return "CONNECTING";
+ case WIFI_DIRECT_STATE_DISCONNECTING:
+ return "DISCONNECTING";
+ case WIFI_DIRECT_STATE_CONNECTED:
+ return "CONNECTED";
+ case WIFI_DIRECT_STATE_GROUP_OWNER:
+ return "GROUP_OWNER";
+ default:
+ return "Unknown State";
}
-
}
int wfd_state_set(wfd_manager_s *manager, int state)
#if defined(TIZEN_FEATURE_DEFAULT_CONNECTION_AGENT)
static int __wfd_util_find_login_user(uid_t *uid)
- {
+{
uid_t *uids;
int ret, i;
char *state;
free(uids);
free(state);
return -1;
- }
-
+}
#endif
gboolean wfd_util_execute_file(const char *file_path,
} else if (pid > 0) {
if (waitpid(pid, &rv, 0) == -1)
WDS_LOGD("wait pid (%u) rv (%d)", pid, rv);
- if (WIFEXITED(rv)) {
+ if (WIFEXITED(rv))
WDS_LOGD("exited, rv=%d", WEXITSTATUS(rv));
- } else if (WIFSIGNALED(rv)) {
+ else if (WIFSIGNALED(rv))
WDS_LOGD("killed by signal %d", WTERMSIG(rv));
- } else if (WIFSTOPPED(rv)) {
+ else if (WIFSTOPPED(rv))
WDS_LOGD("stopped by signal %d", WSTOPSIG(rv));
- } else if (WIFCONTINUED(rv)) {
+ else if (WIFCONTINUED(rv))
WDS_LOGD("continued");
- }
return TRUE;
}
name = vconf_get_str(VCONFKEY_SETAPPL_DEVICE_NAME_STR);
if (!name) {
- WDS_LOGE( "Failed to get vconf value for %s", VCONFKEY_SETAPPL_DEVICE_NAME_STR);
+ WDS_LOGE("Failed to get vconf value for %s", VCONFKEY_SETAPPL_DEVICE_NAME_STR);
return -1;
}
g_strlcpy(phone_name, name, DEV_NAME_LEN + 1);
- WDS_LOGD( "[%s: %s]", VCONFKEY_SETAPPL_DEVICE_NAME_STR, phone_name);
+ WDS_LOGD("[%s: %s]", VCONFKEY_SETAPPL_DEVICE_NAME_STR, phone_name);
g_free(name);
__WDS_LOG_FUNC_EXIT__;
return 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
+ VCONFKEY_WIFI_OFF = 0x00,
+ VCONFKEY_WIFI_UNCONNECTED,
+ VCONFKEY_WIFI_CONNECTED,
+ VCONFKEY_WIFI_TRANSFER,
+ VCONFKEY_WIFI_STATE_MAX
};
*/
res = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_state);
__WDS_LOG_FUNC_EXIT__;
return 1;
}
- WDS_LOGD( "OK. Wi-Fi is off\n");
+ WDS_LOGD("OK. Wi-Fi is off\n");
__WDS_LOG_FUNC_EXIT__;
return 0;
WDS_LOGD("[%s: %d]", VCONFKEY_MOBILE_HOTSPOT_MODE, mobile_ap_state);
if ((mobile_ap_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI)
- || (mobile_ap_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP) ) {
+ || (mobile_ap_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI_AP)) {
WDS_LOGD("Mobile AP is on");
__WDS_LOG_FUNC_EXIT__;
return 1;
}
- WDS_LOGD( "OK. Mobile AP is off\n");
+ WDS_LOGD("OK. Mobile AP is off\n");
__WDS_LOG_FUNC_EXIT__;
return 0;
int vconf_state = 0;
int res = 0;
- // TODO: check validity of state
+ /* TODO: check validity of state */
if (state == WIFI_DIRECT_STATE_ACTIVATED)
vconf_state = VCONFKEY_WIFI_DIRECT_ACTIVATED;
else if (state == WIFI_DIRECT_STATE_DEACTIVATED)
- vconf_state= VCONFKEY_WIFI_DIRECT_DEACTIVATED;
+ vconf_state = VCONFKEY_WIFI_DIRECT_DEACTIVATED;
else if (state == WIFI_DIRECT_STATE_CONNECTED)
vconf_state = VCONFKEY_WIFI_DIRECT_CONNECTED;
else if (state == WIFI_DIRECT_STATE_GROUP_OWNER)
errno = 0;
fd = fopen(file_path, "r");
if (!fd) {
- WDS_LOGE("Failed to open MAC info file [%s] (%s)",file_path , strerror(errno));
+ WDS_LOGE("Failed to open MAC info file [%s] (%s)", file_path , strerror(errno));
__WDS_LOG_FUNC_EXIT__;
return -1;
}
return;
}
- while(fgets(buf, MAX_DHCP_DUMP_SIZE, fp) != NULL) {
+ while (fgets(buf, MAX_DHCP_DUMP_SIZE, fp) != NULL) {
WDS_LOGD("Read line [%s]", buf);
- n = sscanf(buf,"%17s %15s", intf_str, ip_str);
- WDS_LOGD("ip=[%s], mac=[%s]",ip_str, intf_str);
- if (n != 2) {
+ n = sscanf(buf, "%17s %15s", intf_str, ip_str);
+ WDS_LOGD("ip=[%s], mac=[%s]", ip_str, intf_str);
+ if (n != 2)
continue;
- }
+
_txt_to_mac(intf_str, intf_addr);
if (!memcmp(peer->intf_addr, intf_addr, MACADDR_LEN)) {
WDS_LOGD("Peer intf mac found");
return -1;
}
- while(count < 10) {
+ while (count < 10) {
get_str = vconf_get_str(VCONFKEY_DHCPC_SERVER_IP);
if (!get_str) {
WDS_LOGE("Failed to get vconf value[%s]", VCONFKEY_DHCPC_SERVER_IP);
return -1;
}
- if(strcmp(get_str, ZEROIP) == 0) {
+ if (strcmp(get_str, ZEROIP) == 0) {
WDS_LOGE("Failed to get vconf value[%s]", VCONFKEY_DHCPC_SERVER_IP);
g_free(get_str);
__WDS_LOG_FUNC_EXIT__;
/* Get index of interface */
if_index = if_nametoindex(ifname);
- if(if_index < 0) {
+ if (if_index < 0) {
WDS_LOGE("Failed to get interface index. [%s]", strerror(errno));
__WDS_LOG_FUNC_EXIT__;
return -1;
rta->rta_type = IFA_BROADCAST;
rta->rta_len = RTA_LENGTH(IPADDR_LEN);
memcpy(ip_addr, static_ip, IPADDR_LEN);
- ip_addr[3] =0xff;
+ ip_addr[3] = 0xff;
memcpy(RTA_DATA(rta), ip_addr, IPADDR_LEN);
req.nh.nlmsg_len += rta->rta_len;
nl_msg.msg_iovlen = 1;
res = sendmsg(nl_sock, &nl_msg, 0);
- if (res < 0) {
+ if (res < 0)
WDS_LOGE("Failed to sendmsg. [%s]", strerror(errno));
- } else {
+ else
WDS_LOGD("Succed to sendmsg. [%d]", res);
- }
close(nl_sock);
WDS_LOGE("Succeeded to set local(client) IP [" IPSTR "] for iface[%s]",
IP2STR(ip_addr), ifname);
if_index = if_nametoindex(ifname);
- if(if_index < 0) {
+ if (if_index < 0) {
strerror_r(errno, error_buf, MAX_SIZE_ERROR_BUFFER);
WDS_LOGE("Failed to get interface index. [%s]", error_buf);
__WDS_LOG_FUNC_EXIT__;
projects / platform / core / connectivity / wifi-direct-manager.git / commitdiff