1 /****************************************************************************** 2 * 3 * Copyright (C) 2014 Google, Inc. 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 #include <getopt.h> 20 #include <signal.h> 21 #include <stdlib.h> 22 #include <unistd.h> 23 24 #include "btcore/include/bdaddr.h" 25 #include "btcore/include/property.h" 26 #include "osi/include/osi.h" 27 #include "test/suite/support/callbacks.h" 28 #include "test/suite/support/hal.h" 29 30 static const bt_uuid_t HFP_UUID = {{ 0x00, 0x00, 0x11, 0x1E, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB }}; 31 static const bt_uuid_t HFP_AG_UUID = {{ 0x00, 0x00, 0x11, 0x1F, 0x00, 0x00, 0x10, 0x00, 0x80, 0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB }}; 32 33 const bt_interface_t *bt_interface; 34 35 bt_bdaddr_t bt_remote_bdaddr; 36 37 static int f_verbose; 38 static bool discover = false; 39 static bool discoverable = false; 40 static bool bond = false; 41 static bool up = false; 42 static bool get_name = false; 43 static bool set_name = false; 44 static bool sco_listen = false; 45 static bool sco_connect = false; 46 47 static int timeout_in_sec = 30; 48 static char *bd_name; 49 50 static struct option long_options[] = { 51 {"bdaddr", required_argument, 0, 0 }, 52 {"discover", no_argument, 0, 0 }, 53 {"discoverable", no_argument, 0, 0 }, 54 {"time", required_argument, 0, 0 }, 55 {"bond", no_argument, 0, 0 }, 56 {"up", no_argument, 0, 0 }, 57 {"verbose", no_argument, 0, 0 }, 58 {"get_name", no_argument, 0, 0 }, 59 {"set_name", required_argument, 0, 0 }, 60 {"sco_listen", no_argument, 0, 0 }, 61 {"sco_connect", no_argument, 0, 0 }, 62 {0, 0, 0, 0 } 63 }; 64 65 static void usage(const char *name); 66 static bool parse_args(int argc, char **argv); 67 static void sig_handler(int signo); 68 69 bt_property_t *adapter_get_property(bt_property_type_t type); 70 71 int main(int argc, char **argv) { 72 if (!parse_args(argc, argv)) { 73 usage(argv[0]); 74 } 75 76 if (bond && discoverable) { 77 fprintf(stderr, "Can only select either bond or discoverable, not both\n"); 78 usage(argv[0]); 79 } 80 81 if (sco_listen && sco_connect) { 82 fprintf(stderr, "Can only select either sco_listen or sco_connect, not both\n"); 83 usage(argv[0]); 84 } 85 86 if (!bond && !discover && !discoverable && !up && !get_name && !set_name && !sco_listen && !sco_connect) { 87 fprintf(stderr, "Must specify one command\n"); 88 usage(argv[0]); 89 } 90 91 if (signal(SIGINT, sig_handler) == SIG_ERR) { 92 fprintf(stderr, "Will be unable to catch signals\n"); 93 } 94 95 fprintf(stdout, "Bringing up bluetooth adapter\n"); 96 if (!hal_open(callbacks_get_adapter_struct())) { 97 fprintf(stderr, "Unable to open Bluetooth HAL.\n"); 98 return 1; 99 } 100 101 if (discover) { 102 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 103 fprintf(stdout, "BT adapter is up\n"); 104 105 fprintf(stdout, "Starting to start discovery\n"); 106 CALL_AND_WAIT(bt_interface->start_discovery(), discovery_state_changed); 107 fprintf(stdout, "Started discovery for %d seconds\n", timeout_in_sec); 108 109 sleep(timeout_in_sec); 110 111 fprintf(stdout, "Starting to cancel discovery\n"); 112 CALL_AND_WAIT(bt_interface->cancel_discovery(), discovery_state_changed); 113 fprintf(stdout, "Cancelled discovery after %d seconds\n", timeout_in_sec); 114 } 115 116 if (discoverable) { 117 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 118 fprintf(stdout, "BT adapter is up\n"); 119 120 bt_property_t *property = property_new_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE); 121 122 int rc = bt_interface->set_adapter_property(property); 123 fprintf(stdout, "Set rc:%d device as discoverable for %d seconds\n", rc, timeout_in_sec); 124 125 sleep(timeout_in_sec); 126 127 property_free(property); 128 } 129 130 if (bond) { 131 if (bdaddr_is_empty(&bt_remote_bdaddr)) { 132 fprintf(stderr, "Must specify a remote device address [ --bdaddr=xx:yy:zz:aa:bb:cc ]\n"); 133 exit(1); 134 } 135 136 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 137 fprintf(stdout, "BT adapter is up\n"); 138 139 int rc = bt_interface->create_bond(&bt_remote_bdaddr, 0 /* UNKNOWN; Currently not documented :( */); 140 fprintf(stdout, "Started bonding:%d for %d seconds\n", rc, timeout_in_sec); 141 142 sleep(timeout_in_sec); 143 } 144 145 if (up) { 146 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 147 fprintf(stdout, "BT adapter is up\n"); 148 149 fprintf(stdout, "Waiting for %d seconds\n", timeout_in_sec); 150 sleep(timeout_in_sec); 151 } 152 153 if (get_name) { 154 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 155 fprintf(stdout, "BT adapter is up\n"); 156 int error; 157 CALL_AND_WAIT(error = bt_interface->get_adapter_property(BT_PROPERTY_BDNAME), adapter_properties); 158 if (error != BT_STATUS_SUCCESS) { 159 fprintf(stderr, "Unable to get adapter property\n"); 160 exit(1); 161 } 162 bt_property_t *property = adapter_get_property(BT_PROPERTY_BDNAME); 163 const bt_bdname_t *name = property_as_name(property); 164 if (name) 165 printf("Queried bluetooth device name:%s\n", name->name); 166 else 167 printf("No name\n"); 168 } 169 170 if (set_name) { 171 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 172 fprintf(stdout, "BT adapter is up\n"); 173 174 bt_property_t *property = property_new_name(bd_name); 175 printf("Setting bluetooth device name to:%s\n", bd_name); 176 int error; 177 CALL_AND_WAIT(error = bt_interface->set_adapter_property(property), adapter_properties); 178 if (error != BT_STATUS_SUCCESS) { 179 fprintf(stderr, "Unable to set adapter property\n"); 180 exit(1); 181 } 182 CALL_AND_WAIT(error = bt_interface->get_adapter_property(BT_PROPERTY_BDNAME), adapter_properties); 183 if (error != BT_STATUS_SUCCESS) { 184 fprintf(stderr, "Unable to get adapter property\n"); 185 exit(1); 186 } 187 property_free(property); 188 sleep(timeout_in_sec); 189 } 190 191 const int app_uid = 0; 192 193 if (sco_listen) { 194 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 195 fprintf(stdout, "BT adapter is up\n"); 196 197 bt_property_t *property = property_new_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE); 198 CALL_AND_WAIT(bt_interface->set_adapter_property(property), adapter_properties); 199 property_free(property); 200 201 const btsock_interface_t *sock = bt_interface->get_profile_interface(BT_PROFILE_SOCKETS_ID); 202 203 int rfcomm_fd = INVALID_FD; 204 int error = sock->listen(BTSOCK_RFCOMM, "meow", (const uint8_t *)&HFP_AG_UUID, 0, &rfcomm_fd, 0, app_uid); 205 if (error != BT_STATUS_SUCCESS) { 206 fprintf(stderr, "Unable to listen for incoming RFCOMM socket: %d\n", error); 207 exit(1); 208 } 209 210 int sock_fd = INVALID_FD; 211 error = sock->listen(BTSOCK_SCO, NULL, NULL, 5, &sock_fd, 0, app_uid); 212 if (error != BT_STATUS_SUCCESS) { 213 fprintf(stderr, "Unable to listen for incoming SCO sockets: %d\n", error); 214 exit(1); 215 } 216 fprintf(stdout, "Waiting for incoming SCO connections...\n"); 217 sleep(timeout_in_sec); 218 } 219 220 if (sco_connect) { 221 if (bdaddr_is_empty(&bt_remote_bdaddr)) { 222 fprintf(stderr, "Must specify a remote device address [ --bdaddr=xx:yy:zz:aa:bb:cc ]\n"); 223 exit(1); 224 } 225 226 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 227 fprintf(stdout, "BT adapter is up\n"); 228 229 const btsock_interface_t *sock = bt_interface->get_profile_interface(BT_PROFILE_SOCKETS_ID); 230 231 int rfcomm_fd = INVALID_FD; 232 int error = sock->connect(&bt_remote_bdaddr, BTSOCK_RFCOMM, (const uint8_t *)&HFP_AG_UUID, 0, &rfcomm_fd, 0, app_uid); 233 if (error != BT_STATUS_SUCCESS) { 234 fprintf(stderr, "Unable to connect to RFCOMM socket: %d.\n", error); 235 exit(1); 236 } 237 238 WAIT(acl_state_changed); 239 240 fprintf(stdout, "Establishing SCO connection...\n"); 241 242 int sock_fd = INVALID_FD; 243 error = sock->connect(&bt_remote_bdaddr, BTSOCK_SCO, NULL, 5, &sock_fd, 0, app_uid); 244 if (error != BT_STATUS_SUCCESS) { 245 fprintf(stderr, "Unable to connect to SCO socket: %d.\n", error); 246 exit(1); 247 } 248 sleep(timeout_in_sec); 249 } 250 251 CALL_AND_WAIT(bt_interface->disable(), adapter_state_changed); 252 fprintf(stdout, "BT adapter is down\n"); 253 } 254 255 static void sig_handler(int signo) { 256 if (signo == SIGINT) { 257 fprintf(stderr, "Received SIGINT\n"); 258 CALL_AND_WAIT(bt_interface->disable(), adapter_state_changed); 259 fprintf(stderr, "BT adapter is down\n"); 260 exit(1); 261 } 262 } 263 264 static void usage(const char *name) { 265 fprintf(stderr, "Usage: %s [--bond|--discover|--discoverable|--up|--sco_listen|--sco_connect] [--bdaddr=<bdaddr>] [--time=<time_in_sec>] --verbose\n", name); 266 fprintf(stderr, " bond: Discover actively advertising devices\n"); 267 fprintf(stderr, " discover: Discover actively advertising devices\n"); 268 fprintf(stderr, " discoverable: Set into a connectable and discoverable mode\n"); 269 fprintf(stderr, " up: Only bring up stack\n"); 270 fprintf(stderr, " sco_listen: Listen for incoming SCO connections\n"); 271 fprintf(stderr, " sco_connect: Establish a SCO connection with another device\n"); 272 fprintf(stderr, " time: Time to hold in the specified mode\n"); 273 exit(1); 274 } 275 276 static bool parse_args(int argc, char **argv) { 277 while (1) { 278 int option_index = 0; 279 int c = getopt_long_only(argc, argv, "", long_options, &option_index); 280 if (c != 0) 281 break; 282 283 switch (c) { 284 case 0: 285 if (option_index == 0) { 286 if (!string_to_bdaddr(optarg, &bt_remote_bdaddr)) { 287 return false; 288 } 289 } 290 if (option_index == 1) { 291 discover = true; 292 } 293 if (option_index == 2) { 294 discoverable = true; 295 } 296 if (option_index == 3) { 297 timeout_in_sec = atoi(optarg); 298 } 299 if (option_index == 4) { 300 bond = true; 301 } 302 if (option_index == 5) { 303 up = true; 304 } 305 if (option_index == 6) { 306 f_verbose++; 307 } 308 if (option_index == 7) { 309 get_name = true; 310 } 311 if (option_index == 8) { 312 bd_name = (char *)optarg; 313 set_name = true; 314 } 315 if (option_index == 9) { 316 sco_listen = true; 317 } 318 if (option_index == 10) { 319 sco_connect = true; 320 } 321 break; 322 323 default: 324 fprintf(stderr, "?? getopt returned character code 0%o ??\n", c); 325 } 326 } 327 328 if (optind < argc) { 329 fprintf(stderr, "non-option ARGV-elements: "); 330 while (optind < argc) 331 fprintf(stderr, "%s ", argv[optind++]); 332 fprintf(stderr, "\n"); 333 return false; 334 } 335 return true; 336 } 337
