tests/mocks/mock_gdbus.c

   1 /*
   2  * Copyright (c) 2021 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 /**
  18  * TODO: Add logic to methodcall and it's mock reply.
  19  * TODO: Add logic to emit mock signals.
  20  */
  21
  22 #include<stdio.h>
  23 #include "mock_gdbus.h"
  24
  25 #include <stdbool.h>
  26 #include <gio/gio.h>
  27
  28 static bool mock_gdbus_result;
  29 static bool mock_gdbus_devicePolicy;
  30 static bool mock_gdbus_powered;
  31 #define MOCK_TECH_COUNT_MAX 2
  32 #define MOCK_SERVICES_COUNT_MAX 2
  33 #define ERROR_DOMAIN    5
  34 #define ERROR_CODE      10
  35
  36 typedef struct {
  37         GAsyncReadyCallback callback;
  38         gpointer user_data;
  39         const char *method_name;
  40 } gdbus_async_callback_info_s;
  41
  42 #if 0
  43 typedef struct {
  44         GDBusSignalCallback callback;
  45         gpointer user_data;
  46 } gdbus_signal_callback_info_s;
  47
  48
  49 static const char *gdbus_signal_list[WIFI_MOCK_GDBUS_SIGNAL_MAX] = {
  50         [WIFI_MOCK_GDBUS_SIGNAL_STATE_CHANGED_PROPERTIES] = "StateChangedPropertie",
  51         [WIFI_MOCK_GDBUS_SIGNAL_PROPERTY_CHANGED] = "PropertyChanged",
  52         [WIFI_MOCK_GDBUS_SIGNAL_SCAN_CHANGED] = "ScanChanged",
  53         [WIFI_MOCK_GDBUS_SIGNAL_SCAN_DONE] = "ScanDone",
  54 };
  55
  56 static gdbus_signal_callback_info_s gdbus_signal_callbacks[WIFI_MOCK_GDBUS_SIGNAL_MAX] = {
  57         {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL} }; // {NULL, NULL},
  58 //      {NULL, NULL}, {NULL, NULL}, {NULL, NULL}, {NULL, NULL} };
  59
  60 #endif
  61 static gdbus_async_callback_info_s gdbus_async_callback = {NULL, NULL};
  62
  63 typedef struct {
  64         const char *ifname;
  65         const char *mac_address;
  66         gboolean powered;
  67         gboolean connected;
  68 } mock_gdbus_tech_s;
  69
  70 typedef struct {
  71         const char *EncryptionMode;
  72         const char *State;
  73         const char *Name;
  74         const char *Interface;
  75         const char *BssId;
  76 } mock_gdbus_services_s;
  77
  78 char *err_msg[ERROR_MAX] = {"", "PermissionDenied", "AccessDenied", "AlreadyExists", "InProgress", "Device or resource busy", "NULL" };
  79 static int err_no;
  80
  81 mock_gdbus_tech_s mock_tech[MOCK_TECH_COUNT_MAX] = {
  82         {"wlan0", "11:22:33:44:55:66", 0, 0},
  83         {"wlan1", "66:55:44:33:22:11", 0, 0}
  84 };
  85
  86 mock_gdbus_services_s mock_services[MOCK_SERVICES_COUNT_MAX] = {
  87         {"wep", "ready", "TEMP_AP1", "wlan0", "11:22:33:44:55:66"},
  88         {"aes", "ready", "TEMP_AP2", "wlan0", "11:22:33:44:55:66"}
  89 };
  90
  91 void mock_set_gdbus_tech_state(const char *ifname, bool powered, bool connected)
  92 {
  93         for (int i = 0; i < MOCK_TECH_COUNT_MAX; i++) {
  94                 if (g_strcmp0(mock_tech[i].ifname, ifname) != 0)
  95                         continue;
  96
  97                 mock_tech[i].powered = powered;
  98                 mock_tech[i].connected = connected;
  99                 break;
 100         }
 101 }
 102
 103 void mock_set_gdbus_error_msg(int error)
 104 {
 105         err_no = error;
 106 }
 107
 108 static GVariant * __get_mock_variant_get_technologies(void)
 109 {
 110         GVariant *return_parameter;
 111         GVariantBuilder *builder_technologies = g_variant_builder_new(G_VARIANT_TYPE("a(oa{sv})"));;
 112         GVariantBuilder *builder_technology = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 113         GVariantBuilder *deviceList = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 114         const gchar *object_path = "/net/connman/technology/wifi";
 115
 116         // TODO: fill technology data
 117         g_variant_builder_add(builder_technology, "{sv}", "Name", g_variant_new_string("WiFi"));
 118         g_variant_builder_add(builder_technology, "{sv}", "Type", g_variant_new_string("wifi"));
 119         g_variant_builder_add(builder_technology, "{sv}", "Tethering", g_variant_new_boolean(FALSE));
 120         g_variant_builder_add(builder_technology, "{sv}", "Powered", g_variant_new_boolean(TRUE));
 121         g_variant_builder_add(builder_technology, "{sv}", "Connected", g_variant_new_boolean(FALSE));
 122
 123         for (int i = 0; i < MOCK_TECH_COUNT_MAX; i++) {
 124
 125                 g_variant_builder_add(deviceList, "{sv}", "Ifname", g_variant_new_string(mock_tech[i].ifname));
 126                 g_variant_builder_add(deviceList, "{sv}", "Powered", g_variant_new_boolean(mock_tech[i].powered));
 127                 g_variant_builder_add(deviceList, "{sv}", "Connected", g_variant_new_boolean(mock_tech[i].connected));
 128                 g_variant_builder_add(deviceList, "{sv}", "MAC.Address", g_variant_new_string(mock_tech[i].mac_address));
 129         }
 130
 131         g_variant_builder_add(builder_technology, "{sv}", "Device.List", g_variant_builder_end(deviceList));
 132
 133         g_variant_builder_add(builder_technologies, "(oa{sv})", object_path, builder_technology);
 134
 135         return_parameter = g_variant_new("(a(oa{sv}))", builder_technologies);
 136
 137
 138         g_variant_builder_unref(deviceList);
 139         g_variant_builder_unref(builder_technology);
 140         g_variant_builder_unref(builder_technologies);
 141
 142         return return_parameter;
 143 }
 144
 145 static GVariant * __get_mock_variant_get_DevicePolicyGetWifi(void)
 146 {
 147         GVariant *value;
 148         if (mock_gdbus_devicePolicy)
 149                 value = g_variant_new("(i)", 0);
 150         else
 151                 value = g_variant_new("(i)", 1);
 152
 153         return value;
 154 }
 155
 156 static GVariant * __get_mock_variant_int(void)
 157 {
 158         return g_variant_new("(i)", 0);
 159 }
 160
 161 static GVariant * __get_mock_variant_uint(void)
 162 {
 163         return g_variant_new("(u)", 1);
 164 }
 165
 166 static GVariant * __get_mock_variant_bool(void)
 167 {
 168         return g_variant_new("(b)", TRUE);
 169 }
 170
 171 static GVariant * __get_mock_variant_get_scanstate(void)
 172 {
 173         GVariant *value;
 174         GVariantBuilder *scanstate = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 175         //g_variant_builder_add(scanstate, "{sv}", g_variant_new_string(mock_tech[0].ifname), g_variant_new_boolean(FALSE));
 176         g_variant_builder_add(scanstate, "{sv}", "wlan0", g_variant_new_boolean(FALSE));
 177         value = g_variant_new("(a{sv})", scanstate);
 178         return value;
 179 }
 180
 181 static GVariant * __get_mock_variant_get_services(void)
 182 {
 183         GVariant *return_parameter;
 184         GVariantBuilder *builder_services = g_variant_builder_new(G_VARIANT_TYPE("a(oa{sv})"));;
 185         int i = 0;
 186         for (i = 0; i < MOCK_SERVICES_COUNT_MAX; i++) {
 187                 GVariantBuilder *builder_service = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 188                 GVariantBuilder *builder_eth = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 189                 const gchar *object_path = "/net/connman/service/wifi_112233445566_496e6672612d36412d33_managed_psk";
 190
 191                 // TODO: fill service data
 192                 g_variant_builder_add(builder_service, "{sv}", "EncryptionMode", g_variant_new_string(mock_services[i].EncryptionMode));
 193                 g_variant_builder_add(builder_service, "{sv}", "BSSID", g_variant_new_string(mock_services[i].BssId));
 194                 g_variant_builder_add(builder_service, "{sv}", "State", g_variant_new_string(mock_services[i].State));
 195                 g_variant_builder_add(builder_service, "{sv}", "Name", g_variant_new_string(mock_services[i].Name));
 196
 197                 g_variant_builder_add(builder_eth, "{sv}", "Interface", g_variant_new_string(mock_services[i].Interface));
 198
 199                 g_variant_builder_add(builder_service, "{sv}", "Ethernet", g_variant_builder_end(builder_eth));
 200                 g_variant_builder_add(builder_services, "(oa{sv})", object_path, builder_service);
 201                 g_variant_builder_unref(builder_service);
 202                 g_variant_builder_unref(builder_eth);
 203         }
 204         return_parameter = g_variant_new("(a(oa{sv}))", builder_services);
 205
 206         //g_variant_builder_unref(builder_service);
 207         g_variant_builder_unref(builder_services);
 208
 209         return return_parameter;
 210 }
 211
 212 static GVariant * __get_mock_variant_get_properties(void)
 213 {
 214         GVariant *return_parameter;
 215         GVariantBuilder *builder_properties = g_variant_builder_new(G_VARIANT_TYPE("a{sv}"));
 216
 217         g_variant_builder_add(builder_properties, "{sv}", "MacPolicy", g_variant_new_uint32(1));
 218         g_variant_builder_add(builder_properties, "{sv}", "PreassocMacPolicy", g_variant_new_uint32(2));
 219         g_variant_builder_add(builder_properties, "{sv}", "RandomMacAddrLifetime", g_variant_new_uint32(20));
 220
 221         g_variant_builder_add(builder_properties, "{sv}", "AutoConnect", g_variant_new_boolean(TRUE));
 222
 223         return_parameter = g_variant_new("(a{sv})", builder_properties);
 224
 225         g_variant_builder_unref(builder_properties);
 226
 227         return return_parameter;
 228 }
 229
 230 static GVariant * __get_mock_variant_get_interfaces(void)
 231 {
 232         const gchar *interface_name = "wlan0";
 233         GVariantBuilder *builder_interfaces = g_variant_builder_new(G_VARIANT_TYPE("as"));
 234
 235         g_variant_builder_add(builder_interfaces, "s", interface_name);
 236
 237         return g_variant_new("(as)", builder_interfaces);
 238 }
 239
 240 static GVariant * __get_mock_variant_string(void)
 241 {
 242         return g_variant_new("(s)", "dummy");
 243 }
 244
 245 void mock_set_gdbus_result(bool value)
 246 {
 247         mock_gdbus_result = value;
 248 }
 249
 250 void mock_set_gdbus_devicePolicy(bool value)
 251 {
 252         mock_gdbus_devicePolicy = value;
 253 }
 254
 255 void mock_set_gdbus_powered(bool value)
 256 {
 257         mock_gdbus_powered = value;
 258 }
 259
 260 GCancellable *__wrap_g_cancellable_new(void)
 261 {
 262         if (mock_gdbus_result == false)
 263                 return NULL;
 264
 265         return (GCancellable *)g_object_new(G_TYPE_CANCELLABLE, NULL);
 266 }
 267
 268 GDBusConnection *__wrap_g_bus_get_sync(GBusType bus_type, GCancellable *cancellable, GError **error)
 269 {
 270         if (mock_gdbus_result == false)
 271                 return NULL;
 272
 273         return (GDBusConnection *)g_object_new(G_TYPE_DBUS_CONNECTION, NULL);
 274 }
 275
 276 typedef GVariant * (*g_dbus_reply_fn)(void);
 277
 278 typedef struct {
 279         const char *method_name;
 280         g_dbus_reply_fn fn;
 281 } method_call_reply_s;
 282
 283 method_call_reply_s g_dbus_reply[] = {
 284         {"GetTechnologies",         __get_mock_variant_get_technologies},
 285         {"GetServices",             __get_mock_variant_get_services},
 286         {"GetProperties",           __get_mock_variant_get_properties},
 287         {"GetInterfaces",           __get_mock_variant_get_interfaces},
 288         {"DevicePolicyGetWifi",     __get_mock_variant_get_DevicePolicyGetWifi},
 289         {"GetScanState",            __get_mock_variant_get_scanstate},
 290         {"IpConflictSetEnable",     __get_mock_variant_int},
 291         {"SetIpConflictPeriod",     __get_mock_variant_int},
 292         {"GetIpConflictPeriod",     __get_mock_variant_uint},
 293         {"GetIpConflictState",      __get_mock_variant_uint},
 294         {"SetProperty",             __get_mock_variant_int},
 295         {"GetAutoscan",             __get_mock_variant_bool},
 296         {"GetAutoscanmode",         __get_mock_variant_uint},
 297         {"FlushBss",                __get_mock_variant_int},
 298         {"CheckGetPrivilege",       __get_mock_variant_int},
 299         {"GetMaxScanSsid",          __get_mock_variant_get_scanstate},
 300         {"Get5GhzSupported",        __get_mock_variant_get_scanstate},
 301         {"ResumeBgscan",            __get_mock_variant_string},
 302         {"PauseBgscan",             __get_mock_variant_string},
 303         {"AddVsie",                 __get_mock_variant_string},
 304         {"GetVsie",                 __get_mock_variant_string},
 305         {"RemoveVsie",              __get_mock_variant_string},
 306         {"TdlsDiscover",            __get_mock_variant_int},
 307         {"TdlsConnect",             __get_mock_variant_int},
 308         {"TdlsDisconnect",          __get_mock_variant_int},
 309         {"TdlsConnectedPeer",       __get_mock_variant_string},
 310         {"SetBgscan",               __get_mock_variant_int},
 311         {"SaveConfiguration",       __get_mock_variant_int},
 312         {"SaveEapConfiguration",    __get_mock_variant_int},
 313         {"TdlsChannelSwitch",       __get_mock_variant_int},
 314         {"TdlsCancelChannelSwitch", __get_mock_variant_int},
 315         {"LoadConfiguration",       __get_mock_variant_get_scanstate},
 316         {"GetConfigIds",            __get_mock_variant_get_interfaces},
 317         {"SetBSSID",                __get_mock_variant_int},
 318         {NULL, NULL}
 319 };
 320
 321 GVariant *__wrap_g_dbus_connection_call_sync(GDBusConnection *connection,
 322                                              const gchar *bus_name,
 323                                              const gchar *object_path,
 324                                              const gchar *interface_name,
 325                                              const gchar *method_name,
 326                                              GVariant *parameters,
 327                                              const GVariantType *reply_type,
 328                                              GDBusCallFlags flags,
 329                                              gint timeout_msec,
 330                                              GCancellable *cancellable,
 331                                              GError **error)
 332 {
 333         if (mock_gdbus_result == false)
 334                 return NULL;
 335
 336         if (err_no) {
 337                 g_set_error(error, ERROR_DOMAIN, ERROR_CODE, "error message  %s", err_msg[err_no]);
 338                 err_no = ERROR_NONE;
 339                 return NULL;
 340         }
 341
 342         for (int i = 0; g_dbus_reply[i].method_name; i++)
 343                 if (!g_strcmp0(g_dbus_reply[i].method_name, method_name))
 344                         return g_dbus_reply[i].fn();
 345
 346         return NULL;
 347 }
 348
 349 void __wrap_g_dbus_connection_call(GDBusConnection *connection,
 350                                    const gchar *bus_name,
 351                                    const gchar *object_path,
 352                                    const gchar *interface_name,
 353                                    const gchar *method_name,
 354                                    GVariant *parameters,
 355                                    const GVariantType *reply_type,
 356                                    GDBusCallFlags flags,
 357                                    gint timeout_msec,
 358                                    GCancellable *cancellable,
 359                                    GAsyncReadyCallback callback,
 360                                    gpointer user_data)
 361 {
 362         if (mock_gdbus_result == false)
 363                 return;
 364
 365         gdbus_async_callback.callback = callback;
 366         gdbus_async_callback.user_data = user_data;
 367         gdbus_async_callback.method_name = method_name;
 368
 369         return;
 370 }
 371
 372 GVariant * __wrap_g_dbus_connection_call_finish(GDBusConnection *connection,
 373                                                 GAsyncResult *res,
 374                                                 GError **error)
 375 {
 376         GVariant *params = NULL;
 377         const char *method_name = gdbus_async_callback.method_name;
 378         if (mock_gdbus_result == false)
 379                 return NULL;
 380         if ((strcmp(method_name, "LoadDriver") == 0) || (strcmp(method_name, "RemoveDriver") == 0)) {
 381                 if (!g_strcmp0("", err_msg[err_no]))
 382                         error = NULL;
 383                 else
 384                         g_set_error(error, ERROR_DOMAIN, ERROR_CODE, "error message  %s", err_msg[err_no]);
 385                 params = g_variant_new("(u)", 0);
 386         } else if (strcmp(method_name, "ScanDevice") == 0) {
 387                 g_set_error(error, ERROR_DOMAIN, ERROR_CODE, "error message  %s", err_msg[err_no]);
 388                 params = g_variant_new("(u)", 0);
 389         } else if (strcmp(method_name, "SpecificScan") == 0) {
 390                 g_set_error(error, ERROR_DOMAIN, ERROR_CODE, "error message  %s", err_msg[err_no]);
 391                 params = g_variant_new("(u)", 0);
 392         }
 393
 394         gdbus_async_callback.callback = NULL;
 395         gdbus_async_callback.user_data = NULL;
 396         gdbus_async_callback.method_name = NULL;
 397         err_no = ERROR_NONE;
 398
 399         return params;
 400 }
 401
 402 void mock_invoke_gdbus_async_callback(void)
 403 {
 404         if (!gdbus_async_callback.callback)
 405                 return;
 406         gdbus_async_callback.callback(NULL, NULL, gdbus_async_callback.user_data);
 407 }
 408
 409 #if 0
 410 void mock_emit_gdbus_signal(int signo)
 411 {
 412         if (signo < WIFI_MOCK_GDBUS_SIGNAL_STATE_CHANGED_PROPERTIES || signo >= WIFI_MOCK_GDBUS_SIGNAL_MAX)
 413                 return;
 414
 415         if (!gdbus_signal_callbacks[signo].callback)
 416                 return;
 417
 418         GVariant *params = NULL;
 419         return;
 420         switch (signo) {
 421         case TETHERING_MOCK_GDBUS_SIGNAL_NET_CLOSED:
 422                 break;
 423         case TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_ON:
 424                 break;
 425         case TETHERING_MOCK_GDBUS_SIGNAL_WIFI_TETHER_OFF:
 426                 params = g_variant_new("(s)", "There is no connection for a while");
 427                 break;
 428         case TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_ON:
 429                 break;
 430         case TETHERING_MOCK_GDBUS_SIGNAL_USB_TETHER_OFF:
 431                 params = g_variant_new("(s)", "Interface is not available");
 432                 break;
 433         case TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_ON:
 434                 break;
 435         case TETHERING_MOCK_GDBUS_SIGNAL_BT_TETHER_OFF:
 436                 params = g_variant_new("(s)", "There is no connection for a while");
 437                 break;
 438         case TETHERING_MOCK_GDBUS_SIGNAL_NO_DATA_TIMEOUT:
 439         case TETHERING_MOCK_GDBUS_SIGNAL_LOW_BATTERY_MODE:
 440         case TETHERING_MOCK_GDBUS_SIGNAL_FLIGHT_MODE:
 441                 break;
 442         case TETHERING_MOCK_GDBUS_SIGNAL_SECURITY_TYPE_CHANGED:
 443                 params = g_variant_new("(s)", "wpa2-psk");
 444                 break;
 445         case TETHERING_MOCK_GDBUS_SIGNAL_SSID_VISIBILITY_CHANGED:
 446                 params = g_variant_new("(s)", "ssid_visible");
 447                 break;
 448         case TETHERING_MOCK_GDBUS_SIGNAL_PASSPHRASE_CHANGED:
 449                 break;
 450         case TETHERING_MOCK_GDBUS_SIGNAL_DHCP_STATUS:
 451                 params = g_variant_new("(susssu)", "DhcpConnected", 1,
 452                                 "192.168.43.24", "ab:cd:ef:ab:cd:ef",
 453                                 "client", 1592460260);
 454                 break;
 455         default:
 456                 break;
 457         }
 458         gdbus_signal_callbacks[signo].callback(NULL, NULL,
 459                         NULL, NULL, gdbus_signal_list[signo],
 460                         params, gdbus_signal_callbacks[signo].user_data);
 461 }
 462 #endif
 463
 464 guint __wrap_g_dbus_connection_signal_subscribe(GDBusConnection  *connection,
 465                 const gchar                     *sender,
 466                 const gchar                     *interface_name,
 467                 const gchar                     *member,
 468                 const gchar                     *object_path,
 469                 const gchar                     *arg0,
 470                 GDBusSignalFlags        flags,
 471                 GDBusSignalCallback     callback,
 472                 gpointer                        user_data,
 473                 GDestroyNotify          user_data_free_func)
 474 {
 475         if (mock_gdbus_result == false)
 476                 return 0;
 477
 478         return 1;
 479 #if 0
 480         if (!member)
 481                 return 0;
 482         for (int i = WIFI_MOCK_GDBUS_SIGNAL_STATE_CHANGED_PROPERTIES; i < WIFI_MOCK_GDBUS_SIGNAL_MAX; i++) {
 483                 if (strcmp(gdbus_signal_list[i], member) == 0) {
 484                         gdbus_signal_callbacks[i].callback = callback;
 485                         gdbus_signal_callbacks[i].user_data = user_data;
 486                         return i;
 487                 }
 488         }
 489         return 0;
 490 #endif
 491 }
 492
 493 void __wrap_g_dbus_connection_signal_unsubscribe(GDBusConnection *connection,
 494                 guint subscription_id)
 495 {
 496         if (mock_gdbus_result == false)
 497                 return;
 498 #if 0
 499         if (subscription_id >= WIFI_MOCK_GDBUS_SIGNAL_STATE_CHANGED_PROPERTIES
 500                         && subscription_id < WIFI_MOCK_GDBUS_SIGNAL_MAX) {
 501                 gdbus_signal_callbacks[subscription_id].callback = NULL;
 502                 gdbus_signal_callbacks[subscription_id].user_data = NULL;
 503         }
 504
 505         return;
 506 #endif
 507 }