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 if (sco_listen) { 192 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 193 fprintf(stdout, "BT adapter is up\n"); 194 195 bt_property_t *property = property_new_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE); 196 CALL_AND_WAIT(bt_interface->set_adapter_property(property), adapter_properties); 197 property_free(property); 198 199 const btsock_interface_t *sock = bt_interface->get_profile_interface(BT_PROFILE_SOCKETS_ID); 200 201 int rfcomm_fd = INVALID_FD; 202 int error = sock->listen(BTSOCK_RFCOMM, "meow", (const uint8_t *)&HFP_AG_UUID, 0, &rfcomm_fd, 0); 203 if (error != BT_STATUS_SUCCESS) { 204 fprintf(stderr, "Unable to listen for incoming RFCOMM socket: %d\n", error); 205 exit(1); 206 } 207 208 int sock_fd = INVALID_FD; 209 error = sock->listen(BTSOCK_SCO, NULL, NULL, 5, &sock_fd, 0); 210 if (error != BT_STATUS_SUCCESS) { 211 fprintf(stderr, "Unable to listen for incoming SCO sockets: %d\n", error); 212 exit(1); 213 } 214 fprintf(stdout, "Waiting for incoming SCO connections...\n"); 215 sleep(timeout_in_sec); 216 } 217 218 if (sco_connect) { 219 if (bdaddr_is_empty(&bt_remote_bdaddr)) { 220 fprintf(stderr, "Must specify a remote device address [ --bdaddr=xx:yy:zz:aa:bb:cc ]\n"); 221 exit(1); 222 } 223 224 CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed); 225 fprintf(stdout, "BT adapter is up\n"); 226 227 const btsock_interface_t *sock = bt_interface->get_profile_interface(BT_PROFILE_SOCKETS_ID); 228 229 int rfcomm_fd = INVALID_FD; 230 int error = sock->connect(&bt_remote_bdaddr, BTSOCK_RFCOMM, (const uint8_t *)&HFP_AG_UUID, 0, &rfcomm_fd, 0); 231 if (error != BT_STATUS_SUCCESS) { 232 fprintf(stderr, "Unable to connect to RFCOMM socket: %d.\n", error); 233 exit(1); 234 } 235 236 WAIT(acl_state_changed); 237 238 fprintf(stdout, "Establishing SCO connection...\n"); 239 240 int sock_fd = INVALID_FD; 241 error = sock->connect(&bt_remote_bdaddr, BTSOCK_SCO, NULL, 5, &sock_fd, 0); 242 if (error != BT_STATUS_SUCCESS) { 243 fprintf(stderr, "Unable to connect to SCO socket: %d.\n", error); 244 exit(1); 245 } 246 sleep(timeout_in_sec); 247 } 248 249 CALL_AND_WAIT(bt_interface->disable(), adapter_state_changed); 250 fprintf(stdout, "BT adapter is down\n"); 251 } 252 253 static void sig_handler(int signo) { 254 if (signo == SIGINT) { 255 fprintf(stderr, "Received SIGINT\n"); 256 CALL_AND_WAIT(bt_interface->disable(), adapter_state_changed); 257 fprintf(stderr, "BT adapter is down\n"); 258 exit(1); 259 } 260 } 261 262 static void usage(const char *name) { 263 fprintf(stderr, "Usage: %s [--bond|--discover|--discoverable|--up|--sco_listen|--sco_connect] [--bdaddr=<bdaddr>] [--time=<time_in_sec>] --verbose\n", name); 264 fprintf(stderr, " bond: Discover actively advertising devices\n"); 265 fprintf(stderr, " discover: Discover actively advertising devices\n"); 266 fprintf(stderr, " discoverable: Set into a connectable and discoverable mode\n"); 267 fprintf(stderr, " up: Only bring up stack\n"); 268 fprintf(stderr, " sco_listen: Listen for incoming SCO connections\n"); 269 fprintf(stderr, " sco_connect: Establish a SCO connection with another device\n"); 270 fprintf(stderr, " time: Time to hold in the specified mode\n"); 271 exit(1); 272 } 273 274 static bool parse_args(int argc, char **argv) { 275 while (1) { 276 int option_index = 0; 277 int c = getopt_long_only(argc, argv, "", long_options, &option_index); 278 if (c != 0) 279 break; 280 281 switch (c) { 282 case 0: 283 if (option_index == 0) { 284 if (!string_to_bdaddr(optarg, &bt_remote_bdaddr)) { 285 return false; 286 } 287 } 288 if (option_index == 1) { 289 discover = true; 290 } 291 if (option_index == 2) { 292 discoverable = true; 293 } 294 if (option_index == 3) { 295 timeout_in_sec = atoi(optarg); 296 } 297 if (option_index == 4) { 298 bond = true; 299 } 300 if (option_index == 5) { 301 up = true; 302 } 303 if (option_index == 6) { 304 f_verbose++; 305 } 306 if (option_index == 7) { 307 get_name = true; 308 } 309 if (option_index == 8) { 310 bd_name = (char *)optarg; 311 set_name = true; 312 } 313 if (option_index == 9) { 314 sco_listen = true; 315 } 316 if (option_index == 10) { 317 sco_connect = true; 318 } 319 break; 320 321 default: 322 fprintf(stderr, "?? getopt returned character code 0%o ??\n", c); 323 } 324 } 325 326 if (optind < argc) { 327 fprintf(stderr, "non-option ARGV-elements: "); 328 while (optind < argc) 329 fprintf(stderr, "%s ", argv[optind++]); 330 fprintf(stderr, "\n"); 331 return false; 332 } 333 return true; 334 } 335
