tests/mocks/tethering_gdbus.c

   1 /*
   2  * Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "tethering_gdbus.h"
  18
  19 #include <stdio.h>
  20 #include <stdbool.h>
  21 #include <glib.h>
  22 #include <gio/gio.h>
  23
  24 typedef struct {
  25         GAsyncReadyCallback callback;
  26         gpointer user_data;
  27         const char *method_name;
  28 } gdbus_async_callback_info_s;
  29
  30 typedef struct {
  31         GDBusSignalCallback callback;
  32         gpointer user_data;
  33 } gdbus_signal_callback_info_s;
  34
  35 static const char *gdbus_signal_list[TETHERING_MOCK_GDBUS_SIGNAL_MAX] = {
  36         [TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED] = "net_closed",
  37         [TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_ON] = "wifi_on",
  38         [TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_OFF] = "wifi_off",
  39         [TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_ON] = "usb_on",
  40         [TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_OFF] = "usb_off",
  41         [TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_ON] = "bluetooth_on",
  42         [TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_OFF] = "bluetooth_off",
  43         [TETHERING_MOCK_GDBUS_SIGNAL_NO_DATA_TIMEOUT] = "no_data_timeout",
  44         [TETHERING_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE] = "low_batt_mode",
  45         [TETHERING_MOCK_GDBUS_SIGNAL_FLIGHT_MODE] = "flight_mode",
  46         [TETHERING_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED] = "security_type_changed",
  47         [TETHERING_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED] = "ssid_visibility_changed",
  48         [TETHERING_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED] = "passphrase_changed",
  49         [TETHERING_MOCK_GDBUS_SIGNAL_DHCP_STATUS] = "dhcp_status"
  50 };
  51
  52 static const char *gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_MAX] = {
  53         [TETHERING_MOCK_GDBUS_METHOD_DISABLE_USB] = "disable_usb_tethering",
  54         [TETHERING_MOCK_GDBUS_METHOD_DISABLE_WIFI] = "disable_wifi_tethering",
  55         [TETHERING_MOCK_GDBUS_METHOD_DISABLE_BT] = "disable_bt_tethering",
  56         [TETHERING_MOCK_GDBUS_METHOD_DISABLE_P2P] = "disable_p2p_tethering",
  57         [TETHERING_MOCK_GDBUS_METHOD_GET_DATA_PACKET_USAGE] = "get_data_packet_usage",
  58 };
  59
  60 static gdbus_async_callback_info_s gdbus_async_callback = {NULL, NULL};
  61 static gdbus_signal_callback_info_s gdbus_signal_callbacks[TETHERING_MOCK_GDBUS_SIGNAL_MAX] = {
  62         {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL},
  63         {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL} };
  64
  65 static bool tethering_mock_gdbus_result;
  66
  67 void tethering_mock_set_gdbus_result(bool value)
  68 {
  69         tethering_mock_gdbus_result = value;
  70 }
  71
  72 void tethering_mock_invoke_gdbus_async_callback(void)
  73 {
  74         if (!gdbus_async_callback.callback)
  75                 return;
  76
  77         gdbus_async_callback.callback(NULL, NULL, gdbus_async_callback.user_data);
  78 }
  79
  80 void tethering_mock_emit_gdbus_signal(int signo)
  81 {
  82         if (signo < TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED || signo >= TETHERING_MOCK_GDBUS_SIGNAL_MAX)
  83                 return;
  84
  85         if (!gdbus_signal_callbacks[signo].callback)
  86                 return;
  87
  88         GVariant *params = NULL;
  89
  90         switch (signo) {
  91         case TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED:
  92                 break;
  93         case TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_ON:
  94                 break;
  95         case TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_OFF:
  96                 params = g_variant_new("(s)", "There is no connection for a while");
  97                 break;
  98         case TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_ON:
  99                 break;
 100         case TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_OFF:
 101                 params = g_variant_new("(s)", "Interface is not available");
 102                 break;
 103         case TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_ON:
 104                 break;
 105         case TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_OFF:
 106                 params = g_variant_new("(s)", "There is no connection for a while");
 107                 break;
 108         case TETHERING_MOCK_GDBUS_SIGNAL_NO_DATA_TIMEOUT:
 109         case TETHERING_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE:
 110         case TETHERING_MOCK_GDBUS_SIGNAL_FLIGHT_MODE:
 111                 break;
 112         case TETHERING_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED:
 113                 params = g_variant_new("(s)", "wpa2-psk");
 114                 break;
 115         case TETHERING_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED:
 116                 params = g_variant_new("(s)", "ssid_visible");
 117                 break;
 118         case TETHERING_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED:
 119                 break;
 120         case TETHERING_MOCK_GDBUS_SIGNAL_DHCP_STATUS:
 121                 params = g_variant_new("(susssu)", "DhcpConnected", 1,
 122                                 "192.168.43.24", "ab:cd:ef:ab:cd:ef",
 123                                 "client", 1592460260);
 124                 break;
 125         default:
 126                 break;
 127         }
 128
 129         gdbus_signal_callbacks[signo].callback(NULL, NULL,
 130                         NULL, NULL, gdbus_signal_list[signo],
 131                         params, gdbus_signal_callbacks[signo].user_data);
 132 }
 133
 134 GCancellable *__wrap_g_cancellable_new(void)
 135 {
 136         return (GCancellable *)g_object_new(G_TYPE_CANCELLABLE, NULL);
 137 }
 138
 139 GDBusConnection *__wrap_g_bus_get_sync(GBusType bus_type, GCancellable *cancellable, GError **error)
 140 {
 141         return (GDBusConnection *)g_object_new(G_TYPE_DBUS_CONNECTION, NULL);
 142 }
 143
 144 GDBusProxy *__wrap_g_dbus_proxy_new_sync(GDBusConnection *connection,
 145                 GDBusProxyFlags         flags,
 146                 GDBusInterfaceInfo      *info,
 147                 const gchar                     *name,
 148                 const gchar                     *object_path,
 149                 const gchar                     *interface_name,
 150                 GCancellable            *cancellable,
 151                 GError                          **error)
 152 {
 153         return (GDBusProxy *)g_object_new(G_TYPE_DBUS_PROXY, NULL);
 154 }
 155
 156 guint __wrap_g_dbus_connection_signal_subscribe(GDBusConnection  *connection,
 157                 const gchar                     *sender,
 158                 const gchar                     *interface_name,
 159                 const gchar                     *member,
 160                 const gchar                     *object_path,
 161                 const gchar                     *arg0,
 162                 GDBusSignalFlags        flags,
 163                 GDBusSignalCallback     callback,
 164                 gpointer                        user_data,
 165                 GDestroyNotify          user_data_free_func)
 166 {
 167         for (int i = TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED; i < TETHERING_MOCK_GDBUS_SIGNAL_MAX; i++) {
 168                 if (strcmp(gdbus_signal_list[i], member) == 0) {
 169                         gdbus_signal_callbacks[i].callback = callback;
 170                         gdbus_signal_callbacks[i].user_data = user_data;
 171                         return i;
 172                 }
 173         }
 174         return 0;
 175 }
 176
 177 void __wrap_g_dbus_connection_signal_unsubscribe(GDBusConnection *connection,
 178                 guint subscription_id)
 179 {
 180         if (subscription_id >= TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED
 181                         && subscription_id < TETHERING_MOCK_GDBUS_SIGNAL_MAX) {
 182                 gdbus_signal_callbacks[subscription_id].callback = NULL;
 183                 gdbus_signal_callbacks[subscription_id].user_data = NULL;
 184         }
 185
 186         return;
 187 }
 188
 189 typedef struct {
 190         int type;
 191         const char *ip;
 192         const char *mac;
 193         const char *hostname;
 194         int time;
 195 } clients_info_s;
 196
 197 #define DUMMY_CLIENTS_NUM 4
 198 clients_info_s dummy_clients[DUMMY_CLIENTS_NUM + 1] = {
 199         {0, "192.168.43.10", "aa:bb:cc:aa:bb:cc", "client1", 1592379558},  // wifi
 200         {1, "192.168.129.15", "bb:cc:aa:bb:cc:aa", "client2", 1592379626}, // usb
 201         {2, "192.168.130.21", "cc:aa:bb:cc:aa:bb", "client3", 1592379687}, // bluetooth
 202         {3, "192.168.43.57", "ab:cd:ef:ab:cd:ef", "client4", 1592379714},  // p2p
 203         {0, NULL, NULL, NULL, 0}
 204 };
 205
 206 static GVariant *_get_connected_clients_info(void)
 207 {
 208         GVariant *params = NULL;
 209         GVariantBuilder *inner_builder;
 210         GVariantBuilder *outer_builder;
 211
 212         outer_builder = g_variant_builder_new(G_VARIANT_TYPE("a(a{sv})"));
 213
 214         for (int i = 0; i < DUMMY_CLIENTS_NUM; i++) {
 215                 inner_builder = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 216                 g_variant_builder_add(inner_builder, "{sv}", "Type",
 217                                 g_variant_new_int32(dummy_clients[i].type));
 218                 g_variant_builder_add(inner_builder, "{sv}", "IP",
 219                                 g_variant_new_string(dummy_clients[i].ip));
 220                 g_variant_builder_add(inner_builder, "{sv}", "MAC",
 221                                 g_variant_new_string(dummy_clients[i].mac));
 222                 g_variant_builder_add(inner_builder, "{sv}", "Name",
 223                                 g_variant_new_string(dummy_clients[i].hostname));
 224                 g_variant_builder_add(inner_builder, "{sv}", "Time",
 225                                 g_variant_new_int32(dummy_clients[i].time));
 226
 227                 g_variant_builder_add(outer_builder, "(@a{sv})", g_variant_builder_end(inner_builder));
 228                 g_variant_builder_unref(inner_builder);
 229         }
 230
 231         params = g_variant_new("(@a(a{sv}))", g_variant_builder_end(outer_builder));
 232         g_variant_builder_unref(outer_builder);
 233
 234         return params;
 235 }
 236
 237 GVariant *__wrap_g_dbus_proxy_call_sync(GDBusProxy      *proxy,
 238                 const gchar             *method_name,
 239                 GVariant                *parameters,
 240                 GDBusCallFlags  flags,
 241                 gint                    timeout_msec,
 242                 GCancellable    *cancellable,
 243                 GError                  **error)
 244 {
 245         GVariant *params = NULL;
 246
 247         if (!tethering_mock_gdbus_result) {
 248                 *error = g_error_new(G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "dbus error");
 249                 return NULL;
 250         }
 251
 252         if (strcmp(method_name, "get_wifi_tethering_passphrase") == 0)
 253                 params = g_variant_new("(siu)", "P@s$w0rd!", 9, 0);
 254         else if (strcmp(method_name, "get_station_info") == 0)
 255                 params = _get_connected_clients_info();
 256 #ifdef TIZEN_TV_EXT
 257         else if (strcmp(method_name, "get_wifi_tethering_channel") == 0)
 258                 params = g_variant_new("(iu)", 6, 0);
 259 #endif /* TIZEN_TV_EXT */
 260         else
 261                 params = g_variant_new("(u)", 0);
 262
 263         return params;
 264 }
 265
 266 void __wrap_g_dbus_proxy_call(GDBusProxy        *proxy,
 267                 const gchar             *method_name,
 268                 GVariant                *parameters,
 269                 GDBusCallFlags  flags,
 270                 gint                    timeout_msec,
 271                 GCancellable    *cancellable,
 272                 GAsyncReadyCallback     callback,
 273                 gpointer        user_data)
 274 {
 275         gdbus_async_callback.callback = callback;
 276         gdbus_async_callback.user_data = user_data;
 277         gdbus_async_callback.method_name = method_name;
 278 }
 279
 280 GVariant *__wrap_g_dbus_proxy_call_finish(GDBusProxy *proxy,
 281                 GAsyncResult *res, GError **error)
 282 {
 283         GVariant *params = NULL;
 284         const char *method_name = gdbus_async_callback.method_name;
 285
 286         if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_USB]) == 0)
 287                 params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_USB, 0);
 288         else if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_WIFI]) == 0)
 289                 params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_WIFI, 0);
 290         else if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_BT]) == 0)
 291                 params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_BT, 0);
 292         else if (strcmp(method_name, gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_DISABLE_P2P]) == 0)
 293                 params = g_variant_new("(uu)", TETHERING_MOCK_GDBUS_EVENT_DISABLE_P2P, 0);
 294         else if (strcmp(method_name,
 295                                 gdbus_method_list[TETHERING_MOCK_GDBUS_METHOD_GET_DATA_PACKET_USAGE]) == 0)
 296                 params = g_variant_new("(utt)", 1, 123456, 2312412);
 297         else
 298                 params = g_variant_new("(u)", 0);
 299
 300         gdbus_async_callback.callback = NULL;
 301         gdbus_async_callback.user_data = NULL;
 302         gdbus_async_callback.method_name = NULL;
 303
 304         return params;
 305 }
 306
 307 void __wrap_g_dbus_proxy_set_default_timeout(GDBusProxy *proxy, gint timeout_msec)
 308 {
 309         return;
 310 }
 311
 312 gboolean __wrap_g_dbus_connection_emit_signal(GDBusConnection *connection,
 313                 const gchar     *destination_bus_name,
 314                 const gchar     *object_path,
 315                 const gchar     *interface_name,
 316                 const gchar     *signal_name,
 317                 GVariant        *parameters,
 318                 GError          **error)
 319 {
 320         return TRUE;
 321 }