int main(void)
{
//256
uint8_t key[] = { 0x60, 0x3d, 0xeb, 0x10, 0x15, 0xca, 0x71, 0xbe, 0x2b, 0x73, 0xae, 0xf0, 0x85, 0x7d, 0x77, 0x81,
0x1f, 0x35, 0x2c, 0x07, 0x3b, 0x61, 0x08, 0xd7, 0x2d, 0x98, 0x10, 0xa3, 0x09, 0x14, 0xdf, 0xf4 };
uint8_t in[] = { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a};
uint8_t out[16];
for(int i = 0; i < 16; i++)
{
out[i] = in[i];
}
phex(out,16);
struct AES_ctx ctx;
AES_init_ctx(&ctx, key);
AES_ECB_encrypt(&ctx, in);
phex(in,16);
AES_init_ctx(&ctx, key);
AES_ECB_decrypt(&ctx, in);
phex(out,16);
return 0;
}
void usb_keyboard_print_report(report_keyboard_t *report)
{
if (!debug_keyboard) return;
print("keys: ");
for (int i = 0; i < REPORT_KEYS; i++) { phex(report->keys[i]); print(" "); }
print(" mods: "); phex(report->mods); print("\n");
}
void parse_macro(char* line){
uint8_t action, length, i, j = 0;
if(memcmp(line,"[MACRO_",7)==0){
macro_idx = line[7] - '0' - 1;
} else {
ptr = line;
j=0;
while((token = strtok_r(ptr, ",", &rest)) != NULL) {
ptr2 = token;
i = length = action = 0;
while((token2 = strtok_r(ptr2, ":", &rest2)) != NULL) {
if(i==0){
length = atoi(token2);
} else if(i == 1){
action = lookup_id(token2);
}
i++;
ptr2 = rest2;
}
phex(action); phex(length); print("\n");
macro_steps[macro_idx][(j*2)] = action;
macro_steps[macro_idx][(j*2)+1] = length;
ptr = rest;
j++;
}
macro_sizes[macro_idx] = j;
//for(j=0;j<macro_sizes[macro_idx];){
// phex(j);phex(macro_steps[macro_idx][j++]); phex(macro_steps[macro_idx][j++]);print(" ");
//}
}
}
void usb_mouse_print(int8_t x, int8_t y, int8_t wheel_v, int8_t wheel_h, uint8_t buttons) {
if (!debug_mouse) return;
print("usb_mouse[btn|x y v h]: ");
phex(buttons); print("|");
phex(x); print(" ");
phex(y); print(" ");
phex(wheel_v); print(" ");
phex(wheel_h); print("\n");
}
void debug_print(void) {
debug_counter++;
if(debug_counter > 100) {
debug_counter = 0;
for(uint8_t i = 0; i < 7; i++)
phex(queue[i]);
print("\n");
for(uint8_t k = 0; k < NUMBER_OF_KEYS; k++)
phex(key[k].bounce);
print("\n");
}
}
static NOINLINE void ffDoTimeout(void)
{
++ff_timeoutCount;
#ifdef DEBUG
print("bad flip flop status : ");
phex(ff_step);
phex(io_read(0x9));
print(" timeout count : ");
phex(ff_timeoutCount);
print("\n");
#endif
}
void action_function(keyrecord_t *event, uint8_t id, uint8_t opt)
{
print("action_function called\n");
print("id = "); phex(id); print("\n");
print("opt = "); phex(opt); print("\n");
if (id == TEENSY_KEY) {
clear_keyboard();
print("\n\nJump to bootloader... ");
_delay_ms(250);
bootloader_jump(); // should not return
print("not supported.\n");
}
}
static void test_decrypt_cbc(void)
{
// Example "simulating" a smaller buffer...
uint8_t key[] = { 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x61, 0x62, 0x63, 0x64, 0x65, 0x0a };
uint8_t iv[] = { 0x4b, 0xb2, 0x77, 0x87, 0x77, 0xb8, 0x8b, 0xe0, 0xf8, 0x53, 0x4b, 0x7b, 0xd5, 0xba, 0x91, 0x30 };
/*uint8_t in[] = { 0x28, 0x93, 0x77, 0xc4, 0x9f, 0x3e, 0xd4, 0x9a, 0x1e, 0x85, 0x84, 0x58, 0x6b, 0x40, 0x23, 0xf8,
0xff, 0xbd, 0x21, 0x0f, 0x2a, 0x62, 0xe5, 0x4e, 0x6e, 0x89, 0xad, 0x96, 0xee, 0x2e, 0xf2, 0xb9,
0x73, 0xbe, 0xd6, 0xb8, 0xe3, 0xc1, 0x74, 0x3b, 0x71, 0x16, 0xe6, 0x9e, 0x22, 0x22, 0x95, 0x16,
0x3f, 0xf1, 0xca, 0xa1, 0x68, 0x1f, 0xac, 0x09, 0x12, 0x0e, 0xca, 0x30, 0x75, 0x86, 0xe1, 0xa7 };
uint8_t out[] = { 0x6b, 0xc1, 0xbe, 0xe2, 0x2e, 0x40, 0x9f, 0x96, 0xe9, 0x3d, 0x7e, 0x11, 0x73, 0x93, 0x17, 0x2a,
0xae, 0x2d, 0x8a, 0x57, 0x1e, 0x03, 0xac, 0x9c, 0x9e, 0xb7, 0x6f, 0xac, 0x45, 0xaf, 0x8e, 0x51,
0x30, 0xc8, 0x1c, 0x46, 0xa3, 0x5c, 0xe4, 0x11, 0xe5, 0xfb, 0xc1, 0x19, 0x1a, 0x0a, 0x52, 0xef,
0xf6, 0x9f, 0x24, 0x45, 0xdf, 0x4f, 0x9b, 0x17, 0xad, 0x2b, 0x41, 0x7b, 0xe6, 0x6c, 0x37, 0x10 };
*/
char in[32] = "1234567890abcdef";
char out[64] = {0};
uint8_t buffer[64] = {0};
int j;
for ( j = 16; j<32; j++)
{
in[j] = 0x10;
}
printf("xtx CBC encrypt: \n");
AES128_CBC_encrypt_buffer(buffer+0, in+0, 32, key, iv);
phex(buffer);
//AES128_CBC_decrypt_buffer(buffer+16, in+16, 16, 0, 0);
phex(buffer+16);
//AES128_CBC_decrypt_buffer(buffer+32, in+32, 16, 0, 0);
//AES128_CBC_decrypt_buffer(buffer+48, in+48, 16, 0, 0);
printf("xtx CBC encrypt: \n");
int i;
for(i = 0; i < 4; ++i)
{
//AES128_CBC_decrypt_buffer(buffer + (i*16), in+(i*16), 16, key, iv);
//phex(buffer + (i*16));
}
printf("\n");
if(0 == strncmp((char*) out, (char*) buffer, 64))
{
printf("SUCCESS!\n");
}
else
{
printf("FAILURE!\n");
}
}
bool TCPConnection::write(uint8_t *buf, int len) {
if (stopped) {
return false;
}
assert(buf);
assert(len > 0);
boost::shared_array<uint8_t> bufCpy(new uint8_t[len]);
memcpy(bufCpy.get(), buf, len);
pendingWrites.increment();
beetle.writers.schedule(getId(), [this, bufCpy, len] {
uint8_t bufLen = len;
if (SSL_write_all(ssl, &bufLen, 1) != 1 || SSL_write_all(ssl, bufCpy.get(), len) != len) {
if (debug_socket) {
std::stringstream ss;
ss << "socket write failed : " << strerror(errno);
pdebug(ss.str());
}
stopInternal();
} else {
if (debug_socket) {
pdebug("wrote " + std::to_string(len) + " bytes to " + getName());
phex(bufCpy.get(), len);
}
}
pendingWrites.decrement();
});
return true;
}
void matrix_print(void) {
print("\nr/c 0123456789ABCDEF\n");
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": ");
pbin_reverse16(matrix_get_row(row));
print("\n");
}
}
void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
print("\n");
}
}
void matrix_print(void) {
print_matrix_header();
for (uint8_t row = 0; row < MATRIX_ROWS; row++) {
phex(row); print(": ");
print_matrix_row(row);
print("\n");
}
}
void m0110_init(void)
{
uint8_t data;
idle();
_delay_ms(1000);
// Model Number
// M0110 : 0x09 00001001 : model number 4 (100)
// M0110A: 0x0B 00001011 : model number 5 (101)
// M0110 & M0120: ???
m0110_send(M0110_MODEL);
data = m0110_recv();
print("m0110_init model: "); phex(data); print("\n");
m0110_send(M0110_TEST);
data = m0110_recv();
print("m0110_init test: "); phex(data); print("\n");
}
/* get data received by interrupt */
uint8_t ps2_host_recv(void)
{
if (ps2_error) {
print("x");
phex(ps2_error);
ps2_host_send(0xFE); // request to resend
ps2_error = PS2_ERR_NONE;
}
idle();
return pbuf_dequeue();
}
static void mousekey_debug(void)
{
if (!debug_mouse) return;
print("mousekey [btn|x y v h](rep/acl): [");
phex(mouse_report.buttons); print("|");
print_decs(mouse_report.x); print(" ");
print_decs(mouse_report.y); print(" ");
print_decs(mouse_report.v); print(" ");
print_decs(mouse_report.h); print("](");
print_dec(mousekey_repeat); print("/");
print_dec(mousekey_accel); print(")\n");
}
void matrix_print() {
print( "\nr/c 0123456789ABCDEFGHI\n" );
for ( uint8_t row = 0; row < MATRIX_ROWS; row++ ) {
phex( row );
print( ": " );
xprintf( "%019lb", bitrev32( matrix_get_row( row ) ) >> 13 );
print( "\n" );
}
}
static void test_encrypt_ecb_verbose(void)
{
// Example of more verbose verification
uint8_t i, buf[64], buf2[64];
// 128bit key
uint8_t key[16] = { (uint8_t) 0x2b, (uint8_t) 0x7e, (uint8_t) 0x15, (uint8_t) 0x16, (uint8_t) 0x28, (uint8_t) 0xae, (uint8_t) 0xd2, (uint8_t) 0xa6, (uint8_t) 0xab, (uint8_t) 0xf7, (uint8_t) 0x15, (uint8_t) 0x88, (uint8_t) 0x09, (uint8_t) 0xcf, (uint8_t) 0x4f, (uint8_t) 0x3c };
// 512bit text
uint8_t plain_text[64] = { (uint8_t) 0x6b, (uint8_t) 0xc1, (uint8_t) 0xbe, (uint8_t) 0xe2, (uint8_t) 0x2e, (uint8_t) 0x40, (uint8_t) 0x9f, (uint8_t) 0x96, (uint8_t) 0xe9, (uint8_t) 0x3d, (uint8_t) 0x7e, (uint8_t) 0x11, (uint8_t) 0x73, (uint8_t) 0x93, (uint8_t) 0x17, (uint8_t) 0x2a,
(uint8_t) 0xae, (uint8_t) 0x2d, (uint8_t) 0x8a, (uint8_t) 0x57, (uint8_t) 0x1e, (uint8_t) 0x03, (uint8_t) 0xac, (uint8_t) 0x9c, (uint8_t) 0x9e, (uint8_t) 0xb7, (uint8_t) 0x6f, (uint8_t) 0xac, (uint8_t) 0x45, (uint8_t) 0xaf, (uint8_t) 0x8e, (uint8_t) 0x51,
(uint8_t) 0x30, (uint8_t) 0xc8, (uint8_t) 0x1c, (uint8_t) 0x46, (uint8_t) 0xa3, (uint8_t) 0x5c, (uint8_t) 0xe4, (uint8_t) 0x11, (uint8_t) 0xe5, (uint8_t) 0xfb, (uint8_t) 0xc1, (uint8_t) 0x19, (uint8_t) 0x1a, (uint8_t) 0x0a, (uint8_t) 0x52, (uint8_t) 0xef,
(uint8_t) 0xf6, (uint8_t) 0x9f, (uint8_t) 0x24, (uint8_t) 0x45, (uint8_t) 0xdf, (uint8_t) 0x4f, (uint8_t) 0x9b, (uint8_t) 0x17, (uint8_t) 0xad, (uint8_t) 0x2b, (uint8_t) 0x41, (uint8_t) 0x7b, (uint8_t) 0xe6, (uint8_t) 0x6c, (uint8_t) 0x37, (uint8_t) 0x10 };
memset(buf, 0, 64);
memset(buf2, 0, 64);
// print text to encrypt, key and IV
printf("ECB encrypt verbose:\n\n");
printf("plain text:\n");
for(i = (uint8_t) 0; i < (uint8_t) 4; ++i)
{
phex(plain_text + i * (uint8_t) 16);
}
printf("\n");
printf("key:\n");
phex(key);
printf("\n");
// print the resulting cipher as 4 x 16 byte strings
printf("ciphertext:\n");
for(i = 0; i < 4; ++i)
{
AES128_ECB_encrypt(plain_text + (i*16), key, buf+(i*16));
phex(buf + (i*16));
}
printf("\n");
}
static LOWERCODESIZE void tuneCV(p600CV_t oscCV, p600CV_t ampCV)
{
#ifdef DEBUG
print("\ntuning ");phex(oscCV);print("\n");
#endif
int8_t isOsc,i;
// init
tuner.currentCV=oscCV;
isOsc=(oscCV<pcFil1);
// open VCA
sh_setCV(ampCV,UINT16_MAX,0);
// tune
if (isOsc)
{
for(i=TUNER_OSC_NTH_C_LO;i<=TUNER_OSC_NTH_C_HI;++i)
if (tuneOffset(oscCV,i,12*(TUNER_OSC_NTH_C_LO-2),TUNER_OSC_PRECISION))
break;
// extrapolate for octaves that aren't directly tunable
for(i=TUNER_OSC_NTH_C_LO-1;i>=0;--i)
settings.tunes[i][oscCV]=(uint32_t)2*settings.tunes[i+1][oscCV]-settings.tunes[i+2][oscCV];
for(i=TUNER_OSC_NTH_C_HI+1;i<TUNER_OCTAVE_COUNT;++i)
settings.tunes[i][oscCV]=(uint32_t)2*settings.tunes[i-1][oscCV]-settings.tunes[i-2][oscCV];
}
else
{
for(i=TUNER_FIL_NTH_C_LO;i<=TUNER_FIL_NTH_C_HI;++i)
if (tuneOffset(oscCV,i,12*(TUNER_FIL_NTH_C_LO-1),TUNER_FIL_PRECISION))
break;
for(i=TUNER_FIL_NTH_C_LO-1;i>=0;--i)
settings.tunes[i][oscCV]=(uint32_t)2*settings.tunes[i+1][oscCV]-settings.tunes[i+2][oscCV];
for(i=TUNER_FIL_NTH_C_HI+1;i<TUNER_OCTAVE_COUNT;++i)
settings.tunes[i][oscCV]=(uint32_t)2*settings.tunes[i-1][oscCV]-settings.tunes[i-2][oscCV];
}
// close VCA
sh_setCV(ampCV,0,0);
sh_update();
}
/* transfer keyboard report from buffer */
void vusb_transfer_keyboard(void)
{
if (usbInterruptIsReady()) {
if (kbuf_head != kbuf_tail) {
usbSetInterrupt((void *)&kbuf[kbuf_tail], sizeof(report_keyboard_t));
kbuf_tail = (kbuf_tail + 1) % KBUF_SIZE;
if (debug_keyboard) {
print("V-USB: kbuf["); pdec(kbuf_tail); print("->"); pdec(kbuf_head); print("](");
phex((kbuf_head < kbuf_tail) ? (KBUF_SIZE - kbuf_tail + kbuf_head) : (kbuf_head - kbuf_tail));
print(")\n");
}
}
}
}
char flash_checkId(void)
{
unsigned char mfg,dev;
flash_command(0x90);
SET_ADDR(0);
mfg=flash_getData();
print("mfg ");
phex(mfg);
print(" dev ");
SET_ADDR(1);
dev=flash_getData();
phex(dev);
print("\n");
flash_command(0xf0);
return (mfg==0x9d) && (dev==0x1d || dev==0x2d);
}
void matrix_print(void)
{
print("\nr/c 01234567\n");
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
pbin_reverse(matrix_get_row(row));
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
}
/* spin-down a disk */
static void spindown_disk(const char *name)
{
struct sg_io_hdr io_hdr;
unsigned char sense_buf[255];
char dev_name[100];
int fd;
dprintf("spindown: %s\n", name);
/* fabricate SCSI IO request */
memset(&io_hdr, 0x00, sizeof(io_hdr));
io_hdr.interface_id = 'S';
io_hdr.dxfer_direction = SG_DXFER_NONE;
/* SCSI stop unit command */
io_hdr.cmdp = (unsigned char *) "\x1b\x00\x00\x00\x00\x00";
io_hdr.cmd_len = 6;
io_hdr.sbp = sense_buf;
io_hdr.mx_sb_len = (unsigned char) sizeof(sense_buf);
/* open disk device (kernel 2.4 will probably need "sg" names here) */
snprintf(dev_name, sizeof(dev_name), "/dev/%s", name);
if ((fd = open(dev_name, O_RDONLY)) < 0)
{
perror(dev_name);
return;
}
/* execute SCSI request */
if (ioctl(fd, SG_IO, &io_hdr) < 0)
{
char buf[100];
snprintf(buf, sizeof(buf), "ioctl on %s:", name);
perror(buf);
}
else if (io_hdr.masked_status != 0)
{
fprintf(stderr, "error: SCSI command failed with status 0x%02x\n",
io_hdr.masked_status);
if (io_hdr.masked_status == CHECK_CONDITION)
{
phex(sense_buf, io_hdr.sb_len_wr, "sense buffer:\n");
}
}
close(fd);
}
void move_mouse(void) {
/* don't move the mouse unless we already took 2 readings */
if (!initalized) {
initalized = 1;
} else {
// ignore least significant bit, as it's probably noise
currentX = currentX >> 1;
currentY = currentY >> 1;
deltaX = previousX - currentX;
deltaY = previousY - currentY;
if (((deltaX < THRESHOLD) && (deltaX > -THRESHOLD))
&& (deltaY < THRESHOLD && (deltaY > -THRESHOLD))) {
#ifdef DEBUG
if (deltaX != 0 || deltaY != 0) {
print("x="); phex(deltaX); print("\t");
print("y="); phex(deltaY); print("\n");
}
#endif
usb_mouse_move(deltaX, deltaY, 0);
currButtonState = PIND & 0x01; // Care about D0 only
// button pressed
if (!currButtonState) {
usb_mouse_buttons(1, 0, 0);
} else { // released
usb_mouse_buttons(0, 0, 0);
}
}
}
previousX = currentX;
previousY = currentY;
}
int main() {
int port_num = 0;
printf("plz enter the COM Port number:\n");
scanf("%d",&port_num);
ComPort cp = newComPort(port_num);
void* context = zmq_ctx_new();
ZMQServer zmq_server = newZMQServer(context, "tcp://*:5555", ZMQ_REP);
ZMQServer zmq_publisher = newZMQServer(context, "tcp://*:5556", ZMQ_PUB);
char buf[BUFFER_SIZE];
int len;
while(1){
char port_cmd[32];
len = read(zmq_server, buf);
if (!strcmp("lights on", buf + 9)) {
write(cp, "\xAA", 1, buf);
} else if (!strcmp("lights off", buf + 9)) {
write(cp, "\xBB", 1, buf);
}
len = read(cp, buf);
phex(buf, len);
char light_ack[32];
if (!strncmp("\xAB\xCD", buf, 2)) {
memcpy(light_ack, buf + 2, 8);
memcpy(light_ack + 8, " lights on OK", 13);
printf("light_ack = %s\n", light_ack);
write(zmq_server, light_ack, 21);
} else if (!strncmp("\xCD\xEF", buf, 2)) {
memcpy(light_ack, buf + 2, 8);
memcpy(light_ack + 8, " lights off OK", 14);
printf("light_ack = %s\n", light_ack);
write(zmq_server, light_ack, 22);
} else if (!strncmp("\x00\x00", buf, 2)) {
memcpy(light_ack, buf + 2, 8);
memcpy(light_ack + 8, " lights error", 13);
printf("light_ack = %s\n", light_ack);
write(zmq_server, light_ack, 21);
} else {
write(zmq_publisher, (char*)buf, len);
}
}
}
uint8_t m0110_recv(void)
{
uint8_t data = 0;
m0110_error = 0;
WAIT_MS(clock_lo, 250, 1); // keyboard may block long time
for (uint8_t i = 0; i < 8; i++) {
data <<= 1;
WAIT_US(clock_lo, 200, 2);
WAIT_US(clock_hi, 200, 3);
if (data_in()) {
data |= 1;
}
}
idle();
return data;
ERROR:
print("m0110_recv err: "); phex(m0110_error); print("\n");
_delay_ms(500);
idle();
return 0xFF;
}
uint8_t matrix_scan(void)
{
uint8_t key;
is_modified = false;
key = m0110_recv_key();
#ifdef MATRIX_HAS_LOCKING_CAPS
// Send Caps key up event
if (matrix_is_on(ROW(CAPS), COL(CAPS))) {
is_modified = true;
register_key(CAPS_UP);
}
#endif
if (key == M0110_NULL) {
return 0;
} else {
#ifdef MATRIX_HAS_LOCKING_CAPS
if (host_keyboard_leds() & (1<<USB_LED_CAPS_LOCK)) {
// CAPS LOCK on:
// Ignore LockingCaps key down event
if (key == CAPS) return 0;
// Convert LockingCaps key up event into down event
if (key == CAPS_UP) key = CAPS;
} else {
// CAPS LOCK off:
// Ignore LockingCaps key up event
if (key == CAPS_UP) return 0;
}
#endif
is_modified = true;
register_key(key);
}
if (debug_enable) {
print("key: "); phex(key); print("\n");
}
return 1;
}
void matrix_print(void)
{
#if (MATRIX_COLS <= 8)
print("\nr/c 01234567\n");
#else
print("\nr/c 0123456789ABCDEF\n");
#endif
for (uint8_t row = 0; row < matrix_rows(); row++) {
phex(row); print(": ");
#if (MATRIX_COLS <= 8)
pbin_reverse(matrix_get_row(row));
#else
pbin_reverse16(matrix_get_row(row));
#endif
#ifdef MATRIX_HAS_GHOST
if (matrix_has_ghost_in_row(row)) {
print(" <ghost");
}
#endif
print("\n");
}
}
uint8_t m0110_send(uint8_t data)
{
m0110_error = 0;
request();
WAIT_MS(clock_lo, 250, 1); // keyboard may block long time
for (uint8_t bit = 0x80; bit; bit >>= 1) {
WAIT_US(clock_lo, 250, 3);
if (data&bit) {
data_hi();
} else {
data_lo();
}
WAIT_US(clock_hi, 200, 4);
}
_delay_us(100); // hold last bit for 80us
idle();
return 1;
ERROR:
print("m0110_send err: "); phex(m0110_error); print("\n");
_delay_ms(500);
idle();
return 0;
}
void TCPConnection::startInternal() {
beetle.readers.add(sockfd, [this] {
if (stopped) {
return;
}
uint8_t buf[256];
uint8_t len;
// read length of ATT message
int bytesRead = SSL_read(ssl, &len, sizeof(len));
if (bytesRead <= 0) {
if (debug_socket) {
std::stringstream ss;
ss << "socket errno: " << strerror(errno);
pdebug(ss.str());
}
stopInternal();
} else {
assert(bytesRead == 1);
if (debug_socket) {
pdebug("tcp expecting " + std::to_string(len) + " bytes");
}
time_t startTime = time(NULL);
struct timeval defaultTimeout;
defaultTimeout.tv_sec = 0;
defaultTimeout.tv_usec = 100000;
fd_set fdSet;
FD_ZERO(&fdSet);
FD_SET(sockfd, &fdSet);
// read payload ATT message
bytesRead = 0;
while (!stopped && bytesRead < len) {
if (difftime(time(NULL), startTime) > TIMEOUT_PAYLOAD) {
if (debug_socket) {
pdebug("timed out reading payload");
}
stopInternal();
break;
}
int result = SSL_pending(ssl);
if (result <= 0) {
struct timeval timeout = defaultTimeout;
fd_set readFds = fdSet;
fd_set exceptFds = fdSet;
result = select(sockfd + 1, &readFds, NULL, &exceptFds, &timeout);
if (result < 0) {
if (debug_socket) {
std::stringstream ss;
ss << "select failed : " << strerror(errno);
pdebug(ss.str());
}
stopInternal();
break;
}
}
if (result > 0) {
int n = SSL_read(ssl, buf + bytesRead, len - bytesRead);
if (n < 0) {
if (debug_socket) {
std::cerr << "socket errno: " << strerror(errno) << std::endl;
}
stopInternal();
break;
} else {
bytesRead += n;
}
}
}
if (bytesRead < len) {
return;
}
if (debug_socket) {
phex(buf, bytesRead);
pdebug("read " + std::to_string(bytesRead) + " bytes from " + getName());
}
readHandler(buf, bytesRead);
}
});
}
//Key Execute function
//Decodes a keycode, and executes depending on codetype
void key_execute(keycode aKey, uint8_t down)
{
print("inside key_execute\n");
phex(aKey.type);
print("<-Type:Code->");
phex(aKey.code);
print("\n");
switch(aKey.type)
{
case TYPE_KEY:
//Check for type, and call functions
if(down)
add_key(aKey.code);
else
del_key(aKey.code);
break;
case TYPE_MOD:
//Check for type, and call functions
if(down)
add_mod(aKey.code);
else
del_mod(aKey.code);
break;
case TYPE_MEDIA:
case TYPE_MOUSE:
//Placeholder if mouse and media keys implemented
break;
case TYPE_MOMENTARY:
//For mementary layer changes
clear_keyboard(); //Clear all current plessed keys, because they may not exist in new layer
if(down)
set_current_layer(aKey.code);
else
set_current_layer(0); //Return to default layer
break;
case TYPE_TOGGLE:
//For toggleing layer changes
if(down && (aKey.code ^ get_current_layer()) )
{
clear_keyboard();
set_current_layer(aKey.code);
}
break;
case TYPE_MISC:
//Miscelaneous functions need special treatment
switch(aKey.code)
{
case CODE_JMP_BOOT:
//Jump to boot loader
if(down) //Only want to activate on key-down
{
jump_bootloader();
}
break;
case CODE_BR_UP:
//Raise brightness of LEDS
//In steps of 24
if(down) //Only want to activate on key-down
{
if(OCR4D < 0xF0) OCR4D += 0x20;
}
break;
case CODE_BR_DOWN:
//Lower brightness of LEDS
//In steps of 24
if(down) //Only want to activate on key-down
{
if(OCR4D > 0x10) OCR4D -= 0x20;
}
break;
}
break;
default:
//Default case: Unknown Keytype
//Print error and do nothing
print("Unknown Key Type: ");
phex(aKey.type);
pchar('\n');
}
}
