/* - subtract ilenoff from length
* - if data, print data (as text?)
* - if remain is too small, terminate
*/
static int print_csa_item(siemens_csa_item * citem, int ilenoff, int data,
int remain, FILE * stream)
{
int size = 4*sizeof(int); /* base offset */
int nbytes = citem->xx[0], nbytes_plus;
int total_size;
/* round nbytes up to next multiple of 4 */
nbytes_plus = csa_item_value_size_aligned(citem, ilenoff);
total_size = csa_item_size(citem, ilenoff);
fprintf(stream, "-- CSA item (size = %d, total = %d, remain = %d)\n",
size, total_size, remain);
fprintf(stream, " xx : %d (offset %d)\n", nbytes, ilenoff);
fputc('\n', stream);
if( total_size > remain ) {
if(g_MDH_verb > 1) fprintf(stderr,"** PCSAI: insufficient space\n\n");
return total_size;
}
if( data && nbytes > 0 )
print_raw_data(" item data : ", citem->value, nbytes, stderr, 1);
return total_size;
}
/**
* print_re_vend_specific_scn
* @brief print the contents of a vendor specific section
*
* @param res rtas_event_scn to print
* @param verbosity verbose level
* @return number of bytes written
*/
int
print_re_vend_errlog_scn(struct scn_header *shdr, int verbosity)
{
struct rtas_vend_errlog *ve;
int len = 0;
if (shdr->scn_id != RTAS_VEND_ERRLOG_SCN) {
errno = EFAULT;
return -1;
}
ve = (struct rtas_vend_errlog *)shdr;
len += print_scn_title("Vendor Error Log Section");
len += rtas_print("%-20s%c%c%c%c\n", "Vendor ID:", ve->vendor_id[0],
ve->vendor_id[1], ve->vendor_id[2], ve->vendor_id[3]);
if (ve->vendor_data != NULL) {
len += rtas_print("Raw Vendor Error Log:\n");
len += print_raw_data(ve->vendor_data, ve->vendor_data_sz);
}
return len;
}
/**
* print_re_src_scn
* @brief print the contents of a SRC section
*
* @param res rtas_event_scn pointer for SRC section
* @param verbosity verbose level of output
* @return number of bytes written
*/
int
print_re_src_scn(struct scn_header *shdr, int verbosity)
{
struct rtas_src_scn *src;
struct rtas_fru_scn *fru;
int len = 0;
int count = 1;
if ((shdr->scn_id != RTAS_PSRC_SCN) && (shdr->scn_id != RTAS_SSRC_SCN)) {
errno = EFAULT;
return 0;
}
src = (struct rtas_src_scn *)shdr;
if (strncmp(src->v6hdr.id, RTAS_PSRC_SCN_ID, 2) == 0)
len += print_v6_hdr("Primary SRC Section",
(struct rtas_v6_hdr *)&src->v6hdr, verbosity);
else
len += print_v6_hdr("Secondary SRC Section",
(struct rtas_v6_hdr *)&src->v6hdr, verbosity);
if (verbosity >= 2) {
len += rtas_print(PRNT_FMT_2"\n", "SRC Version:", src->version,
"Subsections:", src_subscns_included(src));
}
len += rtas_print("Platform Data:\n");
len += print_raw_data((char*)src->src_platform_data,
sizeof(src->src_platform_data));
len += rtas_print("\n");
len += rtas_print("Extended Reference Codes:\n");
len += rtas_print("2: %08x 3: %08x 4: %08x 5: %08x\n",
src->ext_refcode2, src->ext_refcode3,
src->ext_refcode4, src->ext_refcode5);
len += rtas_print("6: %08x 7: %08x 8: %08x 9: %08x\n\n",
src->ext_refcode6, src->ext_refcode7,
src->ext_refcode8, src->ext_refcode9);
len += print_src_refcode(src);
if (src_subscns_included(src)) {
if (verbosity >= 2) {
len += rtas_print(PRNT_FMT_2, "Sub-Section ID:", src->subscn_id,
"Platform Data:", src->subscn_platform_data);
len += rtas_print(PRNT_FMT_R, "Length:", src->subscn_length);
}
}
len += rtas_print("\n");
for (fru = src->fru_scns; fru != NULL; fru = fru->next) {
len += print_re_fru_scn(fru, verbosity, count);
count++;
}
return len;
}
static COMMAND_FUNC( do_print_raw )
{
Trial_Class *tcp;
tcp = pick_trial_class("");
if( tcp == NULL ) return;
if( no_data(QSP_ARG "do_print_raw") ) return;
print_raw_data(QSP_ARG tcp);
}
static COMMAND_FUNC( do_print_raw )
{
Trial_Class *tcp;
tcp = PICK_TRIAL_CLASS("");
if( tcp == NULL ) return;
if( no_data(QSP_ARG "do_print_raw") ) return;
print_raw_data(QSP_ARG tcp);
}
/**
* rtas_print_raw_event
* @brief Dump the entire rtas event in raw format
*
* @param stream ouput stream to write to
* @param re rtas_event pointer
* @return number of bytes written
*/
int
rtas_print_raw_event(FILE *stream, struct rtas_event *re)
{
int len = 0;
ostream = stream;
len += print_scn_title("Raw RTAS Event Begin");
len += print_raw_data(re->buffer, re->event_length);
len += print_scn_title("Raw RTAS Event End");
return len;
}
/* Specific callback after data packet received */
void network_specific_DataIndicationcallback(APS_DataInd_t* indData)
{
AppMessage_t *FrameReceived = (AppMessage_t *) indData->asdu;
/* Data received indication */
switch(FrameReceived->type)
{
case NETWORK_RESET:
reset_avr();
break;
case NETWORK_UART_OVER_ZB:
print_raw_data(FrameReceived->data,indData->asduLength-1);
break;
default:
uprintf("Unknown data type received = %x\r\n",FrameReceived->type);
break;
}
}
/**
* print_v6_dump_scn
* @brief Print the contents of a version 6 dump locator section
*
* @param res rtas_event_scn pointer for dump locator section
* @param verbosity verbose level of output
* @return number of bytes written
*/
int
print_re_dump_scn(struct scn_header *shdr, int verbosity)
{
struct rtas_dump_scn *dump;
int len = 0;
if (shdr->scn_id != RTAS_DUMP_SCN) {
errno = EFAULT;
return 0;
}
dump = (struct rtas_dump_scn *)shdr;
len += print_v6_hdr("Dump Locator section", &dump->v6hdr, verbosity);
len += rtas_print(PRNT_FMT_L, "Dump ID:", dump->id);
len += rtas_print("%-20s%8s\n", "Dump Field Format:",
(dump->fname_type ? "hex" : "ascii"));
len += rtas_print("%-20s%s\n", "Dump Location:",
(dump->location ? "HMC" : "Partition"));
len += rtas_print(PRNT_FMT_ADDR, "Dump Size:",
dump->size_hi, dump->size_lo);
if (verbosity >= 2) {
len += rtas_print("%-20s%8s ", "Dump Size Valid:",
(dump->size_valid ? "Yes" : "No"));
len += rtas_print(PRNT_FMT_R, "Dump ID Length:", dump->id_len);
if (dump->id_len) {
len += rtas_print("Dump ID:");
if (dump->fname_type)
len += print_raw_data(dump->os_id, dump->id_len);
else
len += rtas_print("%s\n", dump->os_id);
}
}
len += rtas_print("\n");
return len;
}
/**
* print_re_generic_scn
*
*/
int
print_re_generic_scn(struct scn_header *shdr, int verbosity)
{
struct rtas_v6_generic *gen;
uint32_t len = 0;
if (shdr->scn_id != RTAS_GENERIC_SCN) {
errno = EFAULT;
return 0;
}
gen = (struct rtas_v6_generic *)shdr;
len += print_v6_hdr("Unknown Section", &gen->v6hdr, 2);
len += rtas_print("\n");
if (gen->data != NULL) {
len += rtas_print("Raw Section Data:\n");
len += print_raw_data(gen->data,
gen->v6hdr.length - sizeof(struct rtas_v6_hdr_raw));
}
len += rtas_print("\n");
return len;
}
int main(int argc, char** argv) {
R_RSA_PUBLIC_KEY public_key;
R_RSA_PRIVATE_KEY private_key;
int i, n, retval;
bool is_valid;
DATA_BLOCK signature, in, out;
unsigned char signature_buf[256], buf[256], buf2[256];
FILE *f, *fpriv, *fpub;
char cbuf[256];
RSA rsa_key;
RSA *rsa_key_;
BIO *bio_out=NULL;
BIO *bio_err=NULL;
char *certpath;
bool b2o=false; // boinc key to openssl key ?
bool kpriv=false; // private key ?
if (argc == 1) {
usage();
exit(1);
}
if (!strcmp(argv[1], "-genkey")) {
if (argc < 5) {
usage();
exit(1);
}
printf("creating keys in %s and %s\n", argv[3], argv[4]);
n = atoi(argv[2]);
srand(random_int());
RSA* rp = RSA_generate_key(n, 65537, 0, 0);
openssl_to_keys(rp, n, private_key, public_key);
fpriv = fopen(argv[3], "w");
if (!fpriv) die("fopen");
fpub = fopen(argv[4], "w");
if (!fpub) die("fopen");
print_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key));
print_key_hex(fpub, (KEY*)&public_key, sizeof(public_key));
} else if (!strcmp(argv[1], "-sign")) {
if (argc < 4) {
usage();
exit(1);
}
fpriv = fopen(argv[3], "r");
if (!fpriv) die("fopen");
retval = scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key));
if (retval) die("scan_key_hex\n");
signature.data = signature_buf;
signature.len = 256;
retval = sign_file(argv[2], private_key, signature);
print_hex_data(stdout, signature);
} else if (!strcmp(argv[1], "-sign_string")) {
if (argc < 4) {
usage();
exit(1);
}
fpriv = fopen(argv[3], "r");
if (!fpriv) die("fopen");
retval = scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key));
if (retval) die("scan_key_hex\n");
generate_signature(argv[2], cbuf, private_key);
puts(cbuf);
} else if (!strcmp(argv[1], "-verify")) {
if (argc < 5) {
usage();
exit(1);
}
fpub = fopen(argv[4], "r");
if (!fpub) die("fopen");
retval = scan_key_hex(fpub, (KEY*)&public_key, sizeof(public_key));
if (retval) die("read_public_key");
f = fopen(argv[3], "r");
signature.data = signature_buf;
signature.len = 256;
retval = scan_hex_data(f, signature);
if (retval) die("scan_hex_data");
retval = verify_file(argv[2], public_key, signature, is_valid);
if (retval) die("verify_file");
if (is_valid) {
printf("file is valid\n");
} else {
printf("file is invalid\n");
return 1;
}
} else if (!strcmp(argv[1], "-test_crypt")) {
if (argc < 4) {
usage();
exit(1);
}
fpriv = fopen(argv[2], "r");
if (!fpriv) die("fopen");
retval = scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key));
if (retval) die("scan_key_hex\n");
fpub = fopen(argv[3], "r");
if (!fpub) die("fopen");
retval = scan_key_hex(fpub, (KEY*)&public_key, sizeof(public_key));
if (retval) die("read_public_key");
strcpy((char*)buf2, "encryption test successful");
in.data = buf2;
in.len = strlen((char*)in.data);
out.data = buf;
encrypt_private(private_key, in, out);
in = out;
out.data = buf2;
decrypt_public(public_key, in, out);
printf("out: %s\n", out.data);
} else if (!strcmp(argv[1], "-cert_verify")) {
if (argc < 6)
die("usage: crypt_prog -cert_verify file signature_file certificate_dir ca_dir \n");
f = fopen(argv[3], "r");
signature.data = signature_buf;
signature.len = 256;
retval = scan_hex_data(f, signature);
if (retval) die("cannot scan_hex_data");
certpath = check_validity(argv[4], argv[2], signature.data, argv[5]);
if (certpath == NULL) {
die("signature cannot be verfied.\n\n");
} else {
printf("siganture verified using certificate '%s'.\n\n", certpath);
free(certpath);
}
// this converts, but an executable signed with sign_executable,
// and signature converted to OpenSSL format cannot be verified with
// OpenSSL
} else if (!strcmp(argv[1], "-convsig")) {
if (argc < 5) {
usage();
exit(1);
}
if (strcmp(argv[2], "b2o") == 0) {
b2o = true;
} else if (strcmp(argv[2], "o2b") == 0) {
b2o = false;
} else {
die("either 'o2b' or 'b2o' must be defined for -convsig\n");
}
if (b2o) {
f = fopen(argv[3], "r");
signature.data = signature_buf;
signature.len = 256;
retval = scan_hex_data(f, signature);
fclose(f);
f = fopen(argv[4], "w+");
print_raw_data(f, signature);
fclose(f);
} else {
f = fopen(argv[3], "r");
signature.data = signature_buf;
signature.len = 256;
retval = scan_raw_data(f, signature);
fclose(f);
f = fopen(argv[4], "w+");
print_hex_data(f, signature);
fclose(f);
}
} else if (!strcmp(argv[1], "-convkey")) {
if (argc < 6) {
usage();
exit(1);
}
if (strcmp(argv[2], "b2o") == 0) {
b2o = true;
} else if (strcmp(argv[2], "o2b") == 0) {
b2o = false;
} else {
die("either 'o2b' or 'b2o' must be defined for -convkey\n");
}
if (strcmp(argv[3], "pub") == 0) {
kpriv = false;
} else if (strcmp(argv[3], "priv") == 0) {
kpriv = true;
} else {
die("either 'pub' or 'priv' must be defined for -convkey\n");
}
OpenSSL_add_all_algorithms();
ERR_load_crypto_strings();
ENGINE_load_builtin_engines();
if (bio_err == NULL) {
bio_err = BIO_new_fp(stdout, BIO_NOCLOSE);
}
//enc=EVP_get_cipherbyname("des");
//if (enc == NULL)
// die("could not get cypher.\n");
// no encription yet.
bio_out=BIO_new(BIO_s_file());
if (BIO_write_filename(bio_out,argv[5]) <= 0) {
perror(argv[5]);
die("could not create output file.\n");
}
if (b2o) {
rsa_key_ = RSA_new();
if (kpriv) {
fpriv = fopen(argv[4], "r");
if (!fpriv) {
die("fopen");
}
scan_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key));
fclose(fpriv);
private_to_openssl(private_key, &rsa_key);
//i = PEM_write_bio_RSAPrivateKey(bio_out, &rsa_key,
// enc, NULL, 0, pass_cb, NULL);
// no encryption yet.
//i = PEM_write_bio_RSAPrivateKey(bio_out, &rsa_key,
// NULL, NULL, 0, pass_cb, NULL);
fpriv = fopen(argv[5], "w+");
PEM_write_RSAPrivateKey(fpriv, &rsa_key, NULL, NULL, 0, 0, NULL);
fclose(fpriv);
//if (i == 0) {
// ERR_print_errors(bio_err);
// die("could not write key file.\n");
//}
} else {
fpub = fopen(argv[4], "r");
if (!fpub) {
die("fopen");
}
scan_key_hex(fpub, (KEY*)&public_key, sizeof(public_key));
fclose(fpub);
fpub = fopen(argv[5], "w+");
if (!fpub) {
die("fopen");
}
public_to_openssl(public_key, rsa_key_);
i = PEM_write_RSA_PUBKEY(fpub, rsa_key_);
if (i == 0) {
ERR_print_errors(bio_err);
die("could not write key file.\n");
}
fclose(fpub);
}
} else {
// o2b
rsa_key_ = (RSA *)calloc(1, sizeof(RSA));
memset(rsa_key_, 0, sizeof(RSA));
if (rsa_key_ == NULL) {
die("could not allocate memory for RSA structure.\n");
}
if (kpriv) {
fpriv = fopen (argv[4], "r");
rsa_key_ = PEM_read_RSAPrivateKey(fpriv, NULL, NULL, NULL);
fclose(fpriv);
if (rsa_key_ == NULL) {
ERR_print_errors(bio_err);
die("could not load private key.\n");
}
openssl_to_private(rsa_key_, &private_key);
fpriv = fopen(argv[5], "w");
if (!fpriv) {
die("fopen");
}
print_key_hex(fpriv, (KEY*)&private_key, sizeof(private_key));
} else {
fpub = fopen (argv[4], "r");
rsa_key_ = PEM_read_RSA_PUBKEY(fpub, NULL, NULL, NULL);
fclose(fpub);
if (rsa_key_ == NULL) {
ERR_print_errors(bio_err);
die("could not load public key.\n");
}
openssl_to_keys(rsa_key_, 1024, private_key, public_key);
//openssl_to_public(rsa_key_, &public_key);
public_to_openssl(public_key, rsa_key_); //
fpub = fopen(argv[5], "w");
if (!fpub) {
die("fopen");
}
print_key_hex(fpub, (KEY*)&public_key, sizeof(public_key));
}
}
} else {
usage();
exit(1);
}
return 0;
}
int main(int argc, char** argv)
{
Options opts = parse_args(argc, argv);
usb_init();
usb_find_busses();
usb_find_devices();
struct usb_device* dev = find_usb_device(0x20d6, 0xcb17);
int acc_x_min = 0;
int acc_y_min = 0;
int acc_z_min = 0;
int acc_x_max = 0;
int acc_y_max = 0;
int acc_z_max = 0;
int touch_pos_x = 0;
int touch_pos_y = 0;
bool finger_touching = false;
bool pinch_touching = false;
bool scroll_wheel = false;
int wheel_distance = 0;
if (dev)
{
std::unique_ptr<USBDevice> usbdev(new USBDevice(dev));
usbdev->print_info();
usbdev->detach_kernel_driver(0);
usbdev->claim_interface(0);
Evdev evdev;
// init evdev
if (opts.gamepad_mode)
{
evdev.add_abs(ABS_X, -1, 1, 0, 0);
evdev.add_abs(ABS_Y, -1, 1, 0, 0);
evdev.add_key(BTN_A);
evdev.add_key(BTN_B);
evdev.add_key(BTN_X);
evdev.add_key(BTN_Y);
evdev.add_key(BTN_START);
evdev.add_key(BTN_SELECT);
evdev.add_key(BTN_Z);
}
else if (opts.keyboard_mode)
{
evdev.add_key(KEY_LEFT);
evdev.add_key(KEY_RIGHT);
evdev.add_key(KEY_UP);
evdev.add_key(KEY_DOWN);
evdev.add_key(KEY_ENTER);
evdev.add_key(KEY_SPACE);
evdev.add_key(KEY_A);
evdev.add_key(KEY_Z);
evdev.add_key(KEY_ESC);
evdev.add_key(KEY_TAB);
}
else if (opts.tablet_mode)
{
evdev.add_abs(ABS_X, 0, 1913, 0, 0);
evdev.add_abs(ABS_Y, 0, 1076, 0, 0);
evdev.add_abs(ABS_PRESSURE, 0, 143, 0, 0);
evdev.add_key(BTN_TOUCH);
evdev.add_key(BTN_TOOL_PEN);
evdev.add_rel(REL_WHEEL);
evdev.add_rel(REL_HWHEEL);
evdev.add_rel(REL_X);
evdev.add_rel(REL_Y);
}
else if (opts.touchpad_mode)
{
evdev.add_key(BTN_LEFT);
evdev.add_key(BTN_RIGHT);
evdev.add_key(BTN_MIDDLE);
/*
add_key(KEY_FORWARD);
add_key(KEY_BACK);
*/
evdev.add_rel(REL_WHEEL);
evdev.add_rel(REL_HWHEEL);
evdev.add_rel(REL_X);
evdev.add_rel(REL_Y);
}
evdev.finish();
usbdev->listen
(3,
[&](uint8_t* data, int size)
{
UDrawDecoder decoder(data, size);
if (opts.keyboard_mode)
{
evdev.send(EV_KEY, KEY_LEFT, decoder.get_left());
evdev.send(EV_KEY, KEY_RIGHT, decoder.get_right());
evdev.send(EV_KEY, KEY_UP, decoder.get_up());
evdev.send(EV_KEY, KEY_DOWN, decoder.get_down());
evdev.send(EV_KEY, KEY_ENTER, decoder.get_cross());
evdev.send(EV_KEY, KEY_SPACE, decoder.get_circle());
evdev.send(EV_KEY, KEY_A, decoder.get_square());
evdev.send(EV_KEY, KEY_Z, decoder.get_triangle());
evdev.send(EV_KEY, KEY_ESC, decoder.get_start());
evdev.send(EV_KEY, KEY_TAB, decoder.get_select());
evdev.send(EV_SYN, SYN_REPORT, 0);
}
else if (opts.gamepad_mode)
{
evdev.send(EV_ABS, ABS_X, -1 * decoder.get_left() + 1 * decoder.get_right());
evdev.send(EV_ABS, ABS_Y, -1 * decoder.get_up() + 1 * decoder.get_down());
evdev.send(EV_KEY, BTN_A, decoder.get_cross());
evdev.send(EV_KEY, BTN_B, decoder.get_circle());
evdev.send(EV_KEY, BTN_X, decoder.get_square());
evdev.send(EV_KEY, BTN_Y, decoder.get_triangle());
evdev.send(EV_KEY, BTN_START, decoder.get_start());
evdev.send(EV_KEY, BTN_SELECT, decoder.get_select());
evdev.send(EV_KEY, BTN_Z, decoder.get_guide());
evdev.send(EV_SYN, SYN_REPORT, 0);
}
else if (opts.tablet_mode)
{
if (decoder.get_mode() == UDrawDecoder::PEN_MODE)
{
evdev.send(EV_ABS, ABS_X, decoder.get_x());
evdev.send(EV_ABS, ABS_Y, decoder.get_y());
evdev.send(EV_ABS, ABS_PRESSURE, decoder.get_pressure());
evdev.send(EV_KEY, BTN_TOOL_PEN, 1);
if (decoder.get_pressure() > 0)
{
evdev.send(EV_KEY, BTN_TOUCH, 1);
}
else
{
evdev.send(EV_KEY, BTN_TOUCH, 0);
}
evdev.send(EV_SYN, SYN_REPORT, 0);
}
else
{
evdev.send(EV_KEY, BTN_TOOL_PEN, 0);
evdev.send(EV_SYN, SYN_REPORT, 0);
}
}
else if (opts.touchpad_mode)
{
evdev.send(EV_KEY, BTN_LEFT, decoder.get_right());
evdev.send(EV_KEY, BTN_RIGHT, decoder.get_left());
if (decoder.get_mode() == UDrawDecoder::FINGER_MODE)
{
if (!finger_touching)
{
touch_pos_x = decoder.get_x();
touch_pos_y = decoder.get_y();
finger_touching = true;
if (touch_pos_x > 1800)
{
scroll_wheel = true;
wheel_distance = 0;
}
else
{
scroll_wheel = false;
}
}
if (scroll_wheel)
{
wheel_distance += (decoder.get_y() - touch_pos_y) / 10;
int rel = wheel_distance/10;
if (rel != 0)
{
evdev.send(EV_REL, REL_WHEEL, -rel);
wheel_distance -= rel;
touch_pos_x = decoder.get_x();
touch_pos_y = decoder.get_y();
//std::cout << rel << " " << wheel_distance << std::endl;
}
}
else
{
evdev.send(EV_REL, REL_X, decoder.get_x() - touch_pos_x);
evdev.send(EV_REL, REL_Y, decoder.get_y() - touch_pos_y);
touch_pos_x = decoder.get_x();
touch_pos_y = decoder.get_y();
}
}
else
{
finger_touching = false;
}
evdev.send(EV_SYN, SYN_REPORT, 0);
}
else if (opts.accelerometer_mode)
{
if (size != 27)
{
std::cerr << "unknown read size: " << size << std::endl;
}
else
{
//data[0];
int x = data[15] * 255 + data[17]; // x - pen: 3px resolution
int y = data[16] * 255 + data[18]; // y - finger: 1px resolution
if (data[11] == 0x00)
{
std::cout << "nothing";
}
else if (data[11] == 0x80)
{
std::cout << boost::format("finger: x: %4d y: %4d") % x % y;
}
else if (data[11] == 0x40)
{
std::cout << boost::format("pen: x: %4d y: %4d - pressure: %3d") % x % y % (int(data[13]) - 0x70);
}
else
{
std::cout << boost::format("pinch: x: %4d y: %4d distance: %4d orientation: %02x") % x % y % int(data[12]) % (int(data[11]) - 0xc0);
}
int acc_x = ((data[19] + data[20] * 255) - 512);
int acc_y = ((data[21] + data[22] * 255) - 512);
int acc_z = ((data[23] + data[24] * 255) - 512);
acc_x_min = std::min(acc_x, acc_x_min);
acc_y_min = std::min(acc_y, acc_y_min);
acc_z_min = std::min(acc_z, acc_z_min);
acc_x_max = std::max(acc_x, acc_x_max);
acc_y_max = std::max(acc_y, acc_y_max);
acc_z_max = std::max(acc_z, acc_z_max);
// acc_min -31 -33 -33
// acc_max 31 28 29
// ~22 == 1g
// accelerometer
std::cout << boost::format("%4d %4d %4d - %4d %4d %4d - %4d %4d %4d") %
acc_x % acc_y % acc_z %
acc_x_min % acc_y_min % acc_z_min %
acc_x_max % acc_y_max % acc_z_max;
std::cout << std::endl;
}
}
else
{
print_raw_data(std::cout, data, size);
std::cout << std::endl;
}
if (false)
{
evdev.send(EV_KEY, BTN_RIGHT, decoder.get_left());
evdev.send(EV_KEY, BTN_MIDDLE, decoder.get_up());
evdev.send(EV_KEY, BTN_LEFT, decoder.get_right());
evdev.send(EV_REL, REL_WHEEL, decoder.get_triangle() ? 1 : 0);
evdev.send(EV_REL, REL_WHEEL, decoder.get_cross() ? -1 : 0);
evdev.send(EV_KEY, KEY_BACK, decoder.get_circle());
evdev.send(EV_KEY, KEY_FORWARD, decoder.get_square());
if (false)
{
// FIXME: does not work as is, needs throttling
if (decoder.get_mode() == UDrawDecoder::PINCH_MODE)
{
if (!pinch_touching)
{
touch_pos_x = decoder.get_x();
touch_pos_y = decoder.get_y();
pinch_touching = true;
}
evdev.send(EV_REL, REL_HWHEEL, decoder.get_x() - touch_pos_x);
evdev.send(EV_REL, REL_WHEEL, decoder.get_y() - touch_pos_y);
touch_pos_x = decoder.get_x();
touch_pos_y = decoder.get_y();
}
else
{
pinch_touching = false;
}
evdev.send(EV_SYN, SYN_REPORT, 0);
}
}
});
}
return 0;
}
Xbox360Controller::Xbox360Controller(struct usb_device* dev_, bool is_guitar_, bool try_detach) :
dev(dev_),
is_guitar(is_guitar_),
dev_type(),
handle(),
endpoint_in(1),
endpoint_out(2),
read_thread()
{
find_endpoints();
if (0)
{
std::cout << "EP(IN): " << endpoint_in << std::endl;
std::cout << "EP(OUT): " << endpoint_out << std::endl;
}
handle = usb_open(dev);
if (0)
{
int err;
if ((err = usb_set_configuration(handle, 0)) < 0)
{
std::ostringstream out;
out << "Error set USB configuration: " << usb_strerror() << std::endl
<< "Try to run 'rmmod xpad' and then xboxdrv again or start xboxdrv with the option --detach-kernel-driver.";
throw std::runtime_error(out.str());
}
}
if (!handle)
{
throw std::runtime_error("Error opening Xbox360 controller");
}
else
{
// FIXME: bInterfaceNumber shouldn't be hardcoded
int err = usb_claim_n_detach_interface(handle, 0, try_detach);
if (err != 0)
{
std::ostringstream out;
out << " Error couldn't claim the USB interface: " << usb_strerror() << std::endl
<< "Try to run 'rmmod xpad' and then xboxdrv again or start xboxdrv with the option --detach-kernel-driver.";
throw std::runtime_error(out.str());
}
}
if (0)
{
unsigned char arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 16, 32, 64, 128, 255 };
for (int len = 3; len <= 8; ++len)
{
// Sending random data:
for (int front = 0; front < 256; ++front)
{
for (size_t i = 0; i < sizeof(arr); ++i)
{
char ledcmd[] = { front, len, arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i], arr[i] };
printf("%d %d %d\n", len, front, arr[i]);
usb_interrupt_write(handle, endpoint_out, ledcmd, len, 0);
uint8_t data[32];
int ret = usb_interrupt_read(handle, endpoint_in, reinterpret_cast<char*>(data), sizeof(data), 20);
print_raw_data(std::cout, data, ret);
}
}
}
}
read_thread = std::auto_ptr<USBReadThread>(new USBReadThread(handle, endpoint_in, 32));
read_thread->start_thread();
}
bool
Xbox360Controller::read(XboxGenericMsg& msg, bool verbose, int timeout)
{
uint8_t data[32];
int ret = 0;
if (read_thread.get())
{
ret = read_thread->read(data, sizeof(data), timeout);
}
else
{
ret = usb_interrupt_read(handle, endpoint_in, reinterpret_cast<char*>(data), sizeof(data), timeout);
}
if (ret == -ETIMEDOUT)
{
return false;
}
else if (ret < 0)
{ // Error
std::ostringstream str;
str << "Xbox360Controller: USBError: " << ret << "\n" << usb_strerror();
throw std::runtime_error(str.str());
}
else if (ret == 0)
{
if (verbose)
{
std::cout << "zero length read" << std::endl;
// happens with the Xbox360 controller every now and then, just
// ignore, seems harmless, so just ignore
}
}
else if (ret == 3 && data[0] == 0x01 && data[1] == 0x03)
{
if (verbose)
{
std::cout << "Xbox360Controller: LED Status: " << int(data[2]) << std::endl;
}
}
else if (ret == 3 && data[0] == 0x03 && data[1] == 0x03)
{
if (verbose)
{
// data[2] == 0x00 means that rumble is disabled
// data[2] == 0x01 unknown, but rumble works
// data[2] == 0x02 unknown, but rumble works
// data[2] == 0x03 is default with rumble enabled
std::cout << "Xbox360Controller: Rumble Status: " << int(data[2]) << std::endl;
}
}
else if (ret == 3 && data[0] == 0x08 && data[1] == 0x03)
{
if (!g_options->quiet)
{
if (data[2] == 0x00)
std::cout << "Headset: none";
else if (data[2] == 0x02)
std::cout << "Headset: none";
}
}
else if (ret == 20 && data[0] == 0x00 && data[1] == 0x14)
{
if (is_guitar)
{
msg.type = XBOX_MSG_XBOX360_GUITAR;
memcpy(&msg.guitar, data, sizeof(Xbox360GuitarMsg));
}
else
{
msg.type = XBOX_MSG_XBOX360;
memcpy(&msg.xbox360, data, sizeof(Xbox360Msg));
}
return true;
}
else
{
std::cout << "Unknown: ";
print_raw_data(std::cout, data, ret);
}
return false;
}
