void set_float(void *buffer, double value)
{
int expr,
sign;
unsigned char *buf = buffer;
unsigned long frac;
double r;
/* Take absolute */
if (value < 0) {
sign = 0;
value = -value;
} else
sign = 0xFF;
/* Convert mantissa to 32-bit integer, and take exponent */
r = ldexp(frexp(value, &expr), 32);
frac = (unsigned long)r;
expr -= 32;
/* Store values in buffer */
set_long(buf, frac);
set_sshort(buf + 4, expr);
set_byte(buf + 6, sign);
set_byte(buf + 7, 0);
}
void restart_screen( void )
{
zbyte_t high = 1, low = 0;
set_byte( H_STANDARD_HIGH, high );
set_byte( H_STANDARD_LOW, low );
if ( h_type < V4 )
set_byte( H_CONFIG, ( get_byte( H_CONFIG ) | CONFIG_NOSTATUSLINE ) );
/* Force graphics off as we can't do them */
set_word( H_FLAGS, ( get_word( H_FLAGS ) & ( ~GRAPHICS_FLAG ) ) );
} /* restart_screen */
/***********************************************************************
*
* Function: pack_MailSyncPref
*
* Summary: packs Mail
*
* Parameters: MailSyncPref_t*, char* to buffer, buffer length
*
* Returns: effective buffer length
*
***********************************************************************/
int
pack_MailSyncPref(MailSyncPref_t *pref, unsigned char *record, size_t len)
{
size_t destlen = 6 + 1 + 1 + 1;
unsigned char *start = record;
if (pref->filterTo)
destlen += strlen(pref->filterTo);
if (pref->filterSubject)
destlen += strlen(pref->filterSubject);
if (pref->filterFrom)
destlen += strlen(pref->filterFrom);
if (!record)
return destlen;
if (len < destlen)
return 0;
set_byte(record, pref->syncType);
record++;
set_byte(record, pref->getHigh);
record++;
set_byte(record, pref->getContaining);
record++;
set_byte(record, 0);
record++; /* gapfill */
set_short(record, pref->truncate);
record += 2;
if (pref->filterTo) {
strcpy((char *)record, pref->filterTo);
record += strlen(pref->filterTo);
}
*record++ = 0;
if (pref->filterFrom) {
strcpy((char *)record, pref->filterFrom);
record += strlen(pref->filterFrom);
}
*record++ = 0;
if (pref->filterSubject) {
strcpy((char *)record, pref->filterSubject);
record += strlen(pref->filterSubject);
}
*record++ = 0;
return (record - start);
}
void mcMarchingSquares_computeCanonicalSquareTable(
int *list,
int *table,
int *sequenceTable)
{
unsigned int listIndex;
/* Initialize all tables */
memset(table, -1, sizeof(int) * 16);
memset(sequenceTable, -1, sizeof(int) * 16);
listIndex = 0;
/* Iterate over all possible square configurations */
for (int square = 0; square <= 0xf; ++square) {
int canonical = -1;
/* Loop to invert the square */
int inverted = square;
for (int i = 0; i < 2; ++i) {
int sequence;
/* Set the inversion byte */
sequence = set_byte(0, 1, i);
int rotated = inverted;
/* Loop to rotate the square */
for (int j = 0; j < 4; ++j) {
/* TODO: Check for canonical square? */
if (table[rotated] != -1) {
if (canonical == -1) {
/* We found the canonical orientation for this square */
canonical = table[rotated];
table[square] = canonical;
} else {
assert(table[rotated] == canonical);
}
}
if (rotated == canonical) {
/* We found the rotation sequence that brings this square into the
* canonical orientation */
/* Store the rotation sequence and inversion flag */
sequenceTable[square] = sequence;
}
/* Rotate the square */
rotated = mcSquare_rotateSquare(rotated);
/* Update the rotation byte */
sequence = incr_byte(sequence, 0);
}
/* Invert the square */
inverted = mcSquare_invertSquare(inverted);
}
if (canonical == -1) {
/* We could not find the current square configuration in the table, so
* this square configuration defines a canonical square */
canonical = square;
list[listIndex++] = canonical;
table[square] = canonical;
sequenceTable[square] = 0;
}
}
assert(listIndex == MC_MARCHING_SQUARES_NUM_CANONICAL_SQUARES);
}
//done
static void movii(cpu *pcpu) {
if (set_byte(pcpu)<0) {
pcpu->fl = CPU_ERROR;
//printf("byte %x\n",get_byte(pcpu->bx));
}
pcpu->ip++;
}
void send_byte(unsigned char in)
{
// Note: data is latched on falling edge of pin E
//LATC = nibble;
set_byte(in);
E_PIN = 1;
E_PIN = 0;
delay_us(40);
}
/***********************************************************************
*
* Function: pack_Address
*
* Summary: Fill in the raw address record data based on the
* address structure
*
* Parameters: Address_t*, pi_buffer_t *buf of record, record type
*
* Returns: -1 on error, 0 on success.
*
***********************************************************************/
int
pack_Address(const Address_t *addr, pi_buffer_t *buf, addressType type)
{
unsigned int l,
destlen = 9;
unsigned char *buffer;
unsigned long contents,
v,
phoneflag;
unsigned char offset;
if (addr == NULL || buf == NULL)
return -1;
if (type != address_v1)
/* Don't support anything else yet */
return -1;
for (v = 0; v < 19; v++)
if (addr->entry[v] && strlen(addr->entry[v]))
destlen += strlen(addr->entry[v]) + 1;
pi_buffer_expect (buf, destlen);
buf->used = destlen;
buffer = buf->data + 9;
phoneflag = 0;
contents = 0;
offset = 0;
for (v = 0; v < 19; v++) {
if (addr->entry[v] && strlen(addr->entry[v])) {
if (v == entryCompany)
offset =
(unsigned char) (buffer - buf->data) - 8;
contents |= (1 << v);
l = strlen(addr->entry[v]) + 1;
memcpy(buffer, addr->entry[v], l);
buffer += l;
}
}
phoneflag = ((unsigned long) addr->phoneLabel[0]) << 0;
phoneflag |= ((unsigned long) addr->phoneLabel[1]) << 4;
phoneflag |= ((unsigned long) addr->phoneLabel[2]) << 8;
phoneflag |= ((unsigned long) addr->phoneLabel[3]) << 12;
phoneflag |= ((unsigned long) addr->phoneLabel[4]) << 16;
phoneflag |= ((unsigned long) addr->showPhone) << 20;
set_long(buf->data, phoneflag);
set_long(buf->data + 4, contents);
set_byte(buf->data + 8, offset);
return 0;
}
void send_command_byte(unsigned char byte)
{
RS_PIN = 0;
set_byte(byte);
delay_ms(2);
E_PIN = 1;
delay_ms(3);
E_PIN = 0;
delay_ms(2); // Enough time even for slowest command
}
int handle_input(struct plyr *p){
int z;
z = read_byte(p->fd);
if(z == -1){
return 1;
}
if(z == 0 || z == 1) return 0;
p->lastinput = time(NULL);
printf("user input: @ (%d,%d) = %d\n",p->x,p->y,z);
if(z == 0x1b){
handle_escapes(p);
}
else if(z == 253U)
{
read_byte(p->fd); //3
}
else if(z == 255U){
read_byte(p->fd); //1
dump_world(p);
} else if(z == 126 || z == 127)
{
move_left(p);
set_byte(p, ' ');
CHARAT(p,p->x,p->y) = ' ';
}
else if(z == 13)
{
move_down(p);
} else if(z == 10){
} else {
set_byte(p, z);
move_right(p);
}
return 0;
}
/***********************************************************************
*
* Function: pack_MailAppInfo
*
* Summary: packs MailAppInfo
*
* Parameters: MailAppInfo_t*, char* to buffer, buffer length
*
* Returns: effective buffer length
*
***********************************************************************/
int
pack_MailAppInfo(struct MailAppInfo *appinfo, unsigned char *record, size_t len)
{
int i;
unsigned char *start = record;
i = pack_CategoryAppInfo(&appinfo->category, record, len);
if (!record)
return i + 11;
if (!i)
return i;
record += i;
len -= i;
if (len < 8)
return 0;
set_short(record, appinfo->dirty);
record += 2;
set_short(record, 0); /* gapfill */
set_byte(record, appinfo->sortOrder);
record += 2;
set_long(record, appinfo->unsentMessage);
record += 4;
set_short(record, (record - start + 2));
record += 2;
/* if (appinfo->signature)
strcpy(record, appinfo->signature);
else
set_byte(record, 0);
record += strlen(record); */
set_byte(record, 0);
record++;
return (record - start);
}
//*****************************************************************************
//
// This function restarts the screen.
//
//*****************************************************************************
void
restart_screen(void)
{
//
// Set the current column to the beginning of the line.
//
g_lCurColumn = 1;
//
// Discard any saved cursor column.
//
g_lCursorSaved = 0;
//
// Characters should be displayed.
//
g_lDisplay = 1;
//
// The the ZIP configuration flags based on the type of the game.
//
if(h_type < V4)
{
set_byte(H_CONFIG, get_byte(H_CONFIG) | CONFIG_WINDOWS);
}
else
{
set_byte(H_CONFIG,
get_byte(H_CONFIG) | CONFIG_EMPHASIS | CONFIG_WINDOWS);
}
//
// Set the ZIP flags.
//
set_word(H_FLAGS, (get_word(H_FLAGS) & ~GRAPHICS_FLAG));
}
/***********************************************************************
*
* Function: pack_AddressAppInfo
*
* Summary: Fill in the raw app info record data based on the app
* info structure
*
* Parameters: AddressAppInfo_t*, char * to record, record length
*
* Returns: The length of the buffer required if record is NULL,
* or 0 on error, the length of the data used from the
* buffer otherwise
*
***********************************************************************/
int
pack_AddressAppInfo(const AddressAppInfo_t *ai, unsigned char *record, size_t len)
{
int i;
size_t destlen = 4 + 16 * 22 + 2 + 2;
unsigned char *pos = record;
unsigned long r;
i = pack_CategoryAppInfo(&ai->category, record, len);
if (!record)
return destlen + i;
if (!i)
return i;
pos += i;
len -= i;
for (i = 3; i < 8; i++)
strcpy(ai->phoneLabels[i - 3], ai->labels[i]);
for (i = 19; i < 22; i++)
strcpy(ai->phoneLabels[i - 19 + 5], ai->labels[i]);
memset(pos, 0, destlen);
r = 0;
for (i = 0; i < 22; i++)
if (ai->labelRenamed[i])
r |= (1 << i);
set_long(pos, r);
pos += 4;
memcpy(pos, ai->labels, 16 * 22);
pos += 16 * 22;
set_short(pos, ai->country);
pos += 2;
set_byte(pos, ai->sortByCompany);
pos += 2;
for (i = 3; i < 8; i++)
strcpy(ai->phoneLabels[i - 3], ai->labels[i]);
for (i = 19; i < 22; i++)
strcpy(ai->phoneLabels[i - 19 + 5], ai->labels[i]);
return (pos - record);
}
static duk_ret_t
js_ByteArray_setProp(duk_context* ctx)
{
bytearray_t* array;
int index;
int size;
duk_get_prop_string(ctx, 0, "\xFF" "ptr"); array = duk_get_pointer(ctx, -1); duk_pop(ctx);
if (duk_is_number(ctx, 1)) {
index = duk_to_int(ctx, 1);
size = get_bytearray_size(array);
if (index < 0 || index >= size)
duk_error_ni(ctx, -1, DUK_ERR_RANGE_ERROR, "ByteArray[]: Index is out of bounds (%i - size: %i)", index, size);
set_byte(array, index, duk_require_uint(ctx, 2));
return 0;
}
else {
duk_dup(ctx, 1);
duk_dup(ctx, 2);
duk_put_prop(ctx, 0);
return 0;
}
}
int shell_smem(char **args)
{
if (!args[2]) return MISSING_ARGS;
// activation du masque pour ne pas quitter lors d'un check d'adresse
switch_exitMask();
uint32_t value = get_value_from_string(args[2]);
uint32_t nbOctets = (args[3]) ? get_value_from_string(args[3]) : 1;
switch (nbOctets) {
case 1:
if (is_byte(value)) {
set_byte(get_value_from_string(args[1]), value);
} else {
fprintf(stderr, "La valeur est trop grande pour rentrer sur un octet\n");
}
break;
case 2:
if (is_half_word(value)) {
set_half_word(get_value_from_string(args[1]), value);
} else {
fprintf(stderr, "La valeur est trop grande pour rentrer sur un demi-mot\n");
}
break;
case 4:
set_word(get_value_from_string(args[1]), value);
break;
default:
fprintf(stderr, "Le nombre d'octets à écrire est soit 1, 2 ou 4\n");
}
// on desactive le masque, les checks d'addresse sont termines
switch_exitMask();
return OK;
}
/***********************************************************************
*
* Function: pack_Mail
*
* Summary: packs Mail
*
* Parameters: Mail_t*, char* to buffer, buffer length
*
* Returns: effective buffer length
*
***********************************************************************/
int
pack_Mail(struct Mail *mail, unsigned char *buffer, size_t len)
{
size_t destlen = 6 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
unsigned char *start = buffer;
if (mail->subject)
destlen += strlen(mail->subject);
if (mail->from)
destlen += strlen(mail->from);
if (mail->to)
destlen += strlen(mail->to);
if (mail->cc)
destlen += strlen(mail->cc);
if (mail->bcc)
destlen += strlen(mail->bcc);
if (mail->replyTo)
destlen += strlen(mail->replyTo);
if (mail->sentTo)
destlen += strlen(mail->sentTo);
if (mail->body)
destlen += strlen(mail->body);
if (!buffer)
return destlen;
if (len < destlen)
return 0;
set_short(buffer,
((mail->date.tm_year - 4) << 9) | ((mail->date.tm_mon +
1) << 5) | mail->date.
tm_mday);
set_byte(buffer + 2, mail->date.tm_hour);
set_byte(buffer + 3, mail->date.tm_min);
if (!mail->dated)
set_long(buffer, 0);
set_byte(buffer + 4, (mail->read ? (1 << 7) : 0) |
(mail->signature ? (1 << 6) : 0) | (mail->
confirmRead ? (1 << 5) :
0) | (mail->
confirmDelivery
? (1 << 4) : 0) |
((mail->priority & 3) << 2) | (mail->addressing & 3));
set_byte(buffer + 5, 0);
buffer += 6;
if (mail->subject) {
strcpy((char *)buffer, mail->subject);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->from) {
strcpy((char *)buffer, mail->from);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->to) {
strcpy((char *)buffer, mail->to);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->cc) {
strcpy((char *)buffer, mail->cc);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->bcc) {
strcpy((char *)buffer, mail->bcc);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->replyTo) {
strcpy((char *)buffer, mail->replyTo);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->sentTo) {
strcpy((char *)buffer, mail->sentTo);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
if (mail->body) {
strcpy((char *)buffer, mail->body);
buffer += strlen((char *)buffer);
} else
set_byte(buffer, 0);
buffer++;
return (buffer - start);
}
JNIEXPORT void JNICALL Java_com_jtxdriggers_android_ventriloid_VentriloInterface_getevent(JNIEnv* env, jobject obj, jobject eventdata) {
v3_event *ev = v3_get_event(V3_BLOCK);
if(ev != NULL) {
jclass event_class = get_class(env, eventdata);
set_short(env, eventdata, event_class, "type", ev->type);
switch(ev->type) {
case V3_EVENT_PLAY_AUDIO:
{
// PCM data.
jobject pcm = get_object(env, eventdata, event_class, "pcm", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_pcm;");
jclass pcm_class = get_class(env, pcm);
set_int (env, pcm, pcm_class, "length", ev->pcm.length);
set_int (env, pcm, pcm_class, "rate", ev->pcm.rate);
set_short(env, pcm, pcm_class, "send_type", ev->pcm.send_type);
set_byte (env, pcm, pcm_class, "channels", ev->pcm.channels);
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "id", ev->user.id);
// Sample.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
set_pcm_byte_array(env, data, data_class, "sample", ev->data->sample, ev->pcm.length);
}
break;
case V3_EVENT_PING:
{
// Ping.
set_int(env, eventdata, event_class, "ping", ev->ping);
}
break;
case V3_EVENT_USER_TALK_END:
case V3_EVENT_USER_TALK_MUTE:
case V3_EVENT_CHAT_JOIN:
case V3_EVENT_CHAT_LEAVE:
case V3_EVENT_USER_GLOBAL_MUTE_CHANGED:
case V3_EVENT_USER_CHANNEL_MUTE_CHANGED:
case V3_EVENT_USER_RANK_CHANGE:
{
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "id", ev->user.id);
}
break;
case V3_EVENT_USER_CHAN_MOVE:
case V3_EVENT_USER_LOGOUT:
case V3_EVENT_CHAN_REMOVE:
{
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "id", ev->user.id);
// Channel ID.
jobject channel = get_object(env, eventdata, event_class, "channel", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_channel;");
jclass channel_class = get_class(env, channel);
set_short(env, channel, channel_class, "id", ev->channel.id);
}
break;
case V3_EVENT_USER_MODIFY:
case V3_EVENT_USER_LOGIN:
{
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "id", ev->user.id);
// Channel ID.
jobject channel = get_object(env, eventdata, event_class, "channel", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_channel;");
jclass channel_class = get_class(env, channel);
set_short(env, channel, channel_class, "id", ev->channel.id);
// Flags.
set_int(env, eventdata, event_class, "flags", ev->flags);
}
break;
case V3_EVENT_STATUS:
{
// Status message & percentage.
jobject status = get_object(env, eventdata, event_class, "status", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_status;");
jclass status_class = get_class(env, status);
set_byte(env, status, status_class, "percent", ev->status.percent);
set_byte_array(env, status, status_class, "message", ev->status.message);
}
break;
case V3_EVENT_LOGIN_COMPLETE:
case V3_EVENT_LOGIN_FAIL:
case V3_EVENT_DISCONNECT:
case V3_EVENT_ADMIN_AUTH:
case V3_EVENT_CHAN_ADMIN_UPDATED:
case V3_EVENT_PERMS_UPDATED:
{
// No event data for these types!
}
break;
case V3_EVENT_PRIVATE_CHAT_START:
case V3_EVENT_PRIVATE_CHAT_END:
case V3_EVENT_PRIVATE_CHAT_AWAY:
case V3_EVENT_PRIVATE_CHAT_BACK:
{
// User IDs.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "privchat_user1", ev->user.privchat_user1);
set_short(env, user, user_class, "privchat_user2", ev->user.privchat_user2);
}
case V3_EVENT_PRIVATE_CHAT_MESSAGE:
{
// User IDs.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "privchat_user1", ev->user.privchat_user1);
set_short(env, user, user_class, "privchat_user2", ev->user.privchat_user2);
// Chat message.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
set_byte_array(env, data, data_class, "chatmessage", ev->data->chatmessage);
// Flags.
set_int(env, eventdata, event_class, "flags", ev->flags);
}
break;
case V3_EVENT_USERLIST_ADD:
case V3_EVENT_USERLIST_MODIFY:
{
// Account fields.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
jobject account = get_object(env, data, data_class, "account", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data$_account;");
jclass account_class = get_class(env, account);
set_byte_array(env, account, account_class, "username", ev->data->account.username);
}
break;
case V3_EVENT_CHAN_ADD:
case V3_EVENT_CHAN_MODIFY:
{
// Channel id.
jobject channel = get_object(env, eventdata, event_class, "channel", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_channel;");
jclass channel_class = get_class(env, channel);
set_short(env, channel, channel_class, "id", ev->channel.id);
}
break;
case V3_EVENT_DISPLAY_MOTD:
{
/* don't deal with any MOTD events here because they're useless
// MOTD.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
set_byte_array(env, data, data_class, "motd", ev->data->motd);
// Flags.
set_int(env, eventdata, event_class, "flags", ev->flags);
*/
}
break;
case V3_EVENT_CHAN_BADPASS:
{
// Channel ID.
jobject channel = get_object(env, eventdata, event_class, "channel", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_channel;");
jclass channel_class = get_class(env, channel);
set_short(env, channel, channel_class, "id", ev->channel.id);
// Error message.
jobject error = get_object(env, eventdata, event_class, "error", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_error;");
jclass error_class = get_class(env, error);
set_byte_array(env, error, error_class, "message", ev->error.message);
}
break;
case V3_EVENT_ERROR_MSG:
{
// Error message & disconnect flag.
jobject error = get_object(env, eventdata, event_class, "error", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_error;");
jclass error_class = get_class(env, error);
set_byte_array(env, error, error_class, "message", ev->error.message);
set_bool(env, error, error_class, "disconnected", ev->error.disconnected != 0);
}
break;
case V3_EVENT_USER_TALK_START:
{
// PCM data.
jobject pcm = get_object(env, eventdata, event_class, "pcm", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_pcm;");
jclass pcm_class = get_class(env, pcm);
set_int (env, pcm, pcm_class, "rate", ev->pcm.rate);
set_short(env, pcm, pcm_class, "send_type", ev->pcm.send_type);
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "id", ev->user.id);
}
break;
case V3_EVENT_CHAT_MESSAGE:
{
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user,user_class, "id", ev->user.id);
// Chat message.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
set_byte_array(env, data, data_class, "chatmessage", ev->data->chatmessage);
}
break;
case V3_EVENT_USERLIST_REMOVE:
{
// Account ID.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
jobject account = get_object(env, data, data_class, "account", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data$_account;");
jclass account_class = get_class(env, account);
set_short(env, account, account_class, "id", ev->account.id);
}
break;
case V3_EVENT_USERLIST_CHANGE_OWNER:
{
// Account IDs.
jobject data = get_object(env, eventdata, event_class, "data", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data;");
jclass data_class = get_class(env, data);
jobject account = get_object(env, data, data_class, "account", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_data$_account;");
jclass account_class = get_class(env, account);
set_short(env, account, account_class, "id", ev->account.id);
set_short(env, account, account_class, "id2", ev->account.id2);
}
break;
case V3_EVENT_USER_PAGE:
{
// User ID.
jobject user = get_object(env, eventdata, event_class, "user", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_user;");
jclass user_class = get_class(env, user);
set_short(env, user, user_class, "id", ev->user.id);
}
break;
case V3_EVENT_SERVER_PROPERTY_UPDATED:
{
jobject srvprop = get_object(env, eventdata, event_class, "serverproperty", "Lcom/jtxdriggers/android/ventriloid/VentriloEventData$_serverproperty;");
jclass srvprop_class = get_class(env, srvprop);
set_short(env, srvprop, srvprop_class, "property", ev->serverproperty.property);
set_byte(env, srvprop, srvprop_class, "value", ev->serverproperty.value);
}
break;
}
v3_free_event(ev);
}
}
std::char_traits<char>::int_type Base64Stream::overflow(std::char_traits<char>::int_type c)
{
char *ibegin = &data_buf_[0];
char *iend = pptr();
if (!std::char_traits<char>::eq_int_type(c, std::char_traits<char>::eof()))
{
*iend++ = std::char_traits<char>::to_char_type(c);
}
// mark the buffer as free
setp(&data_buf_[0], &data_buf_[0] + data_size_ - 1);
// available data
size_t len = (iend - ibegin);
// if there is nothing to send, just return
if (len == 0)
{
return std::char_traits<char>::not_eof(c);
}
// for each byte...
for (size_t i = 0; i < len; ++i)
{
// do cipher stuff
if (_decode)
{
const int c = Base64::getCharType( ibegin[i] );
switch (c)
{
case Base64::UNKOWN_CHAR:
// skip unknown chars
continue;
case Base64::EQUAL_CHAR:
{
switch (_base64_state)
{
case 0:
// error - first character can not be a '='
return std::char_traits<char>::eof();
case 1:
// error - second character can not be a '='
return std::char_traits<char>::eof();
case 2:
// only one byte left
_base64_padding = 2;
break;
case 3:
// only one byte left
if (_base64_padding == 0)
{
_base64_padding = 3;
}
break;
}
set_b64(0);
break;
}
default:
{
// put char into the decode buffer
set_b64(static_cast<char>(c));
break;
}
}
// when finished
if (_base64_state == 4)
{
if (_base64_padding == 0)
{
_stream.put( _group.get_0() );
_stream.put( _group.get_1() );
_stream.put( _group.get_2() );
}
else if (_base64_padding == 3)
{
_stream.put( _group.get_0() );
_stream.put( _group.get_1() );
}
else if (_base64_padding == 2)
{
_stream.put( _group.get_0() );
}
_base64_state = 0;
_base64_padding = 0;
_group.zero();
}
}
else
{
// put char into the encode buffer
set_byte(ibegin[i]);
if (_base64_state == 3)
{
__flush_encoder__();
_group.zero();
}
}
}
return std::char_traits<char>::not_eof(c);
}
static void *worker(void *blks) {
// State variables
uint64_t lowesthash[8];
pthread_mutex_lock(&mutex);
memcpy(lowesthash, global_lowest_hash, sizeof(lowesthash));
pthread_mutex_unlock(&mutex);
uint8_t (*blocks)[NUM_CH][8] = (uint8_t (*)[NUM_CH][8])blks;
for (long i = 0; ; i++) {
// Accumulate status
if (i >= iters_per_accumulate) {
pthread_mutex_lock(&mutex);
total_iterations += i;
pthread_mutex_unlock(&mutex);
i = 0;
}
// Do hashing
uint64_t hashes[8][NUM_CH];
memcpy(hashes, INITIAL_STATES, sizeof(hashes));
sha512_compress_dual(hashes, blocks);
// Compare with lowest hash
if (hashes[0][0] <= lowesthash[0] || hashes[0][1] <= lowesthash[0]) { // Assumes NUM_CH = 2
pthread_mutex_lock(&mutex);
for (int ch = 0; ch < NUM_CH; ch++) {
if (compare_hashes(hashes, ch, global_lowest_hash) < 0) {
char message[MSG_LEN + 1];
get_message(blocks, ch, message);
fprintf(stdout, "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 "%016" PRIx64 " %s\n",
hashes[0][ch], hashes[1][ch], hashes[2][ch], hashes[3][ch], hashes[4][ch], hashes[5][ch], hashes[6][ch], hashes[7][ch], message);
if (prev_print_type == 1)
fprintf(stderr, " ");
fprintf(stderr, "%016" PRIx64 "%016" PRIx64 "... %s\n", hashes[0][ch], hashes[1][ch], message);
fflush(stdout);
fflush(stderr);
for (int j = 0; j < 8; j++)
global_lowest_hash[j] = hashes[j][ch];
prev_print_type = 0;
}
}
for (int j = 0; j < 8; j++)
lowesthash[j] = global_lowest_hash[j];
pthread_mutex_unlock(&mutex);
}
// Increment messages
int j;
for (j = MSG_LEN - 1; j >= 0 && get_byte(blocks, j, 0) >= 'z'; j--) {
for (int ch = 0; ch < NUM_CH; ch++)
set_byte(blocks, j, ch, 'a');
}
if (j < 0)
break;
for (int ch = 0; ch < NUM_CH; ch++)
set_byte(blocks, j, ch, get_byte(blocks, j, ch) + 1);
}
pthread_mutex_lock(&mutex);
finished_threads++;
pthread_mutex_unlock(&mutex);
return NULL;
}
/**
* Routine to display menu. Since we use 2 rows LCD, the scroll up/down
* menu is by checking the switch state. Since the switch is active low,
* the logic to check is reversed, e.g., when checking if switch OK is
* pressed:
*
* ~~~
* if (!sw_ok)
* ~~~
*/
void show_menu_in_lcd() {
lcd_clear();
menu01:
delay_ms(125); // Prevents switch bouncing
lcd_gotoxy(0,0);
lcd_putsf(" Set PID ");
lcd_gotoxy(0,1);
lcd_putsf(" Set Speed ");
lcd_gotoxy(0,0); // Cursor in first row
lcd_putchar(0);
if (!sw_ok) {
lcd_clear();
pid_cursor = 1;
goto set_PID;
}
if (!sw_down) {
goto menu02;
}
if (!sw_up) {
lcd_clear();
goto menu05;
}
goto menu01;
menu02:
delay_ms(125);
lcd_gotoxy(0,0);
lcd_putsf(" Set PID ");
lcd_gotoxy(0,1);
lcd_putsf(" Set Speed ");
lcd_gotoxy(0,1); // Cursor in 2nd row
lcd_putchar(0);
if (!sw_ok) {
lcd_clear();
speed_cursor = 1;
goto set_speed;
}
if (!sw_up) {
goto menu01;
}
if (!sw_down) {
lcd_clear();
goto menu03;
}
goto menu02;
menu03:
delay_ms(125);
lcd_gotoxy(0,0);
lcd_putsf(" Start!! ");
lcd_gotoxy(0,0); // Cursor in first row
lcd_putchar(0);
if (!sw_ok) {
lcd_clear();
goto start_robot;
}
if (!sw_up) {
lcd_clear();
goto menu02;
}
if (!sw_down) {
lcd_clear();
goto menu01;
}
goto menu03;
set_PID:
delay_ms(150);
lcd_gotoxy(0,0);
lcd_putsf(" Kp Ki Kd ");
lcd_putchar(' ');
lcd_please_display(Kp); lcd_putchar(' '); lcd_putchar(' ');
lcd_please_display(Ki); lcd_putchar(' '); lcd_putchar(' ');
lcd_please_display(Kd); lcd_putchar(' '); lcd_putchar(' ');
switch (pid_cursor) {
case 1:
lcd_gotoxy(1,0); // Kp cursor
lcd_putchar(0);
break;
case 2:
lcd_gotoxy(6,0); // Ki cursor
lcd_putchar(0);
break;
case 3:
lcd_gotoxy(11,0); // Kd cursor
lcd_putchar(0);
break;
}
if (!sw_ok) {
set_byte( 1, pid_cursor);
delay_ms(200);
}
if (!sw_up) {
if (pid_cursor == 3) {
pid_cursor = 1;
} else {
pid_cursor++;
}
}
if (!sw_down) {
if (pid_cursor == 1) {
pid_cursor = 3;
} else {
pid_cursor--;
}
}
if (!sw_cancel) {
lcd_clear();
goto menu01;
}
goto set_PID;
set_speed:
delay_ms(150);
lcd_gotoxy(0,0);
lcd_putsf(" MAX MIN ");
lcd_putchar(' ');lcd_putchar(' ');lcd_putchar(' ');
lcd_please_display(max_speed);
lcd_putchar(' '); lcd_putchar(' ');lcd_putchar(' '); lcd_putchar(' ');
lcd_please_display(min_speed);
lcd_putchar(' ');lcd_putchar(' ');lcd_putchar(' ');
switch (speed_cursor) {
case 1:
lcd_gotoxy(2,0); // kursor MAX
lcd_putchar(0);
break;
case 2:
lcd_gotoxy(9,0); // kursor MIN
lcd_putchar(0);
break;
}
if (!sw_ok) {
set_byte( 2, speed_cursor);
delay_ms(200);
}
if (!sw_up) {
if (speed_cursor == 2) {
speed_cursor = 1;
} else {
speed_cursor++;
}
}
if (!sw_down) {
if (speed_cursor == 1) {
speed_cursor = 2;
} else {
speed_cursor--;
}
}
if (!sw_cancel) {
lcd_clear();
goto menu02;
}
goto set_speed;
start_robot:
lcd_clear();
}
int main(void) {
// Sanity test
if (!self_check()) {
fprintf(stderr, "Self-check failed\n");
return EXIT_FAILURE;
}
benchmark();
// Set up the SHA-512 processed blocks: Message (28 bytes), terminator and padding (96 bytes), length (16 bytes)
uint8_t (*blocks)[16][NUM_CH][8] = calloc(num_threads * 16 * NUM_CH * 8, sizeof(uint8_t));
if (blocks == NULL) {
perror("calloc");
return EXIT_FAILURE;
}
{
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
uint64_t time = ts.tv_sec * UINT64_C(1000000000) + ts.tv_nsec;
for (int i = 0; i < num_threads; i++) {
for (int ch = 0; ch < NUM_CH; ch++) {
uint8_t (*blks)[NUM_CH][8] = blocks[i];
uint64_t temp = time + i * NUM_CH + ch;
for (int j = 0; j < MSG_LEN / 2; j++, temp /= 26)
set_byte(blks, j, ch, 'a' + temp % 26);
for (int j = 0; j < MSG_LEN / 2; j++)
set_byte(blks, j + MSG_LEN / 2, ch, 'a');
set_byte(blks, MSG_LEN, ch, 0x80);
set_byte(blks, 126, ch, MSG_LEN >> 5);
set_byte(blks, 127, ch, MSG_LEN << 3);
}
}
}
// Initialize initial lowest hash
memset(global_lowest_hash, 0xFF, sizeof(global_lowest_hash));
global_lowest_hash[0] >>= 24; // Exclude trivial matches
// Launch threads
pthread_t *threads = calloc(num_threads, sizeof(pthread_t));
if (threads == NULL) {
perror("calloc");
return EXIT_FAILURE;
}
for (int i = 0; i < num_threads; i++)
pthread_create(&threads[i], NULL, worker, blocks[i]);
// Print status until threads finish
while (true) {
pthread_mutex_lock(&mutex);
if (finished_threads >= num_threads) {
pthread_mutex_unlock(&mutex);
break;
}
char message[MSG_LEN + 1];
get_message(blocks[0], 0, message); // Only print thread 0, channel 0
fprintf(stderr, "\rHash trials: %.3f billion (%s)", total_iterations * NUM_CH / 1.0e9, message);
fflush(stderr);
prev_print_type = 1;
pthread_mutex_unlock(&mutex);
sleep(10);
}
fprintf(stderr, "\nSearch space exhausted\n");
// Clean up
for (int i = 0; i < num_threads; i++)
pthread_join(threads[i], NULL);
free(blocks);
free(threads);
return EXIT_SUCCESS;
}
