static void main_menu() { while (true) { print_header(); console_puts("It will attempt to completley destory ALL DATA on SELECTED ATA DISKS.\n\n"); console_puts("The following devices have been detected:\n"); uint8_t devices = 0; for (uint8_t i = 0; i < 4; i++) { if (ide_device_is_present(i) && ide_device_get_type(i) == 0) { console_putsf(" - ATA Device %u (%s) %7uMB - %s\n", i, ide_device_is_dma_capable(i) ? "DMA" : "PIO", ide_device_get_size(i) / 1024 / 2, ide_device_get_string(i, IDE_STRING_MODEL)); devices++; } } if (devices == 0) { console_color(0x0C); console_puts("\nNo devices have been detected. You cannot run this tool.\n"); console_color(0x07); } for (uint8_t i = 0; i < 12 - devices + 1 - (devices ? 0 : 2); i++) console_puts("\n"); console_puts("Press \"i\" to view technical information.\n"); if (devices == 0) { console_puts("You may turn the computer off."); } else { console_puts("Press \"ENTER\" to continue."); } char c = get_key(); switch (c) { case 'i': print_tech_info(); break; case '\n': if(devices) run_tool(devices); break; } } }
bool longcb(puppeteer_msgs::long_command::Request &req, puppeteer_msgs::long_command::Response &res) { // Create a new variable to publish: geometry_msgs::PointStamped cmd; if(exit_flag == false) { ROS_DEBUG("Sending Received Data"); unsigned char dataPtr[128]; MakeLongString(dataPtr, req.type, req.num1, req.num2, req.num3, req.num4, req.num5, req.div); sendData(req.robot_index, dataPtr, LONG_PACKET_SIZE); // If data sent with no errors, we set the response to an // affirmitive value. res.error = false; ROS_DEBUG("Send Complete"); int tmp = get_key(req.robot_index); cmd.header.frame_id = req.type; cmd.header.stamp = ros::Time::now(); cmd.point.x = req.num1; cmd.point.y = req.num2; cmd.point.z = req.num3; pub[tmp-1].publish(cmd); cmd.point.x = req.num4; cmd.point.y = req.num5; cmd.point.z = 0.0; if (tmp != 0) pub[tmp-1].publish(cmd); } else { ROS_DEBUG("Send Request Denied"); res.error = true; } return true; }
int get_auth_level(){ char *IP, *URL, *id, *id_ori, *key, *salt; int level; salt = calloc(128, 1); IP = getenv("REMOTE_ADDR"); if(!IP) die(BAD_IP); URL = getenv("HTTP_REFERER"); if(!URL) die(BAD_URL); key = get_key(); if(!key) die(BAD_SERV); snprintf(salt, 128, "$5$%s$", IP); id = sha(URL, salt); id = strrchr(id, '$') + 1; id_ori = get_id(key, &level); if(!id_ori) die(NO_REG); if(strcmp(id, id_ori)) die(BAD_SERV); free(salt); return(level); }
/* Check the FULL binary, just for good measure. There is not a chance we'll have a false positive here but this function is not performance critical. */ static int cmp_exact(char *source, int index) { int i = 0, len, result; char *p, *key = get_key(index); char delim; unsigned char *binary, *crypt; delim = strchr(source, '.') ? '.' : '$'; p = strrchr(source, delim) + 1; len = strlen(p) / 2; if (len == BINARY_SIZE) return 1; binary = mem_alloc(len); crypt = mem_alloc(len); while (*p) { binary[i++] = (atoi16[ARCH_INDEX(*p)] << 4) | atoi16[ARCH_INDEX(p[1])]; p += 2; } #if !ARCH_LITTLE_ENDIAN for (i = 0; i < len/sizeof(uint32_t); ++i) { ((uint32_t*)binary)[i] = JOHNSWAP(((uint32_t*)binary)[i]); } #endif pbkdf2_sha1((const unsigned char*)key, strlen(key), cur_salt->salt, cur_salt->length, cur_salt->iterations, crypt, len, 0); result = !memcmp(binary, crypt, len); #if 0 dump_stuff_msg("hash binary", binary, len); dump_stuff_msg("calc binary", crypt, len); #endif MEM_FREE(binary); MEM_FREE(crypt); if (!result) fprintf(stderr, "\n%s: Warning: Partial match for '%s'.\n" "This is a bug or a malformed input line of:\n%s\n", FORMAT_LABEL, key, source); return result; }
ObjectGroup::ObjectGroup(const ReaderMapping& reader) : name(), icons(), for_worldmap(false) { icons.clear(); icons.push_back( ObjectIcon("#move", "images/engine/editor/arrow.png") ); reader.get("name", name); reader.get("worldmap", for_worldmap); auto iter = reader.get_iter(); while(iter.next()) { const std::string& token = iter.get_key(); if (token == "object") { icons.push_back( ObjectIcon( iter.as_mapping() ) ); } } }
/** * Read the DER formatted RSA key and populate the key ring buffer. * * @param rsa_keyfile * @return */ int util_set_rsakey(char *rsa_keyfile) { int ret = FALSE; int fdin; uint8_t *pInfile; struct stat sb; fdin = open(rsa_keyfile, O_RDONLY); if (fdin == -1) { perror("Could not open input"); return TRUE; } fstat(fdin, &sb); pInfile = mmap(0, sb.st_size, PROT_READ, MAP_SHARED, fdin, 0); ret = get_key(pInfile); munmap(pInfile, sb.st_size); close(fdin); return ret; }
data_object* object_generator::get_object(int iter) { // compute key (void) get_key(iter, NULL); // compute size unsigned int new_size = 0; if (m_data_size_type == data_size_fixed) { new_size = m_data_size.size_fixed; } else if (m_data_size_type == data_size_range) { if (m_data_size_pattern && *m_data_size_pattern=='S') { double a = (m_key_index-m_key_min)/static_cast<double>(m_key_max-m_key_min); new_size = (m_data_size.size_range.size_max-m_data_size.size_range.size_min)*a + m_data_size.size_range.size_min; } else { new_size = random_range(m_data_size.size_range.size_min > 0 ? m_data_size.size_range.size_min : 1, m_data_size.size_range.size_max); } } else if (m_data_size_type == data_size_weighted) { new_size = m_data_size.size_list->get_next_size(); } else { assert(0); } // compute expiry int expiry = 0; if (m_expiry_max > 0) { expiry = random_range(m_expiry_min, m_expiry_max); } // modify object content in case of random data if (m_random_data) { m_value_buffer[m_value_buffer_mutation_pos++]++; if (m_value_buffer_mutation_pos >= m_value_buffer_size) m_value_buffer_mutation_pos = 0; } // set object m_object.set_key(m_key_buffer, strlen(m_key_buffer)); m_object.set_value(m_value_buffer, new_size); m_object.set_expiry(expiry); return &m_object; }
static object get_item( pair_type& p, size_t index ){ switch( index ){ case 0:{ return get_key( p ); } case 1:{ return get_mapped( p ); } case 2:{ objects::stop_iteration_error(); return object(); //will not reach this line } default:{ PyErr_SetString( PyExc_IndexError, "the only valid index numbers are: 0 and 1"); throw_error_already_set(); return object(); //will not reach this line } } }
int list_del(char* base, char* key, int key_len) { int ndel = 0; btree_node* bp = (btree_node*) base; int* i = &bp->cell_list; while(*i != 0) { list_node* np = (list_node*)(base+*i); if(np->key_len == key_len && memcmp(get_key(np), key, key_len) == 0) // match { ndel++; arena_free(base, *i); *i = np->next; } else i = &np->next; } return ndel; }
void main() { char * map = "#### ####" "# #### #" "# #" "## ##" " # # " " # # " "## ##" "# #" "# #### #" "#### ####"; int map_w = 10; POINT player = { 2, 2 }; unsigned char scancode = 0; unsigned char ascii = 0; clear(); draw_map(map, 0, 0, map_w, 5); do { draw_char(' ', player.x, player.y, 15); switch (scancode) { case 72: move(map, &player, player.x, player.y - 1,map_w); break; case 80: move(map, &player, player.x, player.y + 1,map_w); break; case 75: move(map, &player, player.x - 1, player.y,map_w); break; case 77: move(map, &player, player.x + 1, player.y,map_w); break; } draw_char('@', player.x, player.y, 15); get_key(&scancode, &ascii); }while (scancode != 1); }
bool offset_rindex::load(const std::string& url, gulong _filecount, gulong fsize, bool CreateCacheFile) { filecount = _filecount; npages=(filecount-1)/ENTR_PER_PAGE+2; if (!oft_file.load_cache(url, url, npages*sizeof(guint32))) { MapFile map_file; if (!map_file.open(url.c_str(), fsize)) return false; const gchar *idxdatabuffer=map_file.begin(); /* oft_file.wordoffset[i] holds offset of the i-th page in the index file */ oft_file.allocate_wordoffset(npages); const gchar *p1 = idxdatabuffer; gulong index_size; guint32 j=0; for (guint32 i=0; i<filecount; i++) { index_size=strlen(p1) +1 + 2*sizeof(guint32); if (i % ENTR_PER_PAGE==0) { oft_file.get_wordoffset(j)=p1-idxdatabuffer; ++j; } p1 += index_size; } oft_file.get_wordoffset(j)=p1-idxdatabuffer; map_file.close(); if (CreateCacheFile) { if (!oft_file.save_cache(url)) g_printerr("Cache update failed.\n"); } } if (!(idxfile = fopen(url.c_str(), "rb"))) { return false; } first.assign(0, read_first_on_page_key(0)); last.assign(npages-2, read_first_on_page_key(npages-2)); middle.assign((npages-2)/2, read_first_on_page_key((npages-2)/2)); real_last.assign(filecount-1, get_key(filecount-1)); return true; }
int switch_boot_mode(void) { unsigned long hold_time = 5000000, polling_time = 10000, tmp; //unsigned long upgrade_step; unsigned int key_flag=0; while(hold_time > 0) { udelay(polling_time); tmp = get_key(); if(tmp && (key_flag<10)) { printf("get_key(): %d\n", tmp); key_flag++; } else if(!tmp && (key_flag>=10) && (key_flag<20)) { printf("get_key(): %d\n", tmp); key_flag++; } else if(key_flag>=20) break; hold_time -= polling_time; if((key_flag==0) && (hold_time<4950000)) break; } printf("key_flag=%d\n", key_flag); if(key_flag >= 15) { printf("nand key burning.... please wait\n"); run_command ("tiny_usbtool 20000", 0); return 1; } else if(key_flag == 10) { printf("upgrading... please wait\n"); into_recovery(); } else { printf("Normal Start...\n"); return 1; } }
static void touch_response_handler(lcb_server_t *server, packet_info *info) { lcb_t root = server->instance; char *packet; lcb_uint16_t nkey; const char *key = get_key(server, &nkey, &packet); lcb_uint16_t status = PACKET_STATUS(info); lcb_error_t rc = map_error(root, status); if (key == NULL) { lcb_error_handler(server->instance, LCB_EINTERNAL, NULL); } else { lcb_touch_resp_t resp; setup_lcb_touch_resp_t(&resp, key, nkey, PACKET_CAS(info)); root->callbacks.touch(root, info->ct.cookie, rc, &resp); release_key(server, packet); } }
gint test_hash(autounit_test_t *t) { di_hash_table *table; int i,nbr_of_insert=20; char str[KEY_VALUE_NBR][STRING_MAX_LENGTH]; di_rstring key[KEY_VALUE_NBR]; table = di_hash_table_new(di_rstring_hash, di_rstring_equal); for (i=0;i<nbr_of_insert;i++) { snprintf(str[i],STRING_MAX_LENGTH,"%d",i); get_key(str[i],&key[i]); di_hash_table_insert (table, &key[i], str[i]); } au_assert(t,di_hash_table_size(table) == nbr_of_insert,"hash table size is different with the number of data inserted"); return TRUE; }
static void unlock_response_handler(lcb_server_t *server, packet_info *info) { lcb_t root = server->instance; lcb_uint16_t status = PACKET_STATUS(info); char *packet; lcb_uint16_t nkey; struct lcb_command_data_st *command_data = &info->ct; const char *key = get_key(server, &nkey, &packet); lcb_error_t rc = map_error(root, status); if (key == NULL) { lcb_error_handler(server->instance, LCB_EINTERNAL, NULL); } else { lcb_unlock_resp_t resp; setup_lcb_unlock_resp_t(&resp, key, nkey); root->callbacks.unlock(root, command_data->cookie, rc, &resp); release_key(server, packet); } }
/*------------------------------------------------------------ * Function Name : FormateFlash * Description : 用于第一次使用时格式化FLASH * Input : None * Output : None * Return : None *------------------------------------------------------------*/ void FormateFlash( void ) { SetFormateFlashTimeOut(1000); while (GetFormateFlashTimeOut() == TIMEIN) { if (KEY_STOP != get_key(0xffffffff)) { return; } } if (EraseFlashAskHandler() == DISABLE) { return; } SetPage(USER_LOGIN_PAGE); if (FAILED == LoadManagerLogin() ) { lcd_clear(COLOR_BACK); return; } memset(get_pcm(),0x00,PCM_MEM_SIZE); memset(get_prm(),0x00,PRM_MEM_SIZE); memset(get_prv(),0x00,PRV_MEM_SIZE); pHmi->test_standard_index = KYSNJS; //设置默认试验 pHmi->lcd_light_use = 5; //设置默认亮度 pcm_save(); prm_save(); prv_save(); pcm_read(); prm_read(); prv_read(); lcd_clear(COLOR_BACK); }
void demo_bitmap() { printf("Demo bitmap.\n"); lcd_load_bmp("pic1.bmp", display); lcd_set_bmp(0,0,display); if (get_key() == QUIT) return; lcd_load_bmp("pic2.bmp", display); lcd_set_bmp(0,0,display); if (get_key() == QUIT) return; lcd_load_bmp("pic4.bmp", display); clear_screen(); lcd_set_bmp(0,0,display); if (get_key() == QUIT) return; lcd_set_bmp(40,0,display); if (get_key() == QUIT) return; lcd_set_bmp(80,0,display); if (get_key() == QUIT) return; lcd_load_bmp("pic3.bmp", display); lcd_set_bmp(10,10,display); if (get_key() == QUIT) return; lcd_set_bmp(70,70,display); if (get_key() == QUIT) return; }
BOOST_SERIALIZATION_DECL void extended_type_info::key_unregister() const{ if(NULL == get_key()) return; // note: it's been discovered that at least one platform is not guaranteed // to destroy singletons reverse order of construction. So we can't // use a runtime assert here. Leave this in a reminder not to do this! // BOOST_ASSERT(! singleton<detail::ktmap>::is_destroyed()); if(! singleton<detail::ktmap>::is_destroyed()){ detail::ktmap & x = singleton<detail::ktmap>::get_mutable_instance(); detail::ktmap::iterator start = x.lower_bound(this); detail::ktmap::iterator end = x.upper_bound(this); // remove entry in map which corresponds to this type for(;start != end; ++start){ if(this == *start){ x.erase(start); break; } } } }
static void cancel_supports_port (MMPlugin *plugin, const char *subsys, const char *name) { MMPluginBase *self = MM_PLUGIN_BASE (plugin); MMPluginBasePrivate *priv = MM_PLUGIN_BASE_GET_PRIVATE (self); MMPluginBaseSupportsTask *task; char *key; key = get_key (subsys, name); task = g_hash_table_lookup (priv->tasks, key); if (task) { /* Let the plugin cancel any ongoing tasks */ if (MM_PLUGIN_BASE_GET_CLASS (self)->cancel_task) MM_PLUGIN_BASE_GET_CLASS (self)->cancel_task (self, task); g_hash_table_remove (priv->tasks, key); } g_free (key); }
/* * Print a help message. */ void PrintHelpMessage( void ) /***************************/ { const int lineCount = 15; int count; int num; int ch; BannerMessage(); for( count=0,num=0; usageMsg[count]!=NULL; count++,num++ ) { if( num == lineCount ) { printf( "\t(Press return to continue)" ); fflush( stdout ); ch = get_key(); printf( "\n" ); if( ch == 'q' ) break; num = 0; } printf( "%s\n", usageMsg[count] ); } }
test_case insert_then_remove_then_search( int insertions, int removals, int search_successes, int search_failures, unsigned int seed ) { std::mt19937 rng(seed); test_case ret( insertions + search_successes + search_failures + removals ); auto rem = efficiently_choose_target_to_remove{ std::vector<std::pair<int,bool>>(insertions), insertions }; // Generate the insertions for( int i = 0; i < insertions; i++ ) { ret[i] = operation{ operation_type::insert, 2 * i + 2 }; rem.keys[i] = std::make_pair( 2 * i + 2, true ); } std::shuffle( ret.begin(), ret.begin() + insertions, rng ); // Generate the removals for( int i = 0; i < removals; i++ ) ret[i+insertions] = operation{ operation_type::erase, rem.get_key(rng) }; // Generate the searches std::uniform_int_distribution<> success_index(0, rem.keys.size()-1); std::uniform_int_distribution<> failure(0, insertions); auto bits = random_bits(search_failures, search_successes, rng); for( int i = 0; i < search_successes + search_failures; i++ ) if( bits[i] ) ret[i + insertions+removals] = operation{ operation_type::count, rem.keys[success_index(rng)].first }; else ret[i + insertions+removals] = operation{ operation_type::count, 2*failure(rng) + 1}; return ret; }
void main(){ char cChoiceMenu; lcdBegin(); SplashScreenWindow(); InitUartComm(); delay( 1000 ); key_init(); ecs_MainMenu(); while( 1 ) { //pooling for the keypads to let the user to select the choice from the options shown... cChoiceMenu = translateKeyCode( get_key() ); if( cChoiceMenu == '3' ){ //Sync Data operation mode.... syncScreenActivity(); clearLcdScreen(); ecs_MainMenu(); } else if( cChoiceMenu == '7' ) { //Settings like date settings only... SettingActivity(); clearLcdScreen(); ecs_MainMenu(); } else if( cChoiceMenu == 'B') { //Data Entry Mode operation.... dataEntrySession(); clearLcdScreen(); ecs_MainMenu(); } else { //catch the unallocated button as invalid and indicate the user about it... } } }
static cJSON * get_cJSON(cJSON *parent, const char *json_pointer, int offset) { if (parent == NULL || parent->type == cJSON_NULL) { return NULL; } if (offset == strlen(json_pointer)) { //如果为"" => obj return parent; } // / => "" => obj[""] // /key => "key" =>obj["key"] char * key = get_key(json_pointer, &offset); if (key == NULL) { return NULL; } cJSON *value = NULL; if (parent->type == cJSON_Array) { //key必须为0 or 123,456 int index = atoi(key); //strtol() value = cJSON_GetArrayItem(parent, index); } else if (parent->type == cJSON_Object) { value = cJSON_GetObjectItem(parent, key); } else { //null,number,string,boolean //不应该有key了 value = NULL; } free(key); if (value != NULL && value->type != cJSON_NULL) { return get_cJSON(value, json_pointer, offset); } else { return NULL; } }
// python function stop(channel) static PyObject *py_stop_channel(PyObject *self, PyObject *args, PyObject *kwargs) { char key[8]; char *channel; int gpio; int allowed = -1; clear_error_msg(); if (!PyArg_ParseTuple(args, "s", &channel)) return NULL; if (!get_key(channel, key)) { PyErr_SetString(PyExc_ValueError, "Invalid PWM key or name."); return NULL; } // check to ensure gpio is one of the allowed pins // Not protecting the call as if the get_key() fails, we won't make it here get_gpio_number(channel, &gpio); // Check to see if GPIO is allowed on the hardware // A 1 means we're good to go allowed = gpio_allowed(gpio); if (allowed == -1) { char err[2000]; snprintf(err, sizeof(err), "Error determining hardware. (%s)", get_error_msg()); PyErr_SetString(PyExc_ValueError, err); return NULL; } else if (allowed == 0) { char err[2000]; snprintf(err, sizeof(err), "GPIO %d not available on current Hardware", gpio); PyErr_SetString(PyExc_ValueError, err); return NULL; } softpwm_disable(key); Py_RETURN_NONE; }
int main(int argc, char **argv) { t_letter *msg; t_letter *key; t_letter *res; char *base; int flag; if (argc != 8) { my_printf("Usage : %s <message> <nb1 nb2 nb3 nb4> <base> <flag>\n", argv[0]); return (0); } if ((msg = get_message(argv[1])) == NULL) return (1); if ((key = get_key(argv)) == NULL) return (1); base = argv[6]; flag = my_getnbr(argv[7]); return (0); res = my_crypt_101(msg, key, get_len(msg)); }
/* * Look up pin in keys file. We store a dictionary for each * remote address, and inside that we have a data object for * each local address containing the pin. */ uint8_t * lookup_pin_conf(bdaddr_t *laddr, bdaddr_t *raddr) { link_key_p key = NULL; syslog(LOG_DEBUG, "Got Link_Pin_Request event from '%s', " \ "remote bdaddr %s", bt_ntoa(laddr, NULL), bt_ntoa(raddr, NULL)); if ((key = get_key(raddr, 0)) != NULL) { syslog(LOG_DEBUG, "Found matching entry, " \ "remote bdaddr %s, name '%s', pin %s", bt_ntoa(&key->bdaddr, NULL), (key->name != NULL)? key->name : "No name", (key->pin != NULL)? "exists" : "doesn't exist"); return key->pin; } syslog(LOG_DEBUG, "Could not find link key for remote bdaddr %s", bt_ntoa(raddr, NULL)); return NULL; }
BOOST_SERIALIZATION_DECL bool extended_type_info_no_rtti_0::is_less_than( const boost::serialization::extended_type_info &rhs) const { // shortcut for common case if(this == & rhs) return false; const char * l = get_key(); const char * r = rhs.get_key(); // if this assertion is triggered, it could mean one of the following // a) This class was never exported - make sure all calls which use // this method of type id are in fact exported. // b) This class was used (e.g. serialized through a pointer) before // it was exported. Make sure that classes which use this method // of type id are NOT "automatically" registered by serializating // through a pointer to the to most derived class. OR make sure // that the BOOST_CLASS_EXPORT is included in every file // which does this. BOOST_ASSERT(NULL != l); BOOST_ASSERT(NULL != r); return std::strcmp(l, r) < 0; }
static void cooked_keys(void) { int key; printf("[cooked]"); for(;;) { key = get_key(stdin, 0); if ( key == 0x03 ) { printf("[done]\n"); exit(0); } else if ( key == '?' ) return; if ( key >= 0x20 && key < 0x100 ) { putchar(key); } else { printf("[%04x]", key); } } }
/* * Select Menu */ int select_menu(unsigned int level, unsigned int n_menu) { unsigned int num=0; MZ_disp(level*13+13,num+1,0x04); while(1){ if((z80_sts.status&S_FBTN)==0) return(-1); switch(get_key()){ case 0x0d: // menu select MZ_disp(level*13+13,num+1,0x9a); return(num); break; case 0x1b: // escape menu z80_sts.status&=~S_FBTN; break; case 0x1d: // menu back MZ_disp(level*13+13,num+1,0x9a); return(999); break; case 0x1e: // up if(num>0){ MZ_disp(level*13+13,num,0x04); MZ_disp(level*13+13,num+1,0x9a); num--; } break; case 0x1f: // down if(num<(menus[n_menu].items-1)){ MZ_disp(level*13+13,num+1,0x9a); MZ_disp(level*13+13,num+2,0x04); num++; } break; default: break; } } return(-1); }
static void unlock_response_handler(lcb_server_t *server, struct lcb_command_data_st *command_data, protocol_binary_response_header *res) { lcb_t root = server->instance; lcb_uint16_t status = ntohs(res->response.status); char *packet; lcb_uint16_t nkey; const char *key = get_key(server, &nkey, &packet); lcb_error_t rc = map_error(root, status); if (key == NULL) { lcb_error_handler(server->instance, LCB_EINTERNAL, NULL); } else { lcb_unlock_resp_t resp; setup_lcb_unlock_resp_t(&resp, key, nkey); TRACE_UNLOCK_END(res->response.opaque, command_data->vbucket, rc, &resp); root->callbacks.unlock(root, command_data->cookie, rc, &resp); release_key(server, packet); } }