int main(int argc, char *argv[])
{
struct vhci *vhci;
struct server *server;
sigset_t mask;
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
vhci = vhci_open(VHCI_TYPE_BREDR, 0x23);
if (!vhci) {
fprintf(stderr, "Failed to open Virtual HCI device\n");
return 1;
}
server = server_open_unix("/tmp/bt-server-bredr", 0x42);
if (!server) {
fprintf(stderr, "Failed to open server channel\n");
vhci_close(vhci);
return 1;
}
return mainloop_run();
}
int main(int argc, char *argv[])
{
const char sniff_cmd[] = { 0x01, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
ssize_t written;
sigset_t mask;
server_fd = do_connect(DEFAULT_SERVER, DEFAULT_HOST_PORT);
sniffer_fd = do_connect(DEFAULT_SERVER, DEFAULT_SNIFFER_PORT);
written = write(sniffer_fd, sniff_cmd, sizeof(sniff_cmd));
if (written < 0)
perror("Failed to enable sniffer");
vhci_fd = open("/dev/vhci", O_RDWR | O_NONBLOCK);
if (vhci_fd < 0) {
perror("Failed to /dev/vhci");
close(server_fd);
exit(1);
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
mainloop_add_fd(sniffer_fd, EPOLLIN, sniffer_read_callback, NULL, NULL);
mainloop_add_fd(server_fd, EPOLLIN, server_read_callback, NULL, NULL);
mainloop_add_fd(vhci_fd, EPOLLIN, vhci_read_callback, NULL, NULL);
return mainloop_run();
}
int main(int argc, char *argv[])
{
unsigned long filter_mask = 0;
sigset_t mask;
mainloop_init();
for (;;) {
int opt;
opt = getopt_long(argc, argv, "b:vh", main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'b':
btsnoop_open(optarg);
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
filter_mask |= PACKET_FILTER_SHOW_INDEX;
filter_mask |= PACKET_FILTER_SHOW_TIME;
filter_mask |= PACKET_FILTER_SHOW_ACL_DATA;
packet_set_filter(filter_mask);
printf("Bluetooth monitor ver %s\n", VERSION);
if (control_tracing() < 0) {
if (hcidump_tracing() < 0)
return EXIT_FAILURE;
}
return mainloop_run();
}
int main(int argc, char *argv[])
{
sigset_t mask;
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
if (!open_connection())
return EXIT_FAILURE;
return mainloop_run();
}
int main(int argc, char *argv[])
{
const char *path;
sigset_t mask;
__btd_log_init(NULL, 0);
DBG("");
set_capabilities();
if (argc > 1)
path = argv[1];
else
path = DEFAULT_SNOOP_FILE;
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
if (!strcmp(DEFAULT_SNOOP_FILE, path))
rename(DEFAULT_SNOOP_FILE, DEFAULT_SNOOP_FILE ".old");
if (open_monitor(path) < 0) {
error("bluetoothd_snoop: start failed");
return EXIT_FAILURE;
}
info("bluetoothd_snoop: started");
mainloop_run();
close_monitor();
info("bluetoothd_snoop: stopped");
__btd_log_cleanup();
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
const char SYSTEM_SOCKET_PATH[] = "\0android_system";
sigset_t mask;
struct sockaddr_un addr;
int fd;
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
sigaddset(&mask, SIGCHLD);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Android system emulator ver %s\n", VERSION);
snprintf(exec_dir, sizeof(exec_dir), "%s", dirname(argv[0]));
fd = socket(PF_LOCAL, SOCK_DGRAM | SOCK_CLOEXEC, 0);
if (fd < 0) {
perror("Failed to create system socket");
return EXIT_FAILURE;
}
memset(&addr, 0, sizeof(addr));
addr.sun_family = AF_UNIX;
memcpy(addr.sun_path, SYSTEM_SOCKET_PATH, sizeof(SYSTEM_SOCKET_PATH));
if (bind(fd, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
perror("Failed to bind system socket");
close(fd);
return EXIT_FAILURE;
}
mainloop_add_fd(fd, EPOLLIN, system_socket_callback, NULL, NULL);
/* Make sure bluetoothd creates files with proper permissions */
umask(0177);
return mainloop_run();
}
int
main()
{
int xc = EXIT_FAILURE;
printf("Starting service to restart sensors when display unblanks\n");
if( !sighnd_init() )
goto EXIT;
if( !xdbus_init() )
goto EXIT;
xc = mainloop_run();
EXIT:
xdbus_exit();
return xc;
}
int main(int argc, char *argv[])
{
const char *connect_address = NULL;
const char *server_address = NULL;
const char *unix_path = NULL;
unsigned short tcp_port = 0xb1ee; /* 45550 */
const char *str;
sigset_t mask;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "c:l::u::p:i:dvh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'c':
connect_address = optarg;
break;
case 'l':
if (optarg)
server_address = optarg;
else
server_address = "0.0.0.0";
break;
case 'u':
if (optarg)
unix_path = optarg;
else
unix_path = "/tmp/bt-server-bredr";
break;
case 'p':
tcp_port = atoi(optarg);
break;
case 'i':
if (strlen(optarg) > 3 && !strncmp(optarg, "hci", 3))
str = optarg + 3;
else
str = optarg;
if (!isdigit(*str)) {
usage();
return EXIT_FAILURE;
}
hci_index = atoi(str);
break;
case 'd':
debug_enabled = true;
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind > 0) {
fprintf(stderr, "Invalid command line parameters\n");
return EXIT_FAILURE;
}
if (unix_path && server_address) {
fprintf(stderr, "Invalid to specify TCP and Unix servers\n");
return EXIT_FAILURE;
}
if (connect_address && (unix_path || server_address)) {
fprintf(stderr, "Invalid to specify client and server mode\n");
return EXIT_FAILURE;
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
if (connect_address) {
int host_fd, dev_fd;
printf("Connecting to %s:%u\n", connect_address, tcp_port);
dev_fd = connect_tcp(connect_address, tcp_port);
if (dev_fd < 0)
return EXIT_FAILURE;
printf("Opening virtual device\n");
host_fd = open_vhci(0x00);
if (host_fd < 0) {
close(dev_fd);
return EXIT_FAILURE;
}
if (!setup_proxy(host_fd, false, dev_fd, true)) {
close(dev_fd);
close(host_fd);
return EXIT_FAILURE;
}
} else {
int server_fd;
if (unix_path) {
printf("Listening on %s\n", unix_path);
server_fd = open_unix(unix_path);
} else if (server_address) {
printf("Listening on %s:%u\n", server_address,
tcp_port);
server_fd = open_tcp(server_address, tcp_port);
} else {
fprintf(stderr, "Missing emulator device\n");
return EXIT_FAILURE;
}
if (server_fd < 0)
return EXIT_FAILURE;
mainloop_add_fd(server_fd, EPOLLIN, server_callback,
NULL, NULL);
}
return mainloop_run();
}
int main(int argc, char *argv[])
{
struct server *server1;
struct server *server2;
struct server *server3;
struct server *server4;
struct server *server5;
bool server_enabled = false;
bool serial_enabled = false;
int letest_count = 0;
int amptest_count = 0;
int vhci_count = 0;
enum vhci_type vhci_type = VHCI_TYPE_BREDRLE;
sigset_t mask;
int i;
mainloop_init();
for (;;) {
int opt;
opt = getopt_long(argc, argv, "Ssl::LBAUTvh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'S':
serial_enabled = true;
break;
case 's':
server_enabled = true;
break;
case 'l':
if (optarg)
vhci_count = atoi(optarg);
else
vhci_count = 1;
break;
case 'L':
vhci_type = VHCI_TYPE_LE;
break;
case 'B':
vhci_type = VHCI_TYPE_BREDR;
break;
case 'A':
vhci_type = VHCI_TYPE_AMP;
break;
case 'U':
if (optarg)
letest_count = atoi(optarg);
else
letest_count = 1;
break;
case 'T':
if (optarg)
amptest_count = atoi(optarg);
else
amptest_count = 1;
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (letest_count < 1 && amptest_count < 1 &&
vhci_count < 1 && !server_enabled && !serial_enabled) {
fprintf(stderr, "No emulator specified\n");
return EXIT_FAILURE;
}
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Bluetooth emulator ver %s\n", VERSION);
for (i = 0; i < letest_count; i++) {
struct bt_le *le;
le = bt_le_new();
if (!le) {
fprintf(stderr, "Failed to create LE controller\n");
return EXIT_FAILURE;
}
}
for (i = 0; i < amptest_count; i++) {
struct bt_amp *amp;
amp = bt_amp_new();
if (!amp) {
fprintf(stderr, "Failed to create AMP controller\n");
return EXIT_FAILURE;
}
}
for (i = 0; i < vhci_count; i++) {
struct vhci *vhci;
vhci = vhci_open(vhci_type);
if (!vhci) {
fprintf(stderr, "Failed to open Virtual HCI device\n");
return EXIT_FAILURE;
}
}
if (serial_enabled) {
struct serial *serial;
serial = serial_open(SERIAL_TYPE_BREDRLE);
if (!serial)
fprintf(stderr, "Failed to open serial emulation\n");
}
if (server_enabled) {
server1 = server_open_unix(SERVER_TYPE_BREDRLE,
"/tmp/bt-server-bredrle");
if (!server1)
fprintf(stderr, "Failed to open BR/EDR/LE server\n");
server2 = server_open_unix(SERVER_TYPE_BREDR,
"/tmp/bt-server-bredr");
if (!server2)
fprintf(stderr, "Failed to open BR/EDR server\n");
server3 = server_open_unix(SERVER_TYPE_AMP,
"/tmp/bt-server-amp");
if (!server3)
fprintf(stderr, "Failed to open AMP server\n");
server4 = server_open_unix(SERVER_TYPE_LE,
"/tmp/bt-server-le");
if (!server4)
fprintf(stderr, "Failed to open LE server\n");
server5 = server_open_unix(SERVER_TYPE_MONITOR,
"/tmp/bt-server-mon");
if (!server5)
fprintf(stderr, "Failed to open monitor server\n");
}
return mainloop_run();
}
int main(int argc, char *argv[])
{
int opt;
int sec = BT_SECURITY_LOW;
uint16_t mtu = 0;
uint8_t dst_type = BDADDR_LE_PUBLIC;
bool dst_addr_given = false;
bdaddr_t src_addr, dst_addr;
int dev_id = -1;
int fd;
sigset_t mask;
struct client *cli;
while ((opt = getopt_long(argc, argv, "+hvs:m:t:d:i:",
main_options, NULL)) != -1) {
switch (opt) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'v':
verbose = true;
break;
case 's':
if (strcmp(optarg, "low") == 0)
sec = BT_SECURITY_LOW;
else if (strcmp(optarg, "medium") == 0)
sec = BT_SECURITY_MEDIUM;
else if (strcmp(optarg, "high") == 0)
sec = BT_SECURITY_HIGH;
else {
fprintf(stderr, "Invalid security level\n");
return EXIT_FAILURE;
}
break;
case 'm': {
int arg;
arg = atoi(optarg);
if (arg <= 0) {
fprintf(stderr, "Invalid MTU: %d\n", arg);
return EXIT_FAILURE;
}
if (arg > UINT16_MAX) {
fprintf(stderr, "MTU too large: %d\n", arg);
return EXIT_FAILURE;
}
mtu = (uint16_t)arg;
break;
}
case 't':
if (strcmp(optarg, "random") == 0)
dst_type = BDADDR_LE_RANDOM;
else if (strcmp(optarg, "public") == 0)
dst_type = BDADDR_LE_PUBLIC;
else {
fprintf(stderr,
"Allowed types: random, public\n");
return EXIT_FAILURE;
}
break;
case 'd':
if (str2ba(optarg, &dst_addr) < 0) {
fprintf(stderr, "Invalid remote address: %s\n",
optarg);
return EXIT_FAILURE;
}
dst_addr_given = true;
break;
case 'i':
dev_id = hci_devid(optarg);
if (dev_id < 0) {
perror("Invalid adapter");
return EXIT_FAILURE;
}
break;
default:
fprintf(stderr, "Invalid option: %c\n", opt);
return EXIT_FAILURE;
}
}
if (!argc) {
usage();
return EXIT_SUCCESS;
}
argc -= optind;
argv += optind;
optind = 0;
if (argc) {
usage();
return EXIT_SUCCESS;
}
if (dev_id == -1)
bacpy(&src_addr, BDADDR_ANY);
else if (hci_devba(dev_id, &src_addr) < 0) {
perror("Adapter not available");
return EXIT_FAILURE;
}
if (!dst_addr_given) {
fprintf(stderr, "Destination address required!\n");
return EXIT_FAILURE;
}
mainloop_init();
fd = l2cap_le_att_connect(&src_addr, &dst_addr, dst_type, sec);
if (fd < 0)
return EXIT_FAILURE;
cli = client_create(fd, mtu);
if (!cli) {
close(fd);
return EXIT_FAILURE;
}
if (mainloop_add_fd(fileno(stdin),
EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLERR,
prompt_read_cb, cli, NULL) < 0) {
fprintf(stderr, "Failed to initialize console\n");
return EXIT_FAILURE;
}
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_cb, NULL, NULL);
print_prompt();
mainloop_run();
printf("\n\nShutting down...\n");
client_destroy(cli);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
int opt;
bdaddr_t src_addr;
int dev_id = -1;
int fd;
int sec = BT_SECURITY_LOW;
uint8_t src_type = BDADDR_LE_PUBLIC;
uint16_t mtu = 0;
sigset_t mask;
bool hr_visible = false;
struct server *server;
while ((opt = getopt_long(argc, argv, "+hvrs:t:m:i:",
main_options, NULL)) != -1) {
switch (opt) {
case 'h':
usage();
return EXIT_SUCCESS;
case 'v':
verbose = true;
break;
case 'r':
hr_visible = true;
break;
case 's':
if (strcmp(optarg, "low") == 0)
sec = BT_SECURITY_LOW;
else if (strcmp(optarg, "medium") == 0)
sec = BT_SECURITY_MEDIUM;
else if (strcmp(optarg, "high") == 0)
sec = BT_SECURITY_HIGH;
else {
fprintf(stderr, "Invalid security level\n");
return EXIT_FAILURE;
}
break;
case 't':
if (strcmp(optarg, "random") == 0)
src_type = BDADDR_LE_RANDOM;
else if (strcmp(optarg, "public") == 0)
src_type = BDADDR_LE_PUBLIC;
else {
fprintf(stderr,
"Allowed types: random, public\n");
return EXIT_FAILURE;
}
break;
case 'm': {
int arg;
arg = atoi(optarg);
if (arg <= 0) {
fprintf(stderr, "Invalid MTU: %d\n", arg);
return EXIT_FAILURE;
}
if (arg > UINT16_MAX) {
fprintf(stderr, "MTU too large: %d\n", arg);
return EXIT_FAILURE;
}
mtu = (uint16_t) arg;
break;
}
case 'i':
dev_id = hci_devid(optarg);
if (dev_id < 0) {
perror("Invalid adapter");
return EXIT_FAILURE;
}
break;
default:
fprintf(stderr, "Invalid option: %c\n", opt);
return EXIT_FAILURE;
}
}
argc -= optind;
argv -= optind;
optind = 0;
if (argc) {
usage();
return EXIT_SUCCESS;
}
if (dev_id == -1)
bacpy(&src_addr, BDADDR_ANY);
else if (hci_devba(dev_id, &src_addr) < 0) {
perror("Adapter not available");
return EXIT_FAILURE;
}
fd = l2cap_le_att_listen_and_accept(&src_addr, sec, src_type);
if (fd < 0) {
fprintf(stderr, "Failed to accept L2CAP ATT connection\n");
return EXIT_FAILURE;
}
mainloop_init();
server = server_create(fd, mtu, hr_visible);
if (!server) {
close(fd);
return EXIT_FAILURE;
}
if (mainloop_add_fd(fileno(stdin),
EPOLLIN | EPOLLRDHUP | EPOLLHUP | EPOLLERR,
prompt_read_cb, server, NULL) < 0) {
fprintf(stderr, "Failed to initialize console\n");
server_destroy(server);
return EXIT_FAILURE;
}
printf("Running GATT server\n");
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_cb, NULL, NULL);
print_prompt();
mainloop_run();
printf("\n\nShutting down...\n");
server_destroy(server);
return EXIT_SUCCESS;
}
int main(int argc, char *argv[])
{
mrp_mainloop_t *ml;
mrp_clear(&cfg);
parse_cmdline(&cfg, argc, argv);
mrp_log_set_mask(cfg.log_mask);
mrp_log_set_target(cfg.log_target);
ml = mainloop_create(&cfg);
if (ml == NULL)
fatal("failed to create main loop.");
dbus_test.ml = ml;
setup_dbus_tests(ml);
ml = dbus_test.ml;
setup_timers(ml);
setup_io(ml);
setup_signals(ml);
MRP_UNUSED(setup_deferred); /* XXX TODO: add deferred tests... */
#ifdef GLIB_ENABLED
if (cfg.mainloop_type != MAINLOOP_GLIB && cfg.mainloop_type != MAINLOOP_QT) {
if (cfg.ngio > 0 || cfg.ngtimer > 0)
glib_pump_setup(ml);
}
setup_glib_io();
setup_glib_timers();
#endif
if (mrp_add_timer(ml, 1000, check_quit, NULL) == NULL)
fatal("failed to create quit-check timer");
setup_wakeup(ml);
mainloop_run(&cfg);
check_io();
check_timers();
check_signals();
#ifdef GLIB_ENABLED
check_glib_io();
check_glib_timers();
#endif
if (dbus_test.client != 0)
close(dbus_test.pipe[1]); /* let the client continue */
check_dbus();
#ifdef GLIB_ENABLED
if (cfg.mainloop_type != MAINLOOP_GLIB) {
if (cfg.ngio > 0 || cfg.ngtimer > 0)
glib_pump_cleanup();
}
#endif
cleanup_wakeup();
mainloop_cleanup(&cfg);
}
int main(int argc, char *argv[])
{
const char *str;
sigset_t mask;
int exit_status;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "A::DF::TRi:vh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'A':
if (optarg)
set_bdaddr_value = optarg;
set_bdaddr = true;
break;
case 'D':
use_manufacturer_mode = true;
get_bddata = true;
break;
case 'F':
use_manufacturer_mode = true;
if (optarg)
load_firmware_value = optarg;
load_firmware = true;
break;
case 'T':
use_manufacturer_mode = true;
set_traces = true;
break;
case 'R':
reset_on_exit = true;
break;
case 'i':
if (strlen(optarg) > 3 && !strncmp(optarg, "hci", 3))
str = optarg + 3;
else
str = optarg;
if (!isdigit(*str)) {
usage();
return EXIT_FAILURE;
}
hci_index = atoi(str);
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind > 0) {
fprintf(stderr, "Invalid command line parameters\n");
return EXIT_FAILURE;
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Bluemoon configuration utility ver %s\n", VERSION);
hci_dev = bt_hci_new_user_channel(hci_index);
if (!hci_dev) {
fprintf(stderr, "Failed to open HCI user channel\n");
return EXIT_FAILURE;
}
bt_hci_send(hci_dev, CMD_READ_VERSION, NULL, 0,
read_version_complete, NULL, NULL);
exit_status = mainloop_run();
bt_hci_unref(hci_dev);
return exit_status;
}
int
main(int argc, char **argv)
{
static const char opt_s[] = "hVdl:L:X:w:t:";
static const struct option opt_l[] =
{
{"help", 0, 0, 'h'},
{"usage", 0, 0, 'h'},
{"version", 0, 0, 'V'},
{"daemon", 0, 0, 'd'},
{"log-level", 1, 0, 'L'},
{"log-target", 1, 0, 'l'},
{"limbo-control", 1, 0, 'w'},
{"limbo-timeout", 1, 0, 't'},
{0, 0, 0, 0 }
};
int log_driver = LOG_TO_SYSLOG;
int log_level = LOG_WARNING;
int opt_daemon = 0;
int opt;
progname = *argv = basename(*argv);
if( access("/root/alarmd.verbose", F_OK) == 0 )
{
//log_driver = LOG_TO_STDERR;
log_level = LOG_DEBUG;
}
// libconic uses gobjects
g_type_init();
while( (opt = getopt_long(argc, argv, opt_s, opt_l, 0)) != -1 )
{
switch( opt )
{
case 'h':
show_usage();
exit(0);
case 'V':
printf("%s\n", VERS);
break;
case 'L':
log_level = log_parse_level(optarg);
break;
case 'l':
log_driver = log_parse_driver(optarg);
break;
case 'd':
opt_daemon = 1;
break;
case 't':
server_limbo_set_timeout(strtol(optarg,0,0));
break;
case 'w':
if( cmp_flag(optarg, "disabled") )
{
server_limbo_set_control(DESKTOP_WAIT_DISABLED);
}
else if( cmp_flag(optarg, "home") )
{
server_limbo_set_control(DESKTOP_WAIT_HOME);
}
else if( cmp_flag(optarg, "hildon") )
{
server_limbo_set_control(DESKTOP_WAIT_HOME);
}
else if( cmp_flag(optarg, "startup") )
{
server_limbo_set_control(DESKTOP_WAIT_HOME);
}
else
{
server_limbo_set_control(strtol(optarg,0,0));
}
break;
case 'X':
if( !strcmp(optarg, "cud") )
{
exit( clear_user_data() == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
}
else if( !strcmp(optarg, "rfs") )
{
exit(restore_factory_settings() == -1 ? EXIT_FAILURE : EXIT_SUCCESS);
}
else
{
fprintf(stderr, "Unknwon option: -X%s\n", optarg);
}
exit(EXIT_FAILURE);
break;
case '?':
fprintf(stderr, "%s: (use -h for usage)\n", *argv);
exit(1);
default:
abort ();
}
}
if( opt_daemon && daemon(0,0) )
{
perror("daemon"); exit(1);
}
log_set_level(log_level);
log_open("alarmd", log_driver, 1);
log_info("-- startup --\n");
int xc = mainloop_run();
log_info("-- exit %d --\n", xc);
log_close();
return xc;
}
int main(int argc, char *argv[])
{
unsigned long filter_mask = 0;
const char *reader_path = NULL;
const char *writer_path = NULL;
const char *analyze_path = NULL;
const char *ellisys_server = NULL;
unsigned short ellisys_port = 0;
const char *str;
int exit_status;
sigset_t mask;
mainloop_init();
filter_mask |= PACKET_FILTER_SHOW_TIME_OFFSET;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "d:r:w:a:s:p:i:tTSE:vh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'd':
control_tty(optarg);
break;
case 'r':
reader_path = optarg;
break;
case 'w':
writer_path = optarg;
break;
case 'a':
analyze_path = optarg;
break;
case 's':
control_server(optarg);
break;
case 'p':
packet_set_priority(optarg);
break;
case 'i':
if (strlen(optarg) > 3 && !strncmp(optarg, "hci", 3))
str = optarg + 3;
else
str = optarg;
if (!isdigit(*str)) {
usage();
return EXIT_FAILURE;
}
packet_select_index(atoi(str));
break;
case 't':
filter_mask &= ~PACKET_FILTER_SHOW_TIME_OFFSET;
filter_mask |= PACKET_FILTER_SHOW_TIME;
break;
case 'T':
filter_mask &= ~PACKET_FILTER_SHOW_TIME_OFFSET;
filter_mask |= PACKET_FILTER_SHOW_TIME;
filter_mask |= PACKET_FILTER_SHOW_DATE;
break;
case 'S':
filter_mask |= PACKET_FILTER_SHOW_SCO_DATA;
break;
case 'E':
ellisys_server = optarg;
ellisys_port = 24352;
break;
case '#':
packet_todo();
lmp_todo();
return EXIT_SUCCESS;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind > 0) {
fprintf(stderr, "Invalid command line parameters\n");
return EXIT_FAILURE;
}
if (reader_path && analyze_path) {
fprintf(stderr, "Display and analyze can't be combined\n");
return EXIT_FAILURE;
}
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Bluetooth monitor ver %s\n", VERSION);
keys_setup();
packet_set_filter(filter_mask);
if (analyze_path) {
analyze_trace(analyze_path);
return EXIT_SUCCESS;
}
if (reader_path) {
if (ellisys_server)
ellisys_enable(ellisys_server, ellisys_port);
control_reader(reader_path);
return EXIT_SUCCESS;
}
if (writer_path && !control_writer(writer_path)) {
printf("Failed to open '%s'\n", writer_path);
return EXIT_FAILURE;
}
if (ellisys_server)
ellisys_enable(ellisys_server, ellisys_port);
if (control_tracing() < 0)
return EXIT_FAILURE;
exit_status = mainloop_run();
keys_cleanup();
return exit_status;
}
int main(int argc, char *argv[])
{
cmd_func_t func = NULL;
uint16_t index = 0;
const char *str;
bool use_raw = false;
bool power_down = false;
sigset_t mask;
int fd, i, exit_status;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "i:rRvh", main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'i':
if (strlen(optarg) > 3 && !strncmp(optarg, "hci", 3))
str = optarg + 3;
else
str = optarg;
if (!isdigit(*str)) {
usage();
return EXIT_FAILURE;
}
index = atoi(str);
break;
case 'r':
reset_on_init = true;
break;
case 'R':
use_raw = true;
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind < 1) {
fprintf(stderr, "Missing command argument\n");
return EXIT_FAILURE;
}
for (i = 0; cmd_table[i].name; i++) {
if (!strcmp(cmd_table[i].name, argv[optind])) {
func = cmd_table[i].func;
break;
}
}
if (!func) {
fprintf(stderr, "Unsupported command specified\n");
return EXIT_FAILURE;
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Bluetooth information utility ver %s\n", VERSION);
fd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
if (fd < 0) {
perror("Failed to open HCI raw socket");
return EXIT_FAILURE;
}
memset(&hci_info, 0, sizeof(hci_info));
hci_info.dev_id = index;
if (ioctl(fd, HCIGETDEVINFO, (void *) &hci_info) < 0) {
perror("Failed to get HCI device information");
close(fd);
return EXIT_FAILURE;
}
if (use_raw && !(hci_info.flags & HCI_UP)) {
printf("Powering on controller\n");
if (ioctl(fd, HCIDEVUP, hci_info.dev_id) < 0) {
perror("Failed to power on controller");
close(fd);
return EXIT_FAILURE;
}
power_down = true;
}
close(fd);
hci_type = (hci_info.type & 0x30) >> 4;
if (use_raw) {
hci_dev = bt_hci_new_raw_device(index);
if (!hci_dev) {
fprintf(stderr, "Failed to open HCI raw device\n");
return EXIT_FAILURE;
}
} else {
hci_dev = bt_hci_new_user_channel(index);
if (!hci_dev) {
fprintf(stderr, "Failed to open HCI user channel\n");
return EXIT_FAILURE;
}
reset_on_init = true;
reset_on_shutdown = true;
}
if (!func(argc - optind - 1, argv + optind + 1)) {
bt_hci_unref(hci_dev);
return EXIT_FAILURE;
}
exit_status = mainloop_run();
bt_hci_unref(hci_dev);
if (use_raw && power_down) {
fd = socket(AF_BLUETOOTH, SOCK_RAW | SOCK_CLOEXEC, BTPROTO_HCI);
if (fd >= 0) {
printf("Powering down controller\n");
if (ioctl(fd, HCIDEVDOWN, hci_info.dev_id) < 0)
perror("Failed to power down controller");
close(fd);
}
}
return exit_status;
}
int main(int argc, char *argv[])
{
uint16_t index = 0;
const char *str;
sigset_t mask;
int exit_status;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "i:vh", main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'i':
if (strlen(optarg) > 3 && !strncmp(optarg, "hci", 3))
str = optarg + 3;
else
str = optarg;
if (!isdigit(*str)) {
usage();
return EXIT_FAILURE;
}
index = atoi(str);
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind > 0) {
fprintf(stderr, "Invalid command line parameters\n");
return EXIT_FAILURE;
}
urandom_fd = open("/dev/urandom", O_RDONLY);
if (urandom_fd < 0) {
fprintf(stderr, "Failed to open /dev/urandom device\n");
return EXIT_FAILURE;
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
printf("Low Energy iBeacon utility ver %s\n", VERSION);
hci_dev = bt_hci_new_user_channel(index);
if (!hci_dev) {
fprintf(stderr, "Failed to open HCI user channel\n");
exit_status = EXIT_FAILURE;
goto done;
}
start_ibeacon();
exit_status = mainloop_run();
bt_hci_unref(hci_dev);
done:
close(urandom_fd);
return exit_status;
}
int main(int argc, char *argv[])
{
const char *bredr_path = NULL, *amp_path = NULL, *proto = NULL;
bool raw_device = false;
sigset_t mask;
int exit_status, count = 0, proto_id = HCI_UART_H4;
for (;;) {
int opt;
opt = getopt_long(argc, argv, "B:A:P:Rvh",
main_options, NULL);
if (opt < 0)
break;
switch (opt) {
case 'B':
bredr_path = optarg;
break;
case 'A':
amp_path = optarg;
break;
case 'P':
proto = optarg;
break;
case 'R':
raw_device = true;
break;
case 'v':
printf("%s\n", VERSION);
return EXIT_SUCCESS;
case 'h':
usage();
return EXIT_SUCCESS;
default:
return EXIT_FAILURE;
}
}
if (argc - optind > 0) {
fprintf(stderr, "Invalid command line parameters\n");
return EXIT_FAILURE;
}
mainloop_init();
sigemptyset(&mask);
sigaddset(&mask, SIGINT);
sigaddset(&mask, SIGTERM);
mainloop_set_signal(&mask, signal_callback, NULL, NULL);
if (proto) {
unsigned int i;
for (i = 0; proto_table[i].name; i++) {
if (!strcmp(proto_table[i].name, proto)) {
proto_id = proto_table[i].id;
break;
}
}
if (!proto_table[i].name) {
fprintf(stderr, "Invalid protocol\n");
return EXIT_FAILURE;
}
}
if (bredr_path) {
unsigned long flags;
int fd;
printf("Attaching BR/EDR controller to %s\n", bredr_path);
flags = (1 << HCI_UART_RESET_ON_INIT);
if (raw_device)
flags = (1 << HCI_UART_RAW_DEVICE);
fd = attach_proto(bredr_path, proto_id, flags);
if (fd >= 0) {
mainloop_add_fd(fd, 0, uart_callback, NULL, NULL);
count++;
}
}
if (amp_path) {
unsigned long flags;
int fd;
printf("Attaching AMP controller to %s\n", amp_path);
flags = (1 << HCI_UART_RESET_ON_INIT) |
(1 << HCI_UART_CREATE_AMP);
if (raw_device)
flags = (1 << HCI_UART_RAW_DEVICE);
fd = attach_proto(amp_path, proto_id, flags);
if (fd >= 0) {
mainloop_add_fd(fd, 0, uart_callback, NULL, NULL);
count++;
}
}
if (count < 1) {
fprintf(stderr, "No controller attached\n");
return EXIT_FAILURE;
}
exit_status = mainloop_run();
return exit_status;
}
