void run(char *conf_file) {
struct running rr;
struct event *sig1_ev,*sig2_ev,*sig_hup;
evthread_use_pthreads();
setup_running(&rr);
register_interface_types(&rr);
register_source_types(&rr);
run_config(&rr,conf_file);
start_stats_timer(&rr);
ref_release(&(rr.ic_running));
event_add(sq_consumer(rr.sq),0);
event_add(si_consumer(rr.si),0);
sq_release(rr.sq);
evsignal_add(sig1_ev=evsignal_new(rr.eb,SIGINT,user_quit,&rr),0);
evsignal_add(sig2_ev=evsignal_new(rr.eb,SIGTERM,user_quit,&rr),0);
evsignal_add(sig_hup=evsignal_new(rr.eb,SIGHUP,hupev,&rr),0);
rr.sigkill_timer = event_new(rr.eb,-1,EV_PERSIST,sigkill_self,&rr);
log_info(("Starting event loop"));
event_base_loop(rr.eb,0);
log_info(("Event loop finished"));
event_del(sig1_ev);
event_del(sig2_ev);
event_del(sig_hup);
event_free(sig1_ev);
event_free(sig2_ev);
event_free(sig_hup);
closedown(&rr);
log_info(("Bye!"));
config_finished();
}
int main(int argc, char** argv) {
auto& main_prof = make_profiler("main");
profile_start(main_prof);
try {
options opt = parse_cmdline(argc, argv);
switch (opt.m_mode) {
case options::init:
init();
break;
case options::config:
run_config(require_codedb_path(opt), opt);
break;
case options::build:
build(require_codedb_path(opt), opt);
break;
case options::find:
find(require_codedb_path(opt), opt);
break;
case options::serve:
serve(require_codedb_path(opt), opt);
break;
case options::undefined:
std::cout << "cdb: '" << opt.m_args[0]
<< "' is not a cdb-command. See 'cdb --help'.\n";
break;
case options::help:
help(opt);
break;
default:
std::cout << "Not implemented '" << opt.m_args.at(0) << "'\n";
break;
}
}
catch (const regex_error& error) {
std::string desc = error.what();
if (!desc.empty()) desc[0] = std::toupper(desc[0]);
std::cerr << "Error: invalid regex '" << error.m_expr << "'\n " << desc
<< '\n';
}
catch (const std::exception& e) {
std::cerr << "Error: " << e.what() << std::endl;
}
profile_stop(main_prof);
profiler_report();
}
int main(int argc, char **argv)
{
atexit(onExit);
int count = 0;
addrs = (char**)calloc(sizeof(char**),100);
char * log_file = "";
char * script_file = "/etc/bluetooth/pwntooth.conf";
char * addr = "";
int scan_iterations = 0;
int bool_single_target = 0;
int i = 1;
// Check arguments
while (i < argc) {
if (strcmp(argv[i], "-h") == 0) {
usage();
return 0;
} else if (strcmp(argv[i], "-l") == 0) {
if (++i < argc)
log_file = argv[i];
} else if (strcmp(argv[i], "-n") == 0) {
if (++i < argc) {
scan_iterations = atoi(argv[i]);
}
// Input validation
if ((scan_iterations < 1)||(scan_iterations > 1000000)) {
perror("incorrect number of iterations. choose a number between 1 and 1,000,000.\n");
return 1;
}
} else if (strcmp(argv[i], "-s") == 0) {
if (++i < argc)
script_file = argv[i];
} else if (strcmp(argv[i], "-t") == 0) {
if (++i < argc) {
bool_single_target = 1;
addr = argv[i];
// Input validation
if (strlen(addr) != 17) {
perror("incorrect addr format.\n");
return 1;
}
}
} else {
usage();
return 1;
}
i++;
}
if (bool_single_target) {
run_config(addr, log_file, script_file);
}
else {
// Run for a specified number of iterations
while(count < scan_iterations)
{
printf("Scanning ...\n");
scan(log_file, script_file);
count++;
}
}
return 0;
}
// Scan for available bluetooth devices
int scan(char * log_file, char * filename)
{
inquiry_info *ii = NULL;
int max_rsp, num_rsp;
int dev_id, sock, len, flags;
int i;
int t_count;
char addr[19] = { 0 };
dev_id = hci_get_route(NULL);
sock = hci_open_dev( dev_id );
// Error with opening socket
if (dev_id < 0 || sock < 0) {
perror("error: opening socket\n");
return 1;
}
len = 8;
max_rsp = 255;
flags = IREQ_CACHE_FLUSH;
ii = (inquiry_info*)malloc(max_rsp * sizeof(inquiry_info));
num_rsp = hci_inquiry(dev_id, len, max_rsp, NULL, &ii, flags);
// Check for any devices found
if( num_rsp < 0 ) {
return 1;
}
// Cycle through all the addresses found
for (i = 0; i < num_rsp; i++) {
char name[248] = { 0 };
ba2str(&(ii+i)->bdaddr, addr);
memset(name, 0, sizeof(name));
// Check for device name
if (hci_read_remote_name(sock, &(ii+i)->bdaddr, sizeof(name), name, 0) < 0)
strcpy(name, "[unknown]");
// while (hci_read_remote_name(sock, &(ii+i)->bdaddr, sizeof(name), name, 0) < 0) {
// // Requesting device name
// }
int num = 0;
int matchfound = 0;
// Check to see if a new device has been discovered
while (num < numaddrs) {
if (strcmp (addr, addrs[num]) == 0) {
matchfound = 1;
}
num++;
}
// Run commands for newly found device address
if (matchfound == 0) {
time_stamp(addr, name, log_file);
run_config(addr, log_file, filename);
// Add address to list of discovered devices
addrs[numaddrs] = malloc(sizeof addr + 1);
strcpy(addrs[numaddrs], addr);
numaddrs++;
}
}
free( ii );
close( sock );
return 0;
}
int stw400audioloop (hats_audio_4500_loop action)
{
int result = PASS;
uint8_t data,data0;
uint8_t error1,error2;
AB8500_version version;
/*********************************************************************/
/* no loop => reset audio registers */
/*********************************************************************/
if(action == HATS_STW4500_LOOP_OFF)
{
// Reset audio part
/*error1 = Read4500reg(BLOC_4500_AUDIO, 0x01, &data0);
data = (data0 | 0x80);
error2 = Write4500reg(BLOC_4500_AUDIO, 0x01, data);
error1 = Read4500reg(0x02, 0x00, &data0);
data = (data0 & 0xFE);
error2 = Write4500reg(0x02, 0x00, data);*/
if(action == HATS_STW4500_ANALOGLOOP)
{
run_config(AL_Stop);
}
else
{
run_config(DL_Stop);
}
Cur_Loop = HATS_STW4500_LOOP_OFF;
}
else
{
// ResetAudn
/*error1 = Read4500reg(0x02, 0x00, &data0);
data = (data0 & 0xFE);
error2 = Write4500reg(0x02, 0x00, data);
data = (data0 | 0x02);
error2 = Write4500reg(0x02, 0x00, data);
*/
// Reset audio part
/*rror1 = Read4500reg(BLOC_4500_AUDIO, 0x01, &data0);
data = (data0 | 0x80);
error2 = Write4500reg(BLOC_4500_AUDIO, 0x01, data);
*/
// AudioClk Enable
error1 = Read4500reg (bloc_4500_System_Control_2, 0x0B, &data0);
data = (data0 | 0x18);
error2 = Write4500reg (bloc_4500_System_Control_2, 0x0B, data);
// Dmics Clk GPIO in output
version = Get_AB8500_Version();
if (version == AB8500_VER_V1)
{
error1 = Read4500reg (0x10, 0x13, &data0);
data = (data0 | 0x54);
error2 = Write4500reg (0x10, 0x13, data);
}
// Vintcore12
error1 = Read4500reg (0x03, 0x80, &data0);
data = (data0 | 0x04);
error2 = Write4500reg (0x03, 0x80, data);
// Vaudio Enable
error1 = Read4500reg (bloc_4500_Supply_Control_1, 0x83, &data0);
data = (data0 | 0x42);
error2 = Write4500reg (bloc_4500_Supply_Control_1, 0x83, data);
/*********************************************************************/
/* 4500 digital loop */
/*********************************************************************/
if(action == HATS_STW4500_ANALOGLOOP)
{
run_config(Analog_loop);
Cur_Loop = HATS_STW4500_ANALOGLOOP;
}
/*********************************************************************/
/* digital loop */
/*********************************************************************/
else if(action == HATS_STW4500_DIGITALLOOP)
{
if( (Cur_Out_Organ <NB_OF_OUTPUT) && (Cur_In_Organ <NB_OF_INPUT)
&&(Digital_loop_configs[Cur_Out_Organ][Cur_In_Organ] != NULL))
{
run_config(Digital_loop_configs[Cur_Out_Organ][Cur_In_Organ] );
printf(" run config IN: %x/OUT: %x\n",Cur_In_Organ,Cur_Out_Organ);
}
else
{
/* error */
printf(" config IN: %x/OUT: %x not supported => select another IN or/and OUT\n",Cur_In_Organ,Cur_Out_Organ);
result = FAIL;
}
Cur_Loop = HATS_STW4500_DIGITALLOOP;
}
else
{
/* error */
result = HATS_AUDIO_INVALID_PARAMETER;
printf(" BAD VERSION\n");
}
}
return result;
}
