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; }