std::string impl::check_requirements(const atf::tests::vars_map& metadata, const atf::tests::vars_map& config) { std::string failure_reason = ""; for (atf::tests::vars_map::const_iterator iter = metadata.begin(); failure_reason.empty() && iter != metadata.end(); iter++) { const std::string& name = (*iter).first; const std::string& value = (*iter).second; INV(!value.empty()); // Enforced by application/X-atf-tp parser. if (name == "require.arch") failure_reason = check_arch(value); else if (name == "require.config") failure_reason = check_config(value, config); else if (name == "require.machine") failure_reason = check_machine(value); else if (name == "require.progs") failure_reason = check_progs(value); else if (name == "require.user") failure_reason = check_user(value, config); else { // Unknown require.* properties are forbidden by the // application/X-atf-tp parser. INV(failure_reason.find("require.") != 0); } } return failure_reason; }
/***************************************************************************** 全サーボ設定 *****************************************************************************/ bool CGainer::SetServoAll(const std::vector<WORD> &data) { check_config(); int limit = 8; if ( m_config != 8 ) { return false; } std::string c("P"); char buf[32]; size_t n = data.size(); if ( n > limit ) { n = limit; } for ( size_t i = 0 ; i < n ; ++i ) { sprintf(buf,"%02X",data[i]); c += buf; } int diff = limit - n; while ( diff > 0 ) { c += "00"; --diff; } c += "*"; return command_send(c).size() != 0; }
/* * main: * ----- */ int main123(int argc, char **argv) { time_t end_time; int raw = 0; int mono_from_stereo = 0; printf("Shine v1.08 19/06/03\n"); time(&config.start_time); set_defaults(); if (!parse_command(argc, argv, &raw, &mono_from_stereo)) print_usage(); wave_open(raw, mono_from_stereo); /* prints wave (input) configuration */ check_config(); /* prints mpeg (output) configuration */ printf("Encoding \"%s\" to \"%s\"\n", config.infile, config.outfile); L3_compress(); wave_close(); time(&end_time); end_time -= config.start_time; printf(" Finished in %2ld:%2ld:%2ld\n", end_time/3600,(end_time/60)%60,end_time%60); return 0; }
static AS3_Val init(void * self, AS3_Val args) { void * ref; void * src; void * dest; AS3_ArrayValue(args, "AS3ValType, AS3ValType, AS3ValType", &ref, &src, &dest); flashErrorsRef = (AS3_Val)ref; config.wave.file = funopen((void *)src, readByteArray, writeByteArray, seekByteArray, closeByteArray); config.wave.output = funopen((void *)dest, readByteArray, writeByteArray, seekByteArray, closeByteArray); if (config.wave.file == NULL || config.wave.output == NULL) { ERROR("Unable to set bytes arrays"); } wave_open(); set_defaults(); check_config(); start_compress(); return AS3_Int(1); }
bool CGainer::ScanLine(size_t row,BYTE data[GAINER_LED_MATRIX]) { check_config(); if ( m_config != 7 ) { return false; } if ( row > GAINER_LED_MATRIX-1 ) { return false; } //最適化:前と同じなら実行しない if ( ScanLineCompare(data,m_LEDMatrixOutputs[row]) ) { return true; } std::string c = "a"; size_t i; char buf[32]; sprintf(buf,"%u",row); c += buf; for ( i = 0 ; i < GAINER_LED_MATRIX ; ++i ) { if ( data[i] > 15 ) { data[i] = 15; } sprintf(buf,"%01X",data[i]); c += buf; } c += "*"; command_send(c,true); memcpy(m_LEDMatrixOutputs[row],data,sizeof(m_LEDMatrixOutputs[row])); return true; }
int load_config(const char *filename, config *conf) { FILE* fp; char line[1024]; memset(conf, 0, sizeof(config)); /* Open config file */ fp = fopen(filename, "r+"); if (fp == NULL) { perror("Config file open failed!"); return EXIT_FAILURE; } /* Read config file */ while (fgets(line, 1024, fp)) { if ( (parse_line(line, conf)) != EXIT_SUCCESS) { fprintf(stderr, "Config file structure is not appropriate"); return EXIT_FAILURE; } } /* end while */ fclose(fp); return check_config(*conf); }
CRefresher::CRefresher(const char * rconfig_file) { //by cm config_error = false; if( !rconfig.init(rconfig_file) ) { #ifdef _TEST cout << "config error" << endl << "please check your config file" << endl; #endif config_error = true; } else { //compute file suffix: float tmp = log10((float(rconfig.max_timeout))/(float(rconfig.min_timeout))) / log10(float(rconfig.step)); float suffix = tmp -(int)tmp; int file_num; if(suffix >= 0.5) //sometimes tmp == 4.9999....so have to do this file_num = 2 + (int)tmp; else file_num = 1 + (int)tmp; filesuffix = new FileSuffix( file_num ); /* changelog = fopen("log.change","a"); deletelog = fopen("log.delete","a"); newlog = fopen("log.new","a"); */ config_changed = false; if(check_config()) config_changed = true; init(); } }
ret_code_t fs_store(fs_config_t const * p_config, uint32_t const * p_addr, uint32_t const * const p_data, fs_length_t length_words) { if ((m_flags & FS_FLAG_INIT) == 0) { return NRF_ERROR_INVALID_STATE; } if (!check_config(p_config)) { return NRF_ERROR_FORBIDDEN; } if (!is_word_aligned(p_addr)) { return NRF_ERROR_INVALID_ADDR; } // Check that the erase operation is on pages owned by this user (configuration). if ((p_addr < p_config->p_start_addr) || ((p_addr + length_words) > p_config->p_end_addr)) { return NRF_ERROR_INVALID_ADDR; } return cmd_enqueue(p_config, FS_OP_STORE, p_addr, p_data, length_words); }
void load_config(char * path) { int i; char *p; //__android_log_print(ANDROID_LOG_DEBUG, "org.rin", "path in load_config: %s",path); jfile fd = jfopen(env_game_thread, path, JF_MODE_READ, NULL, 0); if(!fd) { init_config(); return; } memset(&setting, 0, sizeof(setting)); jfread(env_game_thread, fd, &setting, sizeof(setting)); jfclose(env_game_thread, fd); tmpsetting = setting; memcpy(m_pal16[PAL_CUSTOM_LOCAL],setting.custom_palette, sizeof(short)*4*3); check_config(); set_gb_type(); set_speed(setting.speed); }
/***************************************************************************** 全アナログ設定 *****************************************************************************/ bool CGainer::SetAnalogAll(const std::vector<WORD> &data) { int limit = CONFIG[m_config][AOUT]; if ( ! limit ) { return false; } check_config(); std::string c("A"); char buf[32]; size_t n = data.size(); if ( n > limit ) { n = limit; } for ( size_t i = 0 ; i < n ; ++i ) { sprintf(buf,"%02X",data[i]); c += buf; } int diff = limit - n; while ( diff > 0 ) { c += "00"; --diff; } c += "*"; return command_send(c).size() != 0; }
ret_code_t fs_erase(fs_config_t const * p_config, uint32_t * const p_addr, fs_length_t const length_words) { if ((m_flags & FS_FLAG_INIT) == 0) { return NRF_ERROR_INVALID_STATE; } if (!check_config(p_config)) { return NRF_ERROR_FORBIDDEN; } /** Check that the address is aligned on a page boundary and the length to erase * is a multiple of the page size. */ if (((uint32_t)p_addr & (FS_PAGE_SIZE - 1)) || (length_words & (FS_PAGE_SIZE_WORDS - 1))) { return NRF_ERROR_INVALID_ADDR; } // Check that the erase operation is on pages owned by this user (configuration). if ((p_addr < p_config->p_start_addr) || ((p_addr + length_words) > p_config->p_end_addr)) { return NRF_ERROR_INVALID_ADDR; } return cmd_enqueue(p_config, FS_OP_ERASE, p_addr, NULL, length_words); }
static void inotify_handler(int fd, short args, void *cbdata) { struct { struct inotify_event ev; char filename_buffer[4096]; } data; int sz; struct timespec tp={0, 100000}; sz= read(fd, &data, sizeof(data)); if (sz >= sizeof(data.ev)) { OPAL_OUTPUT_VERBOSE((2, orcm_cfgi_base.output, "%s Inotify Event: name %s type %d", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), data.ev.name, data.ev.mask)); /* if the event involves a typical editor swap * file, ignore it */ if (NULL != strstr(data.ev.name, ".swp") || NULL != strchr(data.ev.name, '~')) { /* vi swap */ OPAL_OUTPUT_VERBOSE((2, orcm_cfgi_base.output, "%s Inotify Event: Ignoring .swp file", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME))); return; } if ('.' == data.ev.name[0]) { /* special file */ OPAL_OUTPUT_VERBOSE((2, orcm_cfgi_base.output, "%s Inotify Event: Ignoring dot-file", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME))); return; } if ('#' == data.ev.name[0]) { /* emacs auto-save */ OPAL_OUTPUT_VERBOSE((2, orcm_cfgi_base.output, "%s Ignoring emacs auto-save file", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME))); return; } /* ensure that editors have a chance to cleanly * exit before reading the config so we don't * destabilize the parser */ nanosleep(&tp, NULL); check_config(0, 0, NULL); } else if (sz < 0) { OPAL_OUTPUT_VERBOSE((2, orcm_cfgi_base.output, "%s Inotify Event: READ ERROR", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME))); /* EINVAL: short of space */ return; } else { OPAL_OUTPUT_VERBOSE((2, orcm_cfgi_base.output, "%s Inotify Event: Short read: %d", ORTE_NAME_PRINT(ORTE_PROC_MY_NAME), sz)); } }
int main(int argc, char *argv[]) { char ch; int ret = EXIT_FAILURE; struct sc_config config; config.in_place = 0; config.file[FILE_DIC] = DEFAULT_DICTIONARY; while ((ch = getopt(argc, argv, "d:hi:o:pv")) != -1) { switch (ch) { case 'd': config.file[FILE_DIC] = optarg; break; case 'h': print_content(SC_FILE_HELP); return EXIT_SUCCESS; case 'i': config.file[FILE_DOC] = optarg; break; case 'o': if (config.in_place) { log_fatal("output file cannot be specified " "if in-place edit is asked for"); return EXIT_FAILURE; } config.file[FILE_OUT] = optarg; break; case 'p': if (config.file[FILE_OUT]) { log_fatal("document cannot be edited in place " "if output file is specified"); return EXIT_FAILURE; } config.in_place = 1; break; case 'v': print_content(SC_FILE_VERSION); return EXIT_SUCCESS; default: print_content(SC_FILE_HELP); return EXIT_FAILURE; } } if (check_config(&config, argc, argv)) { print_content(SC_FILE_HELP); goto ERROR; } if (spell_check(&config)) goto ERROR; print_content(SC_FILE_BANNER); ret = EXIT_SUCCESS; ERROR: if (config.file[FILE_OUT]) free(config.file[FILE_OUT]); return ret; }
/** * Create the connection to the resolver service. * * @param cfg configuration to use */ void GNUNET_RESOLVER_connect (const struct GNUNET_CONFIGURATION_Handle *cfg) { GNUNET_assert (NULL != cfg); backoff = GNUNET_TIME_UNIT_MILLISECONDS; resolver_cfg = cfg; check_config (); }
int main(int argc, char **argv) { (void) argc; (void) argv; check_config(); setbuf(stdout, NULL); setbuf(stderr, NULL); log("tuerd (rev " GIT_REV ") starting up"); if(getenv("TUERD_DEBUG")) debug = 1; debug("Debugging enabled. This allows people to be tracked!"); // initialize git git_init(); // initialize nfc nfc_device *nfc_dev = rfid_init(); if(!nfc_dev) die("rfid_init failed"); // initialize watchdog handler struct sigaction sa; sa.sa_handler = sigalarm; sigemptyset(&sa.sa_mask); sa.sa_flags = 0; sigaction(SIGALRM, &sa, NULL); while(1) { debug("-----------------"); debug("waiting for event"); if(!rfid_poll(nfc_dev)) die("rfid_poll failed"); debug("successfully got target"); alarm(10); if(rfid_authenticate_any(nfc_dev, get_key_git)) { debug("auth succeeded, opening door"); open_door(); alarm(0); sleep(10); } else { debug("auth failed"); alarm(0); sleep(1); } } return EXIT_SUCCESS; }
fs_ret_t fs_store(fs_config_t const * const p_config, uint32_t const * const p_dest, uint32_t const * const p_src, uint16_t const length_words) { fs_op_t * p_op; if (!(m_flags & FS_FLAG_INITIALIZED)) { return FS_ERR_NOT_INITIALIZED; } if (!check_config(p_config)) { return FS_ERR_INVALID_CFG; } if ((p_src == NULL) || (p_dest == NULL)) { return FS_ERR_NULL_ARG; } // Check that both pointers are word aligned. if (((uint32_t)p_src & 0x03) || ((uint32_t)p_dest & 0x03)) { return FS_ERR_UNALIGNED_ADDR; } // Check that the operation doesn't go outside the client's memory boundaries. if ((p_config->p_start_addr > p_dest) || (p_config->p_end_addr < (p_dest + length_words))) { return FS_ERR_INVALID_ADDR; } if (length_words == 0) { return FS_ERR_INVALID_ARG; } if (!queue_get_next_free(&p_op)) { return FS_ERR_QUEUE_FULL; } // Initialize the operation. p_op->p_config = p_config; p_op->op_code = FS_OP_STORE; p_op->store.p_src = p_src; p_op->store.p_dest = p_dest; p_op->store.length_words = length_words; queue_start(); return FS_SUCCESS; }
/** * Get an IP address as a string. * * @param sa host address * @param salen length of host address in @a sa * @param do_resolve use #GNUNET_NO to return numeric hostname * @param timeout how long to try resolving * @param callback function to call with hostnames * last callback is NULL when finished * @param cls closure for @a callback * @return handle that can be used to cancel the request */ struct GNUNET_RESOLVER_RequestHandle * GNUNET_RESOLVER_hostname_get (const struct sockaddr *sa, socklen_t salen, int do_resolve, struct GNUNET_TIME_Relative timeout, GNUNET_RESOLVER_HostnameCallback callback, void *cls) { struct GNUNET_RESOLVER_RequestHandle *rh; size_t ip_len; const void *ip; check_config (); switch (sa->sa_family) { case AF_INET: GNUNET_assert (salen == sizeof (struct sockaddr_in)); ip_len = sizeof (struct in_addr); ip = &((const struct sockaddr_in*)sa)->sin_addr; break; case AF_INET6: GNUNET_assert (salen == sizeof (struct sockaddr_in6)); ip_len = sizeof (struct in6_addr); ip = &((const struct sockaddr_in6*)sa)->sin6_addr; break; default: GNUNET_break (0); return NULL; } rh = GNUNET_malloc (sizeof (struct GNUNET_RESOLVER_RequestHandle) + salen); rh->name_callback = callback; rh->cls = cls; rh->af = sa->sa_family; rh->timeout = GNUNET_TIME_relative_to_absolute (timeout); memcpy (&rh[1], ip, ip_len); rh->data_len = ip_len; rh->direction = GNUNET_YES; rh->received_response = GNUNET_NO; if (GNUNET_NO == do_resolve) { rh->task = GNUNET_SCHEDULER_add_now (&numeric_reverse, rh); return rh; } GNUNET_CONTAINER_DLL_insert_tail (req_head, req_tail, rh); rh->was_queued = GNUNET_YES; if (NULL != s_task) { GNUNET_SCHEDULER_cancel (s_task); s_task = NULL; } process_requests (); return rh; }
/***************************************************************************** Continuous系 *****************************************************************************/ void CGainer::ExecuteContinuousDigital(DWORD period) { check_config(); if ( ! CONFIG[m_config][DIN] ) { return; } m_digital_period = period; command_send("r*",true); }
/* * setup() - performs all ONE TIME setup for this test */ void setup(void) { tst_sig(NOFORK, DEF_HANDLER, cleanup); check_config(TEST_NODES); /* Pause if that option was specified * TEST_PAUSE contains the code to fork the test with the -c option. */ TEST_PAUSE; }
fs_ret_t fs_erase(fs_config_t const * const p_config, uint32_t const * const p_page_addr, uint16_t const num_pages) { fs_op_t * p_op; if (!(m_flags & FS_FLAG_INITIALIZED)) { return FS_ERR_NOT_INITIALIZED; } if (!check_config(p_config)) { return FS_ERR_INVALID_CFG; } if (p_page_addr == NULL) { return FS_ERR_NULL_ARG; } // Check that the page is aligned to a page boundary. if (((uint32_t)p_page_addr % FS_PAGE_SIZE) != 0) { return FS_ERR_UNALIGNED_ADDR; } // Check that the operation doesn't go outside the client's memory boundaries. if ((p_page_addr < p_config->p_start_addr) || (p_page_addr + (FS_PAGE_SIZE_WORDS * num_pages) > p_config->p_end_addr)) { return FS_ERR_INVALID_ADDR; } if (num_pages == 0) { return FS_ERR_INVALID_ARG; } if (!queue_get_next_free(&p_op)) { return FS_ERR_QUEUE_FULL; } // Initialize the operation. p_op->p_config = p_config; p_op->op_code = FS_OP_ERASE; p_op->erase.page = ((uint32_t)p_page_addr / FS_PAGE_SIZE); p_op->erase.pages_to_erase = num_pages; queue_start(); return FS_SUCCESS; }
/***************************************************************************** 単独サーボ設定 *****************************************************************************/ bool CGainer::SetServoSingle(int port,BYTE value) { check_config(); int limit = 8; if ( m_config != 8 ) { return false; } char buf[64]; sprintf(buf,"p%d%02X*",port,value); return command_send(buf).size() != 0; }
/***************************************************************************** LED(h/l) *****************************************************************************/ bool CGainer::SetLED(bool isOn) { check_config(); if ( isOn ) { return command_send("h*").size() != 0; } else { return command_send("l*").size() != 0; } }
void CGainer::ExecuteContinuousAnalog(DWORD period) { check_config(); if ( ! CONFIG[m_config][AIN] ) { return; } m_analog_period = period; command_send("i*",true); }
static int config_init(const char *file) { GKeyFile *config; config = load_config(file); check_config(config); parse_config(config); if (config != NULL) g_key_file_free(config); return 0; }
static gboolean sep_setconf_ind(struct avdtp *session, struct avdtp_local_sep *sep, struct avdtp_stream *stream, GSList *caps, avdtp_set_configuration_cb cb, void *user_data) { struct a2dp_endpoint *endpoint = user_data; struct a2dp_device *dev; struct a2dp_preset *preset = NULL; DBG(""); dev = find_device_by_session(session); if (!dev) { error("Unable to find device for session %p", session); return FALSE; } for (; caps != NULL; caps = g_slist_next(caps)) { struct avdtp_service_capability *cap = caps->data; struct avdtp_media_codec_capability *codec; if (cap->category == AVDTP_DELAY_REPORTING) return FALSE; if (cap->category != AVDTP_MEDIA_CODEC) continue; codec = (struct avdtp_media_codec_capability *) cap->data; if (codec->media_codec_type != endpoint->codec) return FALSE; preset = g_new0(struct a2dp_preset, 1); preset->len = cap->length - sizeof(*codec); preset->data = g_memdup(codec->data, preset->len); if (check_config(endpoint, preset) < 0) { preset_free(preset); return FALSE; } } if (!preset) return FALSE; setup_add(dev, endpoint, preset, stream); cb(session, stream, NULL); return TRUE; }
bool CGainer::ScanMatrix(BYTE data[GAINER_LED_MATRIX][GAINER_LED_MATRIX]) { check_config(); if ( m_config != 7 ) { return false; } for ( size_t row = 0 ; row < GAINER_LED_MATRIX ; ++row ) { ScanLine(row,data[row]); } return true; }
/***************************************************************************** 単独アナログ設定 *****************************************************************************/ bool CGainer::SetAnalogSingle(int port,BYTE value) { if ( ! CONFIG[m_config][AOUT] ) { return false; } check_config(); char buf[64]; sprintf(buf,"a%d%02X*",port,value); return command_send(buf).size() != 0; }
/***************************************************************************** 全デジタル設定 *****************************************************************************/ bool CGainer::SetDigitalAll(int value) { if ( ! CONFIG[m_config][DOUT] ) { return false; } check_config(); char c[32]; sprintf(c,"D%04X*",value); return command_send(c).size() != 0; }
/***************************************************************************** 全デジタル取得 *****************************************************************************/ bool CGainer::GetDigitalAll(WORD &result,size_t &bits) { check_config(); if ( ! CONFIG[m_config][DIN] ) { return false; } std::string r = command_send("R*"); result = m_digitalInputs; bits = CONFIG[m_config][DIN]; return r.size() != 0; }
static int setup_config(int type) { int rv; rv = read_config(cl.configfile, type); if (rv < 0) goto out; if (is_auth_req()) { rv = read_authkey(); if (rv < 0) goto out; #if HAVE_LIBGCRYPT if (!gcry_check_version(NULL)) { log_error("gcry_check_version"); rv = -ENOENT; goto out; } gcry_control(GCRYCTL_DISABLE_SECMEM, 0); gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0); #endif } /* Set "local" pointer, ignoring errors. */ if (cl.type == DAEMON && cl.site[0]) { if (!find_site_by_name(cl.site, &local, 1)) { log_error("Cannot find \"%s\" in the configuration.", cl.site); return -EINVAL; } local->local = 1; } else find_myself(NULL, type == CLIENT || type == GEOSTORE); rv = check_config(type); if (rv < 0) goto out; /* Per default the PID file name is derived from the * configuration name. */ if (!cl.lockfile[0]) { snprintf(cl.lockfile, sizeof(cl.lockfile)-1, "%s/%s.pid", BOOTH_RUN_DIR, booth_conf->name); } out: return rv; }