android/tester-socket.c

   1 /*
   2  * Copyright (C) 2014 Intel Corporation
   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 #include <fcntl.h>
  19 #include <unistd.h>
  20 #include <stdbool.h>
  21
  22 #include "emulator/bthost.h"
  23 #include "src/shared/tester.h"
  24 #include "src/shared/queue.h"
  25 #include "tester-main.h"
  26
  27 static struct queue *list; /* List of socket test cases */
  28
  29 static bt_bdaddr_t bdaddr_dummy = {
  30         .address = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55}
  31 };
  32
  33 static int got_fd_result = -1;
  34
  35 static struct bt_action_data btsock_param_socktype_0 = {
  36         .addr = &bdaddr_dummy,
  37         .sock_type = 0,
  38         .channel = 1,
  39         .service_uuid = NULL,
  40         .service_name = "Test service",
  41         .flags = 0,
  42         .fd = &got_fd_result,
  43 };
  44
  45 static struct bt_action_data btsock_param_socktype_l2cap = {
  46         .addr = &bdaddr_dummy,
  47         .sock_type = BTSOCK_L2CAP,
  48         .channel = 1,
  49         .service_uuid = NULL,
  50         .service_name = "Test service",
  51         .flags = 0,
  52         .fd = &got_fd_result,
  53 };
  54
  55 static struct bt_action_data btsock_param_channel_0 = {
  56         .addr = &bdaddr_dummy,
  57         .sock_type = BTSOCK_RFCOMM,
  58         .channel = 0,
  59         .service_uuid = NULL,
  60         .service_name = "Test service",
  61         .flags = 0,
  62         .fd = &got_fd_result,
  63 };
  64
  65 static struct bt_action_data btsock_param = {
  66         .addr = &bdaddr_dummy,
  67         .sock_type = BTSOCK_RFCOMM,
  68         .channel = 1,
  69         .service_uuid = NULL,
  70         .service_name = "Test service",
  71         .flags = 0,
  72         .fd = &got_fd_result,
  73 };
  74
  75 static struct bt_action_data btsock_param_inv_bdaddr = {
  76         .addr = NULL,
  77         .sock_type = BTSOCK_RFCOMM,
  78         .channel = 1,
  79         .service_uuid = NULL,
  80         .service_name = "Test service",
  81         .flags = 0,
  82         .fd = &got_fd_result,
  83 };
  84
  85 static bt_bdaddr_t emu_remote_bdaddr_val = {
  86         .address = { 0x00, 0xaa, 0x01, 0x01, 0x00, 0x00 },
  87 };
  88 static bt_property_t prop_emu_remote_bdadr = {
  89         .type = BT_PROPERTY_BDADDR,
  90         .val = &emu_remote_bdaddr_val,
  91         .len = sizeof(emu_remote_bdaddr_val),
  92 };
  93 static bt_property_t prop_emu_remotes_default_set[] = {
  94         { BT_PROPERTY_BDADDR, sizeof(emu_remote_bdaddr_val),
  95                                                 &emu_remote_bdaddr_val },
  96 };
  97
  98 static struct bt_action_data btsock_param_emu_bdaddr = {
  99         .addr = &emu_remote_bdaddr_val,
 100         .sock_type = BTSOCK_RFCOMM,
 101         .channel = 1,
 102         .service_uuid = NULL,
 103         .service_name = "Test service",
 104         .flags = 0,
 105         .fd = &got_fd_result,
 106 };
 107
 108 static struct emu_set_l2cap_data l2cap_setup_data = {
 109         .psm = 0x0003,
 110         .func = NULL,
 111         .user_data = NULL,
 112 };
 113
 114 static struct bt_action_data prop_emu_remote_bdaddr_req = {
 115         .addr = &emu_remote_bdaddr_val,
 116         .prop_type = BT_PROPERTY_BDADDR,
 117         .prop = &prop_emu_remote_bdadr,
 118 };
 119
 120 static void socket_listen_action(void)
 121 {
 122         struct test_data *data = tester_get_data();
 123         struct step *current_data_step = queue_peek_head(data->steps);
 124         struct bt_action_data *action_data = current_data_step->set_data;
 125         struct step *step = g_new0(struct step, 1);
 126
 127         *action_data->fd = -1;
 128
 129         step->action_status = data->if_sock->listen(action_data->sock_type,
 130                                                 action_data->service_name,
 131                                                 action_data->service_uuid,
 132                                                 action_data->channel,
 133                                                 action_data->fd,
 134                                                 action_data->flags);
 135
 136         schedule_action_verification(step);
 137 }
 138
 139 static void socket_connect_action(void)
 140 {
 141         struct test_data *data = tester_get_data();
 142         struct step *current_data_step = queue_peek_head(data->steps);
 143         struct bt_action_data *action_data = current_data_step->set_data;
 144         struct step *step;
 145         int status;
 146
 147         *action_data->fd = -1;
 148
 149         status = data->if_sock->connect(action_data->addr,
 150                                                 action_data->sock_type,
 151                                                 action_data->service_uuid,
 152                                                 action_data->channel,
 153                                                 action_data->fd,
 154                                                 action_data->flags);
 155
 156         tester_print("status %d sock_fd %d", status, *action_data->fd);
 157
 158         if (!status)
 159                 return;
 160
 161         step = g_new0(struct step, 1);
 162         step->action_status = status;
 163
 164         schedule_action_verification(step);
 165 }
 166
 167 static gboolean socket_chan_cb(GIOChannel *io, GIOCondition cond,
 168                                                         gpointer user_data)
 169 {
 170         int sock_fd = g_io_channel_unix_get_fd(io);
 171         struct step *step = g_new0(struct step, 1);
 172         int channel, len;
 173
 174         tester_print("%s", __func__);
 175
 176         if (cond & G_IO_HUP) {
 177                 tester_warn("Socket %d hang up", sock_fd);
 178
 179                 step->action_status = BT_STATUS_FAIL;
 180                 goto done;
 181         }
 182
 183         if (cond & (G_IO_ERR | G_IO_NVAL)) {
 184                 tester_warn("Socket error: sock %d cond %d", sock_fd, cond);
 185
 186                 step->action_status = BT_STATUS_FAIL;
 187                 goto done;
 188         }
 189
 190         len = read(sock_fd, &channel, sizeof(channel));
 191         if (len != sizeof(channel)) {
 192                 tester_warn("Socket read failed");
 193
 194                 step->action_status = BT_STATUS_FAIL;
 195                 goto done;
 196         }
 197
 198         tester_print("read correct channel: %d", channel);
 199
 200         step->action_status = BT_STATUS_SUCCESS;
 201
 202 done:
 203         schedule_action_verification(step);
 204         return FALSE;
 205 }
 206
 207 static void socket_read_fd_action(void)
 208 {
 209         struct test_data *data = tester_get_data();
 210         struct step *current_data_step = queue_peek_head(data->steps);
 211         struct bt_action_data *action_data = current_data_step->set_data;
 212         GIOChannel *io;
 213
 214         io = g_io_channel_unix_new(*action_data->fd);
 215         g_io_channel_set_close_on_unref(io, TRUE);
 216
 217         g_io_add_watch(io, G_IO_IN | G_IO_HUP | G_IO_ERR | G_IO_NVAL,
 218                                                         socket_chan_cb, NULL);
 219
 220         g_io_channel_unref(io);
 221 }
 222
 223 static void socket_verify_fd_action(void)
 224 {
 225         struct test_data *data = tester_get_data();
 226         struct step *current_data_step = queue_peek_head(data->steps);
 227         struct bt_action_data *action_data = current_data_step->set_data;
 228         struct step *step = g_new0(struct step, 1);
 229
 230         if (!*action_data->fd) {
 231                 step->action_status = BT_STATUS_FAIL;
 232                 goto done;
 233         }
 234
 235         step->action_status = (fcntl(*action_data->fd, F_GETFD) < 0) ?
 236                                         BT_STATUS_FAIL : BT_STATUS_SUCCESS;
 237
 238 done:
 239         schedule_action_verification(step);
 240 }
 241
 242 static void socket_verify_channel_action(void)
 243 {
 244         struct test_data *data = tester_get_data();
 245         struct step *current_data_step = queue_peek_head(data->steps);
 246         struct bt_action_data *action_data = current_data_step->set_data;
 247         int channel, len;
 248         struct step *step = g_new0(struct step, 1);
 249
 250         if (!*action_data->fd) {
 251                 tester_warn("Ups no action_data->fd");
 252
 253                 step->action_status = BT_STATUS_FAIL;
 254                 goto done;
 255         }
 256
 257         len = read(*action_data->fd, &channel, sizeof(channel));
 258         if (len != sizeof(channel) || channel != action_data->channel) {
 259                 tester_warn("Ups bad channel");
 260
 261                 step->action_status = BT_STATUS_FAIL;
 262                 goto done;
 263         }
 264
 265         step->action_status = BT_STATUS_SUCCESS;
 266
 267 done:
 268         schedule_action_verification(step);
 269 }
 270
 271 static void socket_close_channel_action(void)
 272 {
 273         struct test_data *data = tester_get_data();
 274         struct step *current_data_step = queue_peek_head(data->steps);
 275         struct bt_action_data *action_data = current_data_step->set_data;
 276         struct step *step = g_new0(struct step, 1);
 277
 278         if (!*action_data->fd) {
 279                 tester_warn("Ups no action_data->fd");
 280
 281                 step->action_status = BT_STATUS_FAIL;
 282                 goto done;
 283         }
 284
 285         close(*action_data->fd);
 286         *action_data->fd = -1;
 287
 288         step->action_status = BT_STATUS_SUCCESS;
 289
 290 done:
 291         schedule_action_verification(step);
 292 }
 293
 294 static struct test_case test_cases[] = {
 295         TEST_CASE_BREDRLE("Socket Init",
 296                 ACTION_SUCCESS(dummy_action, NULL),
 297         ),
 298         TEST_CASE_BREDRLE("Socket Listen - Invalid: sock_type 0",
 299                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 300                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 301                 ACTION(BT_STATUS_PARM_INVALID, socket_listen_action,
 302                                                 &btsock_param_socktype_0),
 303                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 304                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 305         ),
 306         TEST_CASE_BREDRLE("Socket Listen - Invalid: sock_type L2CAP",
 307                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 308                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 309                 ACTION(BT_STATUS_UNSUPPORTED, socket_listen_action,
 310                                                 &btsock_param_socktype_l2cap),
 311                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 312                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 313         ),
 314         TEST_CASE_BREDRLE("Socket Listen - Invalid: chan, uuid",
 315                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 316                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 317                 ACTION(BT_STATUS_PARM_INVALID, socket_listen_action,
 318                                                 &btsock_param_channel_0),
 319                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 320                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 321         ),
 322         TEST_CASE_BREDRLE("Socket Listen - Check returned fd valid",
 323                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 324                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 325                 ACTION_SUCCESS(socket_listen_action, &btsock_param),
 326                 ACTION_SUCCESS(socket_verify_fd_action, &btsock_param),
 327                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 328                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 329         ),
 330         TEST_CASE_BREDRLE("Socket Listen - Check returned channel",
 331                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 332                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 333                 ACTION_SUCCESS(socket_listen_action, &btsock_param),
 334                 ACTION_SUCCESS(socket_verify_fd_action, &btsock_param),
 335                 ACTION_SUCCESS(socket_verify_channel_action, &btsock_param),
 336                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 337                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 338         ),
 339         TEST_CASE_BREDRLE("Socket Listen - Close and Listen again",
 340                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 341                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 342                 ACTION_SUCCESS(socket_listen_action, &btsock_param),
 343                 ACTION_SUCCESS(socket_verify_fd_action, &btsock_param),
 344                 ACTION_SUCCESS(socket_verify_channel_action, &btsock_param),
 345                 ACTION_SUCCESS(socket_close_channel_action, &btsock_param),
 346                 ACTION_SUCCESS(socket_listen_action, &btsock_param),
 347                 ACTION_SUCCESS(socket_verify_fd_action, &btsock_param),
 348                 ACTION_SUCCESS(socket_verify_channel_action, &btsock_param),
 349                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 350                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 351         ),
 352         TEST_CASE_BREDRLE("Socket Listen - Invalid: double Listen",
 353                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 354                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 355                 ACTION_SUCCESS(socket_listen_action, &btsock_param),
 356                 ACTION_SUCCESS(socket_verify_fd_action, &btsock_param),
 357                 ACTION_SUCCESS(socket_verify_channel_action, &btsock_param),
 358                 ACTION(BT_STATUS_BUSY, socket_listen_action, &btsock_param),
 359                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 360                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 361         ),
 362         TEST_CASE_BREDRLE("Socket Connect - Invalid: sock_type 0",
 363                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 364                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 365                 ACTION(BT_STATUS_PARM_INVALID, socket_connect_action,
 366                                                 &btsock_param_socktype_0),
 367                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 368                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 369         ),
 370         TEST_CASE_BREDRLE("Socket Connect - Invalid: sock_type L2CAP",
 371                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 372                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 373                 ACTION(BT_STATUS_UNSUPPORTED, socket_connect_action,
 374                                                 &btsock_param_socktype_l2cap),
 375                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 376                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 377         ),
 378         TEST_CASE_BREDRLE("Socket Connect - Invalid: chan, uuid",
 379                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 380                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 381                 ACTION(BT_STATUS_PARM_INVALID, socket_connect_action,
 382                                                 &btsock_param_channel_0),
 383                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 384                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 385         ),
 386         TEST_CASE_BREDRLE("Socket Connect - Invalid: bdaddr",
 387                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 388                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 389                 ACTION(BT_STATUS_PARM_INVALID, socket_connect_action,
 390                                                 &btsock_param_inv_bdaddr),
 391                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 392                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 393         ),
 394         TEST_CASE_BREDRLE("Socket Connect - Check returned fd valid",
 395                 ACTION_SUCCESS(set_default_ssp_request_handler, NULL),
 396                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 397                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 398                 ACTION_SUCCESS(emu_setup_powered_remote_action, NULL),
 399                 ACTION_SUCCESS(emu_set_ssp_mode_action, NULL),
 400                 ACTION_SUCCESS(bt_create_bond_action,
 401                                                 &prop_emu_remote_bdaddr_req),
 402                 CALLBACK_BOND_STATE(BT_BOND_STATE_BONDING,
 403                                                 &prop_emu_remote_bdadr, 1),
 404                 CALLBACK_DEVICE_FOUND(prop_emu_remotes_default_set, 1),
 405                 CALLBACK_BOND_STATE(BT_BOND_STATE_BONDED,
 406                                                 &prop_emu_remote_bdadr, 1),
 407                 CALLBACK_DEVICE_PROPS(NULL, 0),
 408                 ACTION_SUCCESS(emu_add_l2cap_server_action, &l2cap_setup_data),
 409                 ACTION_SUCCESS(emu_add_rfcomm_server_action,
 410                                                 &btsock_param_emu_bdaddr),
 411                 ACTION_SUCCESS(socket_connect_action, &btsock_param_emu_bdaddr),
 412                 ACTION_SUCCESS(socket_verify_fd_action,
 413                                                 &btsock_param_emu_bdaddr),
 414                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 415                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 416         ),
 417         TEST_CASE_BREDRLE("Socket Connect - Check returned chann",
 418                 ACTION_SUCCESS(set_default_ssp_request_handler, NULL),
 419                 ACTION_SUCCESS(bluetooth_enable_action, NULL),
 420                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_ON),
 421                 ACTION_SUCCESS(emu_setup_powered_remote_action, NULL),
 422                 ACTION_SUCCESS(emu_set_ssp_mode_action, NULL),
 423                 ACTION_SUCCESS(bt_create_bond_action,
 424                                                 &prop_emu_remote_bdaddr_req),
 425                 CALLBACK_BOND_STATE(BT_BOND_STATE_BONDING,
 426                                                 &prop_emu_remote_bdadr, 1),
 427                 CALLBACK_DEVICE_FOUND(prop_emu_remotes_default_set, 1),
 428                 CALLBACK_BOND_STATE(BT_BOND_STATE_BONDED,
 429                                                 &prop_emu_remote_bdadr, 1),
 430                 CALLBACK_DEVICE_PROPS(NULL, 0),
 431                 ACTION_SUCCESS(emu_add_l2cap_server_action, &l2cap_setup_data),
 432                 ACTION_SUCCESS(emu_add_rfcomm_server_action,
 433                                                 &btsock_param_emu_bdaddr),
 434                 ACTION_SUCCESS(socket_connect_action, &btsock_param_emu_bdaddr),
 435                 ACTION_SUCCESS(socket_verify_fd_action,
 436                                                 &btsock_param_emu_bdaddr),
 437                 ACTION_SUCCESS(socket_verify_channel_action,
 438                                                 &btsock_param_emu_bdaddr),
 439                 ACTION_SUCCESS(socket_read_fd_action, &btsock_param_emu_bdaddr),
 440                 ACTION_SUCCESS(bluetooth_disable_action, NULL),
 441                 CALLBACK_STATE(CB_BT_ADAPTER_STATE_CHANGED, BT_STATE_OFF),
 442         ),
 443 };
 444
 445 struct queue *get_socket_tests(void)
 446 {
 447         uint16_t i = 0;
 448
 449         list = queue_new();
 450
 451         for (; i < sizeof(test_cases) / sizeof(test_cases[0]); ++i)
 452                 queue_push_tail(list, &test_cases[i]);
 453
 454         return list;
 455 }
 456
 457 void remove_socket_tests(void)
 458 {
 459         queue_destroy(list, NULL);
 460 }