static int __init platform_pixter_module_init(void)
{
struct devs_id *dev;
dev = get_device_id(pixter_dev0.type, pixter_dev0.name);
if (dev)
dev->device_handler(&pixter_dev0, dev);
dev = get_device_id(pixter_dev1.type, pixter_dev1.name);
if (dev)
dev->device_handler(&pixter_dev1, dev);
/* Currently only two I2C salves are supported. */
#if 0
dev = get_device_id(pixter_dev2.type, pixter_dev2.name);
if (dev)
dev->device_handler(&pixter_dev2, dev);
#endif
return 0;
}
bool
device_set_symbol_address(device_symbol_t symbol, unsigned long int address)
{
device_id_t device_id;
unsigned long int old;
sqlite3_stmt *st;
int rc;
if (address == 0) {
return false;
}
old = device_get_symbol_address(symbol);
if (old == address) {
return true;
}
if (old) {
printf("Duplicate symbol \"%s\": old = 0x%08x, new = 0x%08x\n", symbol, old, address);
return false;
}
device_id = get_device_id(true);
rc = sqlite3_prepare(db, SQL_REGISTER_DEVICE_ADDRESS, -1, &st, NULL);
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_reset(st);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_int(st, 1, device_id);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_text(st, 2, symbol, -1, SQLITE_STATIC);
}
if (!IS_SQL_ERROR(rc)) {
rc = sqlite3_bind_int(st, 3, address);
}
if (!IS_SQL_ERROR(rc)) {
rc = execute_sql(st);
}
if (IS_SQL_ERROR(rc)) {
printf("%s(%d)\n", sqlite3_errmsg(db), sqlite3_errcode(db));
sqlite3_finalize(st);
return false;
}
sqlite3_finalize(st);
return true;
}
bool operator==(const entry& other) const {
return get_device_id() == other.get_device_id() &&
get_event_time_stamp() == other.get_event_time_stamp() &&
get_valid() == other.get_valid() &&
get_lazy() == other.get_lazy() &&
get_event() == other.get_event() &&
get_event_type() == other.get_event_type() &&
get_original_event() == other.get_original_event();
}
static void *
winmm_output_init(G_GNUC_UNUSED const struct audio_format *audio_format,
G_GNUC_UNUSED const struct config_param *param,
G_GNUC_UNUSED GError **error)
{
struct winmm_output *wo = g_new(struct winmm_output, 1);
const char *device = config_get_block_string(param, "device", NULL);
wo->device_id = get_device_id(device);
return wo;
}
int
main(void)
{
halInit();
chSysInit();
get_device_id();
/* start stdout port */
sdStart(SD_STDIO, NULL);
xflash_init();
cmdline_init();
rngStart(&RNGD);
app_cfg_init();
check_for_faults();
gfx_init();
touch_init();
sensor_init(SENSOR_1, SD_OW1);
sensor_init(SENSOR_2, SD_OW2);
temp_control_init(CONTROLLER_1);
temp_control_init(CONTROLLER_2);
ota_update_init();
net_init();
web_api_init();
sntp_init();
gui_init();
thread_watchdog_init();
create_home_screen();
recovery_screen_create();
screen_saver_create();
if (palReadPad(PORT_SELF_TEST_EN, PAD_SELF_TEST_EN) == 0) {
widget_t* self_test_screen = self_test_screen_create();
gui_push_screen(self_test_screen);
}
recovery_img_init();
while (TRUE) {
cmdline_restart();
toggle_LED1();
}
}
/***************************************************************************
* GetDeviceID [DSOUND.9]
*
* Retrieves unique identifier of default device specified
*
* PARAMS
* pGuidSrc [I] Address of device GUID.
* pGuidDest [O] Address to receive unique device GUID.
*
* RETURNS
* Success: DS_OK
* Failure: DSERR_INVALIDPARAM
*
* NOTES
* pGuidSrc is a valid device GUID or DSDEVID_DefaultPlayback,
* DSDEVID_DefaultCapture, DSDEVID_DefaultVoicePlayback, or
* DSDEVID_DefaultVoiceCapture.
* Returns pGuidSrc if pGuidSrc is a valid device or the device
* GUID for the specified constants.
*/
HRESULT WINAPI GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest)
{
IMMDeviceEnumerator *devenum;
EDataFlow flow = (EDataFlow)-1;
ERole role = (ERole)-1;
HRESULT hr, init_hr;
TRACE("(%s,%p)\n", get_device_id(pGuidSrc),pGuidDest);
if(!pGuidSrc || !pGuidDest)
return DSERR_INVALIDPARAM;
init_hr = get_mmdevenum(&devenum);
if(!devenum)
return init_hr;
if(IsEqualGUID(&DSDEVID_DefaultPlayback, pGuidSrc)){
role = eMultimedia;
flow = eRender;
}else if(IsEqualGUID(&DSDEVID_DefaultVoicePlayback, pGuidSrc)){
role = eCommunications;
flow = eRender;
}else if(IsEqualGUID(&DSDEVID_DefaultCapture, pGuidSrc)){
role = eMultimedia;
flow = eCapture;
}else if(IsEqualGUID(&DSDEVID_DefaultVoiceCapture, pGuidSrc)){
role = eCommunications;
flow = eCapture;
}
if(role != (ERole)-1 && flow != (EDataFlow)-1){
IMMDevice *device;
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum,
flow, role, &device);
if(FAILED(hr)){
WARN("GetDefaultAudioEndpoint failed: %08x\n", hr);
release_mmdevenum(devenum, init_hr);
return DSERR_NODRIVER;
}
hr = get_mmdevice_guid(device, NULL, pGuidDest);
IMMDevice_Release(device);
release_mmdevenum(devenum, init_hr);
return (hr == S_OK) ? DS_OK : hr;
}
release_mmdevenum(devenum, init_hr);
*pGuidDest = *pGuidSrc;
return DS_OK;
}
nlohmann::json to_json(void) const {
return nlohmann::json({
{"device_id", type_safe::get(get_device_id())},
{"event_time_stamp", get_event_time_stamp()},
{"valid", get_valid()},
{"lazy", get_lazy()},
{"event", get_event()},
{"event_type", get_event_type()},
{"original_event", get_original_event()},
});
}
/**
* Enrolls a finger and returns the associated fp-data.
*
* @param env the Java Environment pointer.
* @param obj the jobject of the type jlibfprint/JlibFprint.
* @return the jlibfprint/JlibFprint$fp_print_data with the data just given by the scanner.
* @throws an enroll_exception is raised is something gone wrong.
*/
JNIEXPORT jobject JNICALL Java_jlibfprint_JlibFprint_enroll_1finger(JNIEnv* env, jobject ref)
{
const jclass fpClass = env->FindClass("jlibfprint/JlibFprint$fp_print_data");
const jclass eeClass = env->FindClass("jlibfprint/JlibFprint$EnrollException");
/* Starts the library */
if (fp_init()) // Se differente da 0 => Exception
{
jobject enrollException = env->AllocObject(eeClass);
jfieldID eeExcp_id = env->GetFieldID(eeClass, "enroll_exception", "I");
env->SetIntField(enrollException, eeExcp_id, UNABLE_TO_LOAD_LIBFPRINT);
env->Throw((jthrowable)enrollException);
return NULL;
}
fp_dev *device;
fp_print_data* pdp;
/* Gets the pointer to the device */
if (!get_device_id(env, ref, &device))
{
jobject enrollException = env->AllocObject(eeClass);
jfieldID eeExcp_id = env->GetFieldID(eeClass, "enroll_exception", "I");
env->SetIntField(enrollException, eeExcp_id, DEVICE_NOT_FOUND);
env->Throw((jthrowable)enrollException);
return NULL;
}
/* Enrolls the finger */
int ef = fp_enroll_finger(device, &pdp);
/* Create a new obj to store the data */
jobject obj = env->AllocObject(fpClass);
/* Raises an exception if the enrollment was not completed */
if (ef != FP_ENROLL_COMPLETE)
{
jobject enrollException = env->AllocObject(eeClass);
jfieldID eeExcp_id = env->GetFieldID(eeClass, "enroll_exception", "I");
env->SetIntField(enrollException, eeExcp_id, ef);
env->Throw((jthrowable)enrollException);
}
else
{
/* Fills the object with the enrollment data */
cfp2jfp(env, obj, pdp);
memset(pdp, 0, sizeof(fp_print_data));
fp_print_data_free(pdp);
}
fp_dev_close(device);
fp_exit();
return obj;
}
bool database::authkey_auth(const char GUID[SUPLA_GUID_SIZE],
const char Email[SUPLA_EMAIL_MAXSIZE],
const char AuthKey[SUPLA_AUTHKEY_SIZE], int *UserID,
bool Client, const char *sql) {
if (_mysql == NULL) {
return false;
}
int ID = 0;
int _UserID = get_user_id_by_email(Email);
if (_UserID == 0 && !Client) {
ID = get_device_id_and_user(GUID, &_UserID);
}
if (_UserID == 0) {
return false;
}
if (ID == 0) ID = Client ? get_client_id(_UserID, GUID) : get_device_id(GUID);
if (ID == 0) { // Yes. When client not exists then is authorized
*UserID = _UserID;
return true;
}
bool is_null = false;
char AuthKeyHash[BCRYPT_HASH_MAXSIZE];
memset(AuthKeyHash, 0, BCRYPT_HASH_MAXSIZE);
if (!get_authkey_hash(ID, AuthKeyHash, BCRYPT_HASH_MAXSIZE, &is_null, sql)) {
return false;
}
if (is_null) { // Yes. When is null then is authorized
*UserID = _UserID;
return true;
}
char AuthKeyHEX[SUPLA_AUTHKEY_HEXSIZE];
memset(AuthKeyHEX, 0, SUPLA_AUTHKEY_HEXSIZE);
st_authkey2hex(AuthKeyHEX, AuthKey);
if (st_bcrypt_check(AuthKeyHEX, AuthKeyHash,
strnlen(AuthKeyHash, BCRYPT_HASH_MAXSIZE))) {
*UserID = _UserID;
return true;
}
return false;
}
int net_log_init()
{
get_device_id();
close_execute_cmd();
if ((g_fd = connect_push_server(DOMAIN_NANME, 8080)) < 0)
{
return -1;
}
if (pthread_mutex_init(&log_net_lock, 0) != 0)
{
return -1;
}
return 0;
}
static void scan_device(uint8_t bus, uint8_t dev)
{
for (uint8_t func = 0; func < 8; ++func) {
uint16_t vendor_id = get_vendor_id(bus, dev, func);
if (vendor_id != 0xFFFF) {
uint32_t device_id = get_device_id(bus, dev, func);
uint32_t class_code = get_class_code(bus, dev, func);
uint32_t subclass_code = get_subclass_code(bus, dev, func);
printk("Bus: %d, Device: %d, Function %d\n", bus, dev, func);
printk(" -> Vendor ID: %x, Device ID: %x, Class: %x, Subclass: %x\n", vendor_id, device_id, class_code, subclass_code);
//printk(" -> Vednor: %s\n", get_vendor_name(vendor_id));
//printk(" -> Device: %s\n", get_device_name(vendor_id, device_id));
}
}
}
static struct audio_output *
winmm_output_init(const struct config_param *param, GError **error_r)
{
struct winmm_output *wo = g_new(struct winmm_output, 1);
if (!ao_base_init(&wo->base, &winmm_output_plugin, param, error_r)) {
g_free(wo);
return NULL;
}
const char *device = config_get_block_string(param, "device", NULL);
if (!get_device_id(device, &wo->device_id, error_r)) {
ao_base_finish(&wo->base);
g_free(wo);
return NULL;
}
return &wo->base;
}
/**
* __display_operations - Display the available operations
* @kcl: KClient data structure
*/
void __display_operations(struct kclient *kcl, char *dev_name)
{
unsigned int i;
dev_id_t id = get_device_id(kcl, dev_name);
for (i=1; i<kcl->devs_num; i++) {
if (kcl->devices[i].id == id) {
unsigned int j;
printf("\e[7m%-5s%-50s\e[27m\n", "ID", "OPERATION");
for (j=0; j<kcl->devices[i].ops_num; j++) {
printf("%-5u%-50s\n", kcl->devices[i].ops[j].id,
kcl->devices[i].ops[j].name);
}
goto exit_success;
}
}
int main() {
ssize_t f = open ("/dev/de4", O_RDWR);
if (f == -1) {
printf ("Couldn't open the device. Did you load the driver?\n");
return 0;
} else {
printf ("Opened the device: file handle #%zu!\n", f);
}
printf ("Vendor id = 0x%x, Device id = 0x%x\n",
get_vendor_id(f), get_device_id(f));
print_pid();
test_global_mem_write(f);
int i;
/* Change upper limit to a larger number (e.g. 1000) for stress testing */
for (i = 0; i < 1; i++) {
printf ("-- %d --\n", i);
test_auto_discovery_read (f);
test_small_writes (f);
test_global_mem(f);
// test_large_read_write (f);
// test_reprogram(f);
test_dma_writes(f);
// test_cvp(f);
}
test_global_mem_write(f);
printf ("Done testing!\n");
close (f);
return 0;
}
std::string getFullPortUSB(std::string id) {
std::string port;
libusb_device **devs; //pointer to pointer of device, used to retrieve a list of devices
libusb_context *ctx = NULL; //a libusb session
int r; //for return values
ssize_t cnt; //holding number of devices in list
r = libusb_init(&ctx); //initialize a library session
if(r < 0) {
std::cout<<"Init Error "<<r<<std::endl; //there was an error
return NULL;
}
libusb_set_debug(ctx, 3); //set verbosity level to 3, as suggested in the documentation
cnt = libusb_get_device_list(ctx, &devs); //get the list of devices
if(cnt < 0)
std::cout<<"Get Device Error"<<std::endl; //there was an error
std::cout<<cnt<<" Devices in list."<<std::endl; //print total number of usb devices
for(ssize_t i = 0; i < cnt; i++)
{
std::string tmpid = get_device_id(devs[i]);
if (tmpid.compare(id)==0)
{
port = get_device_port(devs[i]);
std::cout << " usb device " << tmpid << " found with port=" << port<< std::endl;
}
}
libusb_free_device_list(devs, 1); //free the list, unref the devices in it
libusb_exit(ctx); //close the session
return port;
}
int main(int argc, char** argv) {
Device* device;
retcode = 0;
get_options(argc, argv);
if (cmd_args.help)
usage();
device = (Device*) malloc(sizeof(Device));
get_device_id(device);
if (device->id == NULL) {
retcode = 2;
goto cleanup;
}
printf("Found USB Device: %s\n", device->id);
get_device_index(device);
if (device->index < 0) {
retcode = 3;
goto cleanup;
}
get_file_path(device);
program_device(device);
cleanup:
free(device->id);
free(device->file);
free(device);
return retcode;
}
int pci_device_scan(uint16_t vendor_id, uint16_t device_id, struct pci_dev *ref)
{
/* TODO cache bus entries */
uint8_t bus = 0;
for (uint8_t dev = 0; dev < 32; ++dev) {
for (uint8_t func = 0; func < 8; ++func) {
uint16_t _vendor_id = get_vendor_id(bus, dev, func);
if (_vendor_id != 0xFFFF) {
uint16_t _device_id = get_device_id(bus, dev, func);
if (_vendor_id == vendor_id && _device_id == device_id) {
if (ref) {
ref->bus = bus;
ref->dev = dev;
ref->func = func;
}
return 0;
}
}
}
}
return -1;
}
int main(int argc, char **argv)
{
SYS_SetResetCallback(WiiResetPressed);
SYS_SetPowerCallback(WiiPowerPressed);
usleep(250*1000);
GRRLIB_Init();
GRRLIB_ttfFont *font = GRRLIB_LoadTTF(verdana_ttf, verdana_ttf_size);
WPAD_Init();
USB_Initialize();
USB_DeviceChangeNotifyAsync(USB_CLASS_HID, change_notify_cb, NULL);
int dev_id = get_device_id();
int fd = open_device(dev_id);
struct ds4_input data;
memset(&data, 0, sizeof(data));
fetch_data(fd, &data);
random_leds(fd);
int screenW = rmode->fbWidth, screenH = rmode->efbHeight;
float pos_x = screenW/2, pos_y = screenH/2;
while (run) {
WPAD_ScanPads();
u32 pressed = WPAD_ButtonsDown(0);
if (pressed & WPAD_BUTTON_B) {
dev_id = get_device_id();
fd = open_device(dev_id);
}
if (pressed & WPAD_BUTTON_A) {
random_leds(fd);
}
GRRLIB_FillScreen(0x0);
GRRLIB_PrintfTTF(15, 15, font, "ds4wii by xerpi | L1: center | R1: random color", 15, 0xFFFFFFFF);
u32 color = (r<<24)|(g<<16)|(b<<8)|0xFF;
GRRLIB_Circle(pos_x, pos_y, 15, color, 0);
GRRLIB_Circle(pos_x, pos_y, 14, color, 0);
memset(&data, 0, sizeof(data));
fetch_data(fd, &data);
if (data.L1) {pos_x = screenW/2, pos_y = screenH/2;}
if (data.R1) {random_leds(fd);}
//1920x940
if (data.finger1active) {
GRRLIB_Circle((screenW/1920.0f)*data.finger1X, (screenH/940.0f)*data.finger1Y, 10, 0x00FF00FF, 1);
}
if (data.finger2active) {
GRRLIB_Circle((screenW/1920.0f)*data.finger2X, (screenH/940.0f)*data.finger2Y, 10, 0x0000FFFF, 1);
}
/*char buf1[256];
sprintf(buf1, "aX: %8hi aY: %8hi aZ: %8hi", data.accelX, data.accelY, data.accelZ);
char buf2[256];
sprintf(buf2, "gyroX: %8hi gyroY: %8hi gyroZ: %8hi", data.gyroX, data.gyroY, data.gyroZ);
GRRLIB_PrintfTTF(15, 30, font, buf1, 14, 0xFFFFFFFF);
GRRLIB_PrintfTTF(15, 45, font, buf2, 14, 0xFFFFFFFF);
*/
#define THRESHOLD 50.0f
if (fabs(data.accelX) > THRESHOLD)
pos_y -= data.accelX/55.0f;
if (fabs(data.accelY) > THRESHOLD)
pos_x -= data.accelY/55.0f;
if (pressed & WPAD_BUTTON_HOME) run = 0;
GRRLIB_Render();
}
USB_CloseDevice(&fd);
USB_Deinitialize();
GRRLIB_FreeTTF (font);
GRRLIB_Exit();
exit(0);
return 0;
}
LRESULT CALLBACK PaletteProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
LPNMHDR nmhdr;
static char tmpstr[1024];
char *ptr;
int i;
int reinitvideo = 0;
switch(message) {
case WM_INITDIALOG:
CheckDlgButton(hDlg,IDC_FRAMELIMITCHECK,config_get_bool("video.framelimit") ? BST_CHECKED : BST_UNCHECKED);
//video filters
ptr = config_get_string("video.filter");
for(i=0;filters[i];i++) {
ComboBox_AddString(GetDlgItem(hDlg,IDC_FILTERCOMBO),filters[i]);
if(stricmp(filters[i],ptr) == 0)
ComboBox_SetCurSel(GetDlgItem(hDlg,IDC_FILTERCOMBO),i);
}
//scale
for(i=0;scales[i];i++) {
ComboBox_AddString(GetDlgItem(hDlg,IDC_SCALECOMBO),scales[i]);
if((i + 1) == config_get_int("video.scale"))
ComboBox_SetCurSel(GetDlgItem(hDlg,IDC_SCALECOMBO),i);
}
//port1 input devices
ptr = config_get_string("input.port0");
for(i=0;inputdevices[i];i++) {
ComboBox_AddString(GetDlgItem(hDlg,IDC_PORT1COMBO),inputdevices[i]);
if(stricmp(inputdevices[i],ptr) == 0)
ComboBox_SetCurSel(GetDlgItem(hDlg,IDC_PORT1COMBO),i);
}
//port2 input devices
ptr = config_get_string("input.port1");
for(i=0;inputdevices[i];i++) {
ComboBox_AddString(GetDlgItem(hDlg,IDC_PORT2COMBO),inputdevices[i]);
if(stricmp(inputdevices[i],ptr) == 0)
ComboBox_SetCurSel(GetDlgItem(hDlg,IDC_PORT2COMBO),i);
}
//expansion port devices
ptr = config_get_string("input.expansion");
for(i=0;inputexpansion[i];i++) {
ComboBox_AddString(GetDlgItem(hDlg,IDC_EXPANSIONCOMBO),inputexpansion[i]);
if(stricmp(inputexpansion[i],ptr) == 0)
ComboBox_SetCurSel(GetDlgItem(hDlg,IDC_EXPANSIONCOMBO),i);
}
return(TRUE);
case WM_NOTIFY:
nmhdr = (LPNMHDR)lParam;
switch(nmhdr->code) {
case PSN_APPLY:
config_set_bool("video.framelimit",IsDlgButtonChecked(hDlg,IDC_FRAMELIMITCHECK) ? 1 : 0);
ptr = mem_strdup(config_get_string("video.filter"));
GetDlgItemText_SetConfig(hDlg,IDC_FILTERCOMBO,"video.filter");
if(stricmp(ptr,config_get_string("video.filter")) != 0) {
reinitvideo = 1;
}
mem_free(ptr);
i = ComboBox_GetCurSel(GetDlgItem(hDlg,IDC_SCALECOMBO));
if(i != CB_ERR) {
if(config_get_int("video.scale") != (i + 1)) {
config_set_int("video.scale",i + 1);
reinitvideo = 1;
}
}
if(reinitvideo) {
video_reinit();
}
GetDlgItemText_SetConfig(hDlg,IDC_PORT1COMBO,"input.port0");
GetDlgItemText_SetConfig(hDlg,IDC_PORT2COMBO,"input.port1");
nes_set_inputdev(0,get_device_id(config_get_string("input.port0")));
nes_set_inputdev(1,get_device_id(config_get_string("input.port1")));
return(TRUE);
}
break;
}
return(FALSE);
}
int main(int argc, char** argv)
{
int recovery = 0, no_flash = 0, restore_boot = 0, arg_error = 0,
no_reboot = 0, i;
// Parse the arguments
if (argc < 2)
arg_error = 1;
else {
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "recovery") == 0) {
// Check to see if restore option is already set
// Do not allow user to do recovery and restore at the same time
if (restore_boot)
arg_error = 1;
recovery = 1;
} else if (strcmp(argv[i], "restore") == 0) {
// Check to see if recovery option is already set
// Do not allow user to do recovery and restore at the same time
if (recovery)
arg_error = 1;
restore_boot = 1;
} else if (strcmp(argv[i], "noflash") == 0)
no_flash = 1;
else if (strcmp(argv[i], "noreboot") == 0)
no_reboot = 1;
else if (strcmp(argv[i], "verbose") == 0)
verbose = 1;
else if (strcmp(argv[i], "java") == 0)
java = 1;
else
arg_error = 1;
}
}
if (arg_error) {
printf("Invalid argument given.\n");
printf("Valid arguments are:\n");
printf(" recovery -- backs up boot and recovery and flashes recovery to boot\n");
printf(" restore -- restores the most recent backup of boot made by this utility\n");
printf(" noflash -- same as 'recovery' but does not flash boot or reboot at the end\n");
printf(" noreboot -- does not reboot after flashing boot during 'recovery'\n");
printf(" verbose -- show extra debug information\n");
printf("\nNOTE: You cannot do 'recovery' and 'restore' in the same operation.\nFailed\n");
return 0;
}
get_device_id();
if (verbose)
printf("Device ID is: '%s'\n", device_id);
if (strcmp(device_id, "0000000000000000") == 0) {
printf("Error, device ID is all zeros!\n");
printf("Did you 'su' first? HTC Dumlock requires root access.\nFailed\n");
return 0;
}
if (recovery) {
if (!java)
printf("Flashing recovery to boot, this may take a few minutes . . .\n");
flash_recovery_to_boot(no_flash, no_reboot);
}
if (restore_boot) {
printf("Restoring boot, this may take a few minutes . . .\n");
restore_original_boot(no_flash);
}
return 0;
}
device_id_t
detect_device(void)
{
return get_device_id(false);
}
int main(int argc, char* argv[])
{
print_title("BBN APS2 Sequence Player");
argc-=(argc>0); argv+=(argc>0); // skip program name argv[0] if present
option::Stats stats(usage, argc, argv);
option::Option *options = new option::Option[stats.options_max];
option::Option *buffer = new option::Option[stats.buffer_max];
option::Parser parse(usage, argc, argv, options, buffer);
if (parse.error())
return -1;
if (options[HELP] || argc == 0) {
option::printUsage(std::cout, usage);
return 0;
}
for (option::Option* opt = options[UNKNOWN]; opt; opt = opt->next())
std::cout << "Unknown option: " << opt->name << "\n";
for (int i = 0; i < parse.nonOptionsCount(); ++i)
std::cout << "Non-option #" << i << ": " << parse.nonOption(i) << "\n";
//Logging level
TLogLevel logLevel = logINFO;
if (options[LOG_LEVEL]) {
logLevel = TLogLevel(atoi(options[LOG_LEVEL].arg));
}
//Trigger source -- default of internal
APS2_TRIGGER_SOURCE triggerSource = INTERNAL;
if (options[TRIG_MODE]) {
triggerSource = APS2_TRIGGER_SOURCE(atoi(options[TRIG_MODE].arg));
}
set_logging_level(logLevel);
set_log("stdout");
//Trigger interval -- default of 10ms
double trigInterval = 10e-3;
if (options[TRIG_INTERVAL]) {
trigInterval = atof(options[TRIG_INTERVAL].arg);
}
string seqFile;
if (options[SEQ_FILE]){
seqFile = string(options[SEQ_FILE].arg);
} else {
std::cerr << "A sequence file is required.";
return -1;
}
string deviceSerial = get_device_id();
if (deviceSerial.empty()){
cout << concol::RED << "No APS2 devices connected! Exiting..." << concol::RESET << endl;
return 0;
}
connect_APS(deviceSerial.c_str());
double uptime;
get_uptime(deviceSerial.c_str(), &uptime);
cout << concol::CYAN << "Uptime for device " << deviceSerial << " is " << uptime << " seconds" << concol::RESET << endl;
// force initialize device
init_APS(deviceSerial.c_str(), 1);
//load the sequence file
load_sequence_file(deviceSerial.c_str(), seqFile.c_str());
//Set the trigger mode
set_trigger_source(deviceSerial.c_str(), triggerSource);
//Trigger interval
set_trigger_interval(deviceSerial.c_str(), trigInterval);
//Set to sequence mode
set_run_mode(deviceSerial.c_str(), RUN_SEQUENCE);
run(deviceSerial.c_str());
//For software trigger, trigger on key stroke
if (triggerSource == 2) {
cout << concol::YELLOW << "Press t-Return to trigger or q-Return to exit" << concol::RESET << endl;
while(true) {
char keyStroke = cin.get();
if (keyStroke == 't') {
trigger(deviceSerial.c_str());
} else if (keyStroke == 'q') {
break;
}
}
}
else {
cout << concol::YELLOW << "Press any key to stop" << concol::RESET;
cin.get();
}
stop(deviceSerial.c_str());
disconnect_APS(deviceSerial.c_str());
delete[] options;
delete[] buffer;
return 0;
}
bool is_paired(const active_modifier_flag& other) const {
return get_type() == other.get_inverse_type() &&
get_modifier_flag() == other.get_modifier_flag() &&
get_device_id() == other.get_device_id();
}
NTSTATUS WINAPI PNP_AddDevice(DRIVER_OBJECT *driver, DEVICE_OBJECT *PDO)
{
DEVICE_OBJECT *device = NULL;
NTSTATUS status;
minidriver *minidriver;
HID_DEVICE_ATTRIBUTES attr;
BASE_DEVICE_EXTENSION *ext = NULL;
HID_DESCRIPTOR descriptor;
BYTE *reportDescriptor;
INT i;
WCHAR *PDO_id;
WCHAR *id_ptr;
status = get_device_id(PDO, BusQueryInstanceID, &PDO_id);
if (status != STATUS_SUCCESS)
{
ERR("Failed to get PDO id(%x)\n",status);
return status;
}
TRACE("PDO add device(%p:%s)\n", PDO, debugstr_w(PDO_id));
minidriver = find_minidriver(driver);
status = HID_CreateDevice(PDO, &minidriver->minidriver, &device);
if (status != STATUS_SUCCESS)
{
ERR("Failed to create HID object (%x)\n",status);
HeapFree(GetProcessHeap(), 0, PDO_id);
return status;
}
ext = device->DeviceExtension;
InitializeListHead(&ext->irp_queue);
TRACE("Created device %p\n",device);
status = minidriver->AddDevice(minidriver->minidriver.DriverObject, device);
if (status != STATUS_SUCCESS)
{
ERR("Minidriver AddDevice failed (%x)\n",status);
HeapFree(GetProcessHeap(), 0, PDO_id);
HID_DeleteDevice(&minidriver->minidriver, device);
return status;
}
status = call_minidriver(IOCTL_HID_GET_DEVICE_ATTRIBUTES, device,
NULL, 0, &attr, sizeof(attr));
if (status != STATUS_SUCCESS)
{
ERR("Minidriver failed to get Attributes(%x)\n",status);
HID_DeleteDevice(&minidriver->minidriver, device);
HeapFree(GetProcessHeap(), 0, PDO_id);
return status;
}
ext->information.VendorID = attr.VendorID;
ext->information.ProductID = attr.ProductID;
ext->information.VersionNumber = attr.VersionNumber;
ext->information.Polled = minidriver->minidriver.DevicesArePolled;
status = call_minidriver(IOCTL_HID_GET_DEVICE_DESCRIPTOR, device, NULL, 0,
&descriptor, sizeof(descriptor));
if (status != STATUS_SUCCESS)
{
ERR("Cannot get Device Descriptor(%x)\n",status);
HID_DeleteDevice(&minidriver->minidriver, device);
HeapFree(GetProcessHeap(), 0, PDO_id);
return status;
}
for (i = 0; i < descriptor.bNumDescriptors; i++)
if (descriptor.DescriptorList[i].bReportType == HID_REPORT_DESCRIPTOR_TYPE)
break;
if (i >= descriptor.bNumDescriptors)
{
ERR("No Report Descriptor found in reply\n");
HID_DeleteDevice(&minidriver->minidriver, device);
HeapFree(GetProcessHeap(), 0, PDO_id);
return status;
}
reportDescriptor = HeapAlloc(GetProcessHeap(), 0, descriptor.DescriptorList[i].wReportLength);
status = call_minidriver(IOCTL_HID_GET_REPORT_DESCRIPTOR, device, NULL, 0,
reportDescriptor, descriptor.DescriptorList[i].wReportLength);
if (status != STATUS_SUCCESS)
{
ERR("Cannot get Report Descriptor(%x)\n",status);
HID_DeleteDevice(&minidriver->minidriver, device);
HeapFree(GetProcessHeap(), 0, reportDescriptor);
HeapFree(GetProcessHeap(), 0, PDO_id);
return status;
}
ext->preparseData = ParseDescriptor(reportDescriptor, descriptor.DescriptorList[0].wReportLength);
HeapFree(GetProcessHeap(), 0, reportDescriptor);
if (!ext->preparseData)
{
ERR("Cannot parse Report Descriptor\n");
HID_DeleteDevice(&minidriver->minidriver, device);
HeapFree(GetProcessHeap(), 0, PDO_id);
return STATUS_NOT_SUPPORTED;
}
ext->information.DescriptorSize = ext->preparseData->dwSize;
lstrcpyW(ext->instance_id, device_enumeratorW);
strcatW(ext->instance_id, separator_W);
/* Skip the original enumerator */
id_ptr = strchrW(PDO_id, '\\');
id_ptr++;
strcatW(ext->instance_id, id_ptr);
HeapFree(GetProcessHeap(), 0, PDO_id);
sprintfW(ext->device_id, device_deviceid_fmtW, device_enumeratorW, ext->information.VendorID, ext->information.ProductID);
HID_LinkDevice(device);
ext->poll_interval = DEFAULT_POLL_INTERVAL;
ext->ring_buffer = RingBuffer_Create(sizeof(HID_XFER_PACKET) + ext->preparseData->caps.InputReportByteLength);
HID_StartDeviceThread(device);
return STATUS_SUCCESS;
}
bool operator==(const active_modifier_flag& other) const {
return get_type() == other.get_type() &&
get_modifier_flag() == other.get_modifier_flag() &&
get_device_id() == other.get_device_id();
}
int screenshot(char *address, char *plugin_name, char *filename,
int timeout, bool no_gui, void *image_buffer,
int *image_size, char *image_format, char *image_filename)
{
bool no_match = true;
char id[ID_LENGTH_MAX];
bool token_found = true;
char *token = NULL;
int plugin_winner = -1;
int match_count = 0;
int match_count_max = 0;
char *regex_buffer;
int i = 0;
// Check parameters
if (strlen(address) == 0)
{
error_printf("Missing address\n");
exit(EXIT_FAILURE);
}
// Save variables
screenshot_address = address;
screenshot_filename = filename;
screenshot_no_gui = no_gui;
screenshot_image_buffer = image_buffer;
screenshot_image_size = image_size;
screenshot_image_format = image_format;
screenshot_image_filename = image_filename;
if (strlen(plugin_name) == 0)
{
// Get instrument ID
if (get_device_id(address, id, timeout) != 0)
{
error_printf("Unable to retrieve instrument ID\n");
exit(EXIT_FAILURE);
}
// Find relevant screenshot plugin (match instrument ID to plugin)
while ((i < PLUGIN_LIST_SIZE_MAX) && (plugin_list[i] != NULL))
{
// Skip plugin if it has no .regex entry
if (plugin_list[i]->regex == NULL)
{
i++;
continue;
}
// Walk through space separated regular expressions in regex string
regex_buffer = strdup(plugin_list[i]->regex);
while (token_found == true)
{
if (token == NULL)
token = strtok(regex_buffer, " ");
else
token = strtok(NULL, " ");
if (token != NULL)
{
// Match regular expression against ID
if (regex_match(id, token))
match_count++; // Successful match
}
else
token_found = false;
}
free(regex_buffer);
// Plugin with most matches wins
if (match_count > match_count_max)
{
plugin_winner = i;
match_count_max = match_count;
}
// Reset
match_count = 0;
token_found = true;
i++;
}
if (plugin_winner == -1)
{
error_printf("Could not autodetect which screenshot plugin to use - please specify plugin name manually\n");
exit(EXIT_FAILURE);
}
if (isatty(fileno(stdout)) && screenshot_no_gui)
printf("Loaded %s screenshot plugin\n", plugin_list[plugin_winner]->name);
no_match = false;
i = plugin_winner;
}
else
{
// Find relevant screenshot plugin (match specified plugin name to plugin)
while ((i < PLUGIN_LIST_SIZE_MAX) && (plugin_list[i] != NULL))
{
if (strcmp(plugin_list[i]->name, plugin_name) == 0)
{
no_match = false;
break;
}
i++;
}
}
if (no_match)
{
error_printf("Unknown plugin name\n");
exit(EXIT_FAILURE);
}
// Call capture screenshot function
return plugin_list[i]->screenshot(address, timeout);
}
int process() {
memset(device_id, 0, sizeof(device_id));
get_device_id(device_id);
return 0;
}
int create_tun(const char *const name,
const char *const basedev,
int *const tun_itf_id,
size_t *const basedev_mtu,
size_t *const tun_itf_mtu)
{
struct ifreq ifr;
int fd, err;
assert(name != NULL);
assert(basedev != NULL);
assert(tun_itf_id != NULL);
assert(basedev_mtu != NULL);
assert(tun_itf_mtu != NULL);
/* open a file descriptor on the kernel interface */
if((fd = open("/dev/net/tun", O_RDWR)) < 0)
{
trace(LOG_ERR, "failed to open /dev/net/tun: %s (%d)\n",
strerror(errno), errno);
goto error;
}
/* flags: IFF_TUN - TUN device (no Ethernet headers)
* IFF_TAP - TAP device
* IFF_NO_PI - Do not provide packet information */
bzero(&ifr, sizeof(ifr));
strncpy(ifr.ifr_name, name, IFNAMSIZ);
ifr.ifr_name[IFNAMSIZ - 1] = '\0';
ifr.ifr_flags = IFF_TUN | IFF_UP;
/* create the TUN interface */
if((err = ioctl(fd, TUNSETIFF, (void *) &ifr)) < 0)
{
trace(LOG_ERR, "failed to ioctl(TUNSETIFF) on /dev/net/tun: %s (%d)\n",
strerror(errno), errno);
goto close;
}
if(!set_link_mtu(basedev, name, basedev_mtu, tun_itf_mtu))
{
trace(LOG_ERR, "failed to create TUN interface '%s': failed to set MTU",
name);
goto close;
}
trace(LOG_INFO, "MTU of underlying interface '%s' set to %zd bytes",
basedev, *basedev_mtu);
trace(LOG_INFO, "MTU of tunnel interface '%s' set to %zd bytes", name,
*tun_itf_mtu);
if(set_link_up(name) != 0)
{
trace(LOG_ERR, "failed to create TUN interface '%s': failed to set "
"link up", name);
goto close;
}
if(get_device_id(name, tun_itf_id) != 0)
{
trace(LOG_ERR, "failed to create TUN interface '%s': failed to get "
"device ID", name);
goto close;
}
return fd;
close:
close(fd);
error:
return -1;
}
static HRESULT probe_devices(IMMDeviceEnumerator *devenum, EDataFlow flowdir, vector_DevMap *list)
{
IMMDeviceCollection *coll;
IMMDevice *defdev = NULL;
LPWSTR defdevid = NULL;
HRESULT hr;
UINT count;
UINT i;
hr = IMMDeviceEnumerator_EnumAudioEndpoints(devenum, flowdir, DEVICE_STATE_ACTIVE, &coll);
if(FAILED(hr))
{
ERR("Failed to enumerate audio endpoints: 0x%08lx\n", hr);
return hr;
}
count = 0;
hr = IMMDeviceCollection_GetCount(coll, &count);
if(SUCCEEDED(hr) && count > 0)
{
clear_devlist(list);
if(!VECTOR_RESERVE(*list, count))
{
IMMDeviceCollection_Release(coll);
return E_OUTOFMEMORY;
}
hr = IMMDeviceEnumerator_GetDefaultAudioEndpoint(devenum, flowdir,
eMultimedia, &defdev);
}
if(SUCCEEDED(hr) && defdev != NULL)
{
defdevid = get_device_id(defdev);
if(defdevid)
add_device(defdev, defdevid, list);
}
for(i = 0;i < count;++i)
{
IMMDevice *device;
LPWSTR devid;
hr = IMMDeviceCollection_Item(coll, i, &device);
if(FAILED(hr)) continue;
devid = get_device_id(device);
if(devid)
{
if(wcscmp(devid, defdevid) != 0)
add_device(device, devid, list);
CoTaskMemFree(devid);
}
IMMDevice_Release(device);
}
if(defdev) IMMDevice_Release(defdev);
if(defdevid) CoTaskMemFree(defdevid);
IMMDeviceCollection_Release(coll);
return S_OK;
}
// get locations from our device.info
void getLocations()
{
FILE *fp;
int tmpInt;
char tmpText[50];
if (strcmp(get_fstype(),"mtd") == 0)
{
fp = __popen("cat /proc/mtd", "r");
} else if (strcmp(get_fstype(),"emmc") == 0) {
fp = __popen("cat /proc/emmc", "r");
}
if (fp == NULL)
{
ui_print("\n=> Halp! Could not determine flash type!\n");
} else {
while (fscanf(fp,"%s %*s %*s %*c%s",tmp.dev,tmp.mnt) != EOF)
{
if (strcmp(tmp.dev,"dev:") != 0)
{
tmp.dev[strlen(tmp.dev)-1] = '\0';
tmp.mnt[strlen(tmp.mnt)-1] = '\0';
if (sscanf(tmp.dev,"mtd%d",&tmpInt) == 1)
{
sprintf(tmpText,"%smtdblock%d",tw_block,tmpInt);
strcpy(tmp.blk,tmpText);
sprintf(tmpText,"%s%s",tw_mtd,tmp.dev);
strcpy(tmp.dev,tmpText);
} else {
sprintf(tmpText,"%s%s",tw_block,tmp.dev);
strcpy(tmp.dev,tmpText);
strcpy(tmp.blk,tmp.dev);
}
}
if (strcmp(tmp.mnt,"system") == 0) { // read in system line
strcpy(sys.mnt,tmp.mnt);
strcpy(sys.dev,tmp.dev);
strcpy(sys.blk,tmp.blk);
}
if (strcmp(tmp.mnt,"userdata") == 0) {
strcpy(dat.mnt,"data");
strcpy(dat.dev,tmp.dev);
strcpy(dat.blk,tmp.blk);
}
if (strcmp(tmp.mnt,"boot") == 0) {
strcpy(boo.mnt,tmp.mnt);
strcpy(boo.dev,tmp.dev);
strcpy(boo.blk,tmp.blk);
}
if (strcmp(tmp.mnt,"recovery") == 0) {
strcpy(rec.mnt,tmp.mnt);
strcpy(rec.dev,tmp.dev);
strcpy(rec.blk,tmp.blk);
}
if (strcmp(tmp.mnt,"cache") == 0) {
strcpy(cac.mnt,tmp.mnt);
strcpy(cac.dev,tmp.dev);
strcpy(cac.blk,tmp.blk);
}
if (strcmp(tmp.mnt,"wimax") == 0 || strcmp(tmp.mnt,"efs") == 0) {
strcpy(wim.mnt,tmp.mnt);
strcpy(wim.dev,tmp.dev);
strcpy(wim.blk,tmp.blk);
}
}
pclose(fp);
readRecFstab();
}
get_device_id();
}
