int btstack_main(int argc, const char * argv[]){
#ifdef TABLE_SIZE
compute_signal();
#endif
hci_register_sco_packet_handler(&sco_packet_handler);
hci_discoverable_control(1);
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
gap_set_local_name("BTstack HSP HS");
hsp_hs_init(rfcomm_channel_nr);
hsp_hs_register_packet_handler(packet_handler);
sdp_init();
memset((uint8_t *)hsp_service_buffer, 0, sizeof(hsp_service_buffer));
hsp_hs_create_service((uint8_t *)hsp_service_buffer, rfcomm_channel_nr, hsp_hs_service_name, 0);
sdp_register_service_internal(NULL, (uint8_t *)hsp_service_buffer);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
one_shot_timer_setup();
spp_service_setup();
hci_discoverable_control(1);
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
gap_set_local_name("BTstack SPP Counter");
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
printf("Starting up..\n");
hci_set_class_of_device(0x200404);
hci_disable_l2cap_timeout_check();
hci_ssp_set_io_capability(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
gap_io_capabilities = "IO_CAPABILITY_NO_INPUT_NO_OUTPUT";
hci_ssp_set_authentication_requirement(0);
hci_ssp_set_auto_accept(0);
// gap_set_bondable_mode(0);
l2cap_init();
l2cap_register_packet_handler(&packet_handler2);
l2cap_register_fixed_channel(&packet_handler, L2CAP_CID_CONNECTIONLESS_CHANNEL);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler2);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 150); // reserved channel, mtu=100
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
sdp_create_spp_service((uint8_t*) spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
de_dump_data_element((uint8_t*) spp_service_buffer);
printf("SDP service record size: %u\n\r", de_get_len((uint8_t*)spp_service_buffer));
sdp_register_service_internal(NULL, (uint8_t*)spp_service_buffer);
memset(dummy_service_buffer, 0, sizeof(dummy_service_buffer));
sdp_create_dummy_service((uint8_t*)dummy_service_buffer, "UUID128 Test");
de_dump_data_element((uint8_t*)dummy_service_buffer);
printf("Dummy service record size: %u\n\r", de_get_len((uint8_t*)dummy_service_buffer));
sdp_register_service_internal(NULL, (uint8_t*)dummy_service_buffer);
sdp_query_rfcomm_register_callback(handle_query_rfcomm_event, NULL);
hci_discoverable_control(0);
hci_connectable_control(0);
// turn on!
hci_power_control(HCI_POWER_ON);
btstack_stdin_setup(stdin_process);
// set one-shot timer
// timer_source_t heartbeat;
// heartbeat.process = &heartbeat_handler;
// run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
// run_loop_add_timer(&heartbeat);
return 0;
}
int btstack_main(void)
{
hci_discoverable_control(1);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 0xffff);
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
/* LISTING_PAUSE */
#ifdef EMBEDDED
/* LISTING_RESUME */
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
/* LISTING_PAUSE */
#else
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
#endif
/* LISTING_RESUME */
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
// setup le device db
le_device_db_init();
// setup SM: Display only
sm_init();
// setup ATT server
att_server_init(profile_data, att_read_callback, att_write_callback);
att_dump_attributes();
// set one-shot timer
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// turn on!
hci_power_control(HCI_POWER_ON);
return 0;
}
int btstack_main(int argc, const char * argv[]){
hci_discoverable_control(1);
l2cap_init();
l2cap_register_packet_handler(packet_handler);
rfcomm_init();
rfcomm_register_packet_handler(packet_handler);
rfcomm_register_service_internal(NULL, RFCOMM_SERVER_CHANNEL, 0xffff); // reserved channel, mtu limited by l2cap
// init SDP, create record for SPP and register with SDP
sdp_init();
memset(spp_service_buffer, 0, sizeof(spp_service_buffer));
#ifdef EMBEDDED
service_record_item_t * service_record_item = (service_record_item_t *) spp_service_buffer;
sdp_create_spp_service( (uint8_t*) &service_record_item->service_record, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service buffer size: %u\n", (uint16_t) (sizeof(service_record_item_t) + de_get_len((uint8_t*) &service_record_item->service_record)));
sdp_register_service_internal(NULL, service_record_item);
#else
sdp_create_spp_service( spp_service_buffer, RFCOMM_SERVER_CHANNEL, "SPP Counter");
printf("SDP service record size: %u\n", de_get_len(spp_service_buffer));
sdp_register_service_internal(NULL, spp_service_buffer);
#endif
hci_ssp_set_io_capability(SSP_IO_CAPABILITY_DISPLAY_YES_NO);
// set one-shot timer
timer_source_t heartbeat;
heartbeat.process = &heartbeat_handler;
run_loop_set_timer(&heartbeat, HEARTBEAT_PERIOD_MS);
run_loop_add_timer(&heartbeat);
// turn on!
hci_power_control(HCI_POWER_ON);
// go!
run_loop_execute();
// happy compiler!
return 0;
}
int stdin_process(struct data_source *ds){
char buffer;
read(ds->fd, &buffer, 1);
// passkey input
if (ui_digits_for_passkey){
if (buffer < '0' || buffer > '9') return 0;
printf("%c", buffer);
fflush(stdout);
ui_passkey = ui_passkey * 10 + buffer - '0';
ui_digits_for_passkey--;
if (ui_digits_for_passkey == 0){
printf("\nSending Passkey '%06u'\n", ui_passkey);
hci_send_cmd(&hci_user_passkey_request_reply, remote, ui_passkey);
}
return 0;
}
if (ui_chars_for_pin){
printf("%c", buffer);
fflush(stdout);
if (buffer == '\n'){
printf("\nSending Pin '%s'\n", ui_pin);
hci_send_cmd(&hci_pin_code_request_reply, remote, ui_pin_offset, ui_pin);
} else {
ui_pin[ui_pin_offset++] = buffer;
}
return 0;
}
switch (buffer){
case 'c':
gap_connectable = 0;
hci_connectable_control(0);
show_usage();
break;
case 'C':
gap_connectable = 1;
hci_connectable_control(1);
show_usage();
break;
case 'd':
gap_discoverable = 0;
hci_discoverable_control(0);
show_usage();
break;
case 'D':
gap_discoverable = 1;
hci_discoverable_control(1);
show_usage();
break;
case 'b':
gap_bondable = 0;
// gap_set_bondable_mode(0);
update_auth_req();
show_usage();
break;
case 'B':
gap_bondable = 1;
// gap_set_bondable_mode(1);
update_auth_req();
show_usage();
break;
case 'm':
gap_mitm_protection = 0;
update_auth_req();
show_usage();
break;
case 'M':
gap_mitm_protection = 1;
update_auth_req();
show_usage();
break;
case '<':
gap_dedicated_bonding_mode = 0;
update_auth_req();
show_usage();
break;
case '>':
gap_dedicated_bonding_mode = 1;
update_auth_req();
show_usage();
break;
case 'e':
gap_io_capabilities = "IO_CAPABILITY_DISPLAY_ONLY";
hci_ssp_set_io_capability(IO_CAPABILITY_DISPLAY_ONLY);
show_usage();
break;
case 'f':
gap_io_capabilities = "IO_CAPABILITY_DISPLAY_YES_NO";
hci_ssp_set_io_capability(IO_CAPABILITY_DISPLAY_YES_NO);
show_usage();
break;
case 'g':
gap_io_capabilities = "IO_CAPABILITY_NO_INPUT_NO_OUTPUT";
hci_ssp_set_io_capability(IO_CAPABILITY_NO_INPUT_NO_OUTPUT);
show_usage();
break;
case 'h':
gap_io_capabilities = "IO_CAPABILITY_KEYBOARD_ONLY";
hci_ssp_set_io_capability(IO_CAPABILITY_KEYBOARD_ONLY);
show_usage();
break;
case 'i':
start_scan();
break;
case 'j':
printf("Start dedicated bonding to %s using MITM %u\n", bd_addr_to_str(remote), gap_mitm_protection);
gap_dedicated_bonding(remote, gap_mitm_protection);
break;
case 'z':
printf("Start dedicated bonding to %s using legacy pairing\n", bd_addr_to_str(remote));
gap_dedicated_bonding(remote, gap_mitm_protection);
break;
case 'y':
printf("Disabling SSP for this session\n");
hci_send_cmd(&hci_write_simple_pairing_mode, 0);
break;
case 'k':
printf("Start SDP query for SPP service\n");
sdp_query_rfcomm_channel_and_name_for_uuid(remote_rfcomm, 0x1101);
break;
case 't':
printf("Terminate connection with handle 0x%04x\n", handle);
hci_send_cmd(&hci_disconnect, handle, 0x13); // remote closed connection
break;
case 'p':
printf("Creating HCI Connection to %s\n", bd_addr_to_str(remote));
hci_send_cmd(&hci_create_connection, remote, hci_usable_acl_packet_types(), 0, 0, 0, 1);
break;
// printf("Creating L2CAP Connection to %s, PSM SDP\n", bd_addr_to_str(remote));
// l2cap_create_channel_internal(NULL, packet_handler, remote, PSM_SDP, 100);
// break;
// case 'u':
// printf("Creating L2CAP Connection to %s, PSM 3\n", bd_addr_to_str(remote));
// l2cap_create_channel_internal(NULL, packet_handler, remote, 3, 100);
// break;
case 'q':
printf("Send L2CAP Data\n");
l2cap_send_internal(local_cid, (uint8_t *) "0123456789", 10);
break;
case 'r':
printf("Send L2CAP ECHO Request\n");
l2cap_send_echo_request(handle, (uint8_t *) "Hello World!", 13);
break;
case 's':
printf("L2CAP Channel Closed\n");
l2cap_disconnect_internal(local_cid, 0);
break;
case 'x':
printf("Outgoing L2CAP Channels to SDP will also require SSP\n");
l2cap_require_security_level_2_for_outgoing_sdp();
break;
case 'l':
printf("Creating RFCOMM Channel to %s #%u\n", bd_addr_to_str(remote_rfcomm), rfcomm_channel_nr);
rfcomm_create_channel_internal(NULL, remote_rfcomm, rfcomm_channel_nr);
break;
case 'n':
printf("Send RFCOMM Data\n"); // mtu < 60
rfcomm_send_internal(rfcomm_channel_id, (uint8_t *) "012345678901234567890123456789012345678901234567890123456789", mtu);
break;
case 'u':
printf("Sending RLS indicating framing error\n"); // mtu < 60
rfcomm_send_local_line_status(rfcomm_channel_id, 9);
break;
case 'v':
printf("Sending RPN CMD to select 115200 baud\n"); // mtu < 60
rfcomm_send_port_configuration(rfcomm_channel_id, RPN_BAUD_115200, RPN_DATA_BITS_8, RPN_STOP_BITS_1_0, RPN_PARITY_NONE, 0);
break;
case 'w':
printf("Sending RPN REQ to query remote port settings\n"); // mtu < 60
rfcomm_query_port_configuration(rfcomm_channel_id);
break;
case 'o':
printf("RFCOMM Channel Closed\n");
rfcomm_disconnect_internal(rfcomm_channel_id);
rfcomm_channel_id = 0;
break;
case '+':
printf("Initiate SSP on current connection\n");
gap_request_security_level(handle, LEVEL_2);
break;
case '*':
printf("Sending SSP User Confirmation for %s\n", bd_addr_to_str(remote));
hci_send_cmd(&hci_user_confirmation_request_reply, remote);
break;
case '=':
printf("Deleting Link Key for %s\n", bd_addr_to_str(remote));
hci_drop_link_key_for_bd_addr(remote);
break;
case 'U':
printf("Sending UCD data on handle 0x%04x\n", handle);
send_ucd_packet();
break;
case 'Q':
printf("Closing HCI Connection to handle 0x%04x\n", handle);
gap_disconnect(handle);
break;
default:
show_usage();
break;
}
return 0;
}
