void GuiWidgetList::ScrollList(int /*n*/, const std::string & value) { if (value == "fwd") { int delta = m_vertical ? m_rows : m_cols; if (m_list_offset < m_list_size - delta) { m_list_offset += delta; if (get_values.connected()) { m_values.resize(m_rows * m_cols); get_values(m_list_offset, m_values); } } } else if (value == "rev") { int delta = m_vertical ? m_rows : m_cols; if (m_list_offset >= delta) { m_list_offset -= delta; if (get_values.connected()) { m_values.resize(m_rows * m_cols); get_values(m_list_offset, m_values); } } } }
void line_create(void) { char *s; float x1 = 0, y1 = 0, x2 = 0, y2 = 0; int res; serv_set_hint(DUP(_("enter first point: "))); serv_set_state(ST_LINE1); do { s = serv_get_string(); res = get_values(s, shell->context.fx, shell->context.fy, &x1, &y1); if (res == 1) serv_set_hint(DUP(_("error, please reenter: "))); } while (res == 1); serv_set_state(ST_LINE2); if (res == 0) { serv_set_state(ST_NORMAL); return; } do { pre_line_x1y1(x1, y1); shell->context.fx = x1; shell->context.fy = y1; serv_set_hint(DUP(_("enter next point: "))); do { s = serv_get_string(); res = get_values(s, x1, y1, &x2, &y2); if (res == 1) serv_set_hint(DUP(_("error, please reenter: "))); } while (res == 1); if (res == 0) { serv_set_state(ST_NORMAL); return; } lock_data(); _line_create(x1, y1, x2, y2); shell->context.fx = x2; shell->context.fy = y2; unlock_data(); x1 = x2; y1 = y2; } while (1); }
int read_hdrfile(char *infile) { SEASAT_header_ext *hdr; FILE *fp = fopen(infile,"r"); int val, i, end_line; double dtmp, t, t1; int clock_drift_hist[MAX_CLOCK_DRIFT]; int clock_drift_median; double clock_shift; if (fp==NULL) {printf("ERROR: can't open %s header file\n",infile); return(1); } hdr = (SEASAT_header_ext *) malloc(sizeof(SEASAT_header_ext)); for (i=0; i<start_line; i++) { val = get_values(fp, hdr); if (val!=20) {printf("ERROR: unable to read to specified start line in header file\n"); exit(1);} } station_code = hdr->station_code; start_year = 1970 + hdr->lsd_year; start_date = hdr->day_of_year; start_sec = (double) hdr->msec / 1000.0; s_date.year = 1970 + hdr->lsd_year; s_date.jd = hdr->day_of_year; dtmp = (double) hdr->msec / 1000.0; date_sec2hms(dtmp,&s_time); if (USE_CLOCK_DRIFT==1) { for (i=0; i<MAX_CLOCK_DRIFT; i++) clock_drift_hist[i] = 0; end_line = start_line + npatches*patch_size; for (i = start_line; i<end_line; i++) { val = get_values(fp, hdr); if (val!=20) {printf("ERROR: unable to read to specified end line in header file\n"); exit(1);} clock_drift_hist[hdr->clock_drift]++; } printf("APPLYING CLOCK DRIFT TO IMAGE TIMING.\n"); clock_drift_median = get_median(clock_drift_hist,MAX_CLOCK_DRIFT); printf("\tclock_drift_median = %li \n",clock_drift_median); clock_shift = (double) clock_drift_median / 1000.0; start_sec += clock_shift; if (start_sec > 86400.0) {start_sec -= 86400.0; start_date += 1;} dtmp = date_hms2sec(&s_time)+clock_shift; if (dtmp > 86400.0) { s_date.jd+=1; dtmp-=86400.0;} date_sec2hms(dtmp,&s_time); } printf("Found start time: %i %i %lf\n",start_year, start_date, start_sec); fclose(fp); }
int between_days(struct node *date1head, struct node *date2head) { struct date d1, d2; if (date1head == NULL || date2head == NULL) return -1; get_values(date1head, &d1); get_values(date2head, &d2); int diff = difference(&d1, &d2); if (diff < 0) return -diff; return diff; }
int main(int argc, char *argv[]) { int c, unit = 'B', t = 1; char *iface = NULL; int warningrx = 0, warningtx = 0, criticalrx = 0, criticaltx = 0; while (c = getopt(argc, argv, "bBht:i:w:c:"), c != -1) { switch (c) { case 'b': case 'B': unit = c; break; case 't': t = atoi(optarg); break; case 'i': iface = strcat(optarg, ":"); break; case 'w': sscanf(optarg, "%d:%d", &warningrx, &warningtx); break; case 'c': sscanf(optarg, "%d:%d", &criticalrx, &criticaltx); break; case 'h': usage(argv); return STATE_UNKNOWN; } } time_t s, s_old; ulli received, sent, received_old, sent_old; double rx, tx; get_values(iface, &s_old, &received_old, &sent_old); while (1) { sleep(t); get_values(iface, &s, &received, &sent); rx = (received - received_old) / (float)(s - s_old); tx = (sent - sent_old) / (float)(s - s_old); display(unit, rx, warningrx, criticalrx); printf(" "); display(unit, tx, warningtx, criticaltx); fflush(stdout); s_old = s; received_old = received; sent_old = sent; } return STATE_OK; }
void main_poller_loop(unsigned char poller_type) { int nextcheck, sleeptime, processed; double sec; zabbix_log(LOG_LEVEL_DEBUG, "In main_poller_loop() process_type:'%s' process_num:%d", get_process_type_string(process_type), process_num); zbx_setproctitle("%s [connecting to the database]", get_process_type_string(process_type)); DBconnect(ZBX_DB_CONNECT_NORMAL); for (;;) { zbx_setproctitle("%s [getting values]", get_process_type_string(process_type)); sec = zbx_time(); processed = get_values(poller_type); sec = zbx_time() - sec; zabbix_log(LOG_LEVEL_DEBUG, "%s #%d spent " ZBX_FS_DBL " seconds while updating %d values", get_process_type_string(process_type), process_num, sec, processed); nextcheck = DCconfig_get_poller_nextcheck(poller_type); sleeptime = calculate_sleeptime(nextcheck, POLLER_DELAY); zbx_sleep_loop(sleeptime); } }
static PyObject * py_hivex_node_set_values (PyObject *self, PyObject *args) { PyObject *py_r; int r; hive_h *h; PyObject *py_h; long node; py_set_values values; PyObject *py_values; if (!PyArg_ParseTuple (args, (char *) "OlO:hivex_node_set_values", &py_h, &node, &py_values)) return NULL; h = get_handle (py_h); if (get_values (py_values, &values) == -1) return NULL; r = hivex_node_set_values (h, node, values.nr_values, values.values, 0); free (values.values); if (r == -1) { PyErr_SetString (PyExc_RuntimeError, strerror (errno)); return NULL; } Py_INCREF (Py_None); py_r = Py_None; return py_r; }
s_ctrl read_ctrl_infos (oss_mixext ext, int id) { s_ctrl ctrl; ctrl.id = id; ctrl.real_id = ext.ctrl; ctrl.dev = ext.dev; ctrl.timestamp = ext.timestamp; ctrl.type = ext.type; ctrl.name = strdup(ext.extname); ctrl.max_value = ext.maxvalue; ctrl.min_value = ext.minvalue; if (ext.flags & MIXF_DECIBEL) ctrl.units_type = DECIBEL; else if (ext.flags & MIXF_CENTIBEL) ctrl.units_type = CENTIBEL; else if (ext.flags & MIXF_HZ) ctrl.units_type = HZ; get_values(&ctrl); return ctrl; }
void weights::reconcile_values(Al::request& req) { auto& values = get_values(); if (values.RedundantSize() > 1) { values *= DataType(1) / values.RedundantSize(); m_comm->nb_allreduce(values, values.RedundantComm(), req); } }
static void process_downtime(json_t * payload) { char * host_name, * service_description = NULL; char * author_name = NULL, *comment_data = NULL; time_t start_time = 0, end_time = 0, entry_time = 0; int fixed; unsigned long duration = 0, triggered_by = 0, downtimeid; if(get_values(payload, "host_name", JSON_STRING, 1, &host_name, "service_description", JSON_STRING, 0, &service_description, "entry_time", JSON_INTEGER, 1, &entry_time, "author_name", JSON_STRING, 0, &author_name, "comment_data", JSON_STRING, 0, &comment_data, "start_time", JSON_INTEGER, 1, &start_time, "end_time", JSON_INTEGER, 1, &end_time, "fixed", JSON_TRUE, 1, &fixed, "duration", JSON_INTEGER, 1, &duration, "triggered_by", JSON_INTEGER, 0, &triggered_by, NULL) != 0) { json_decref(payload); return; } schedule_downtime(service_description != NULL ? SERVICE_DOWNTIME: HOST_DOWNTIME, host_name, service_description, entry_time, author_name, comment_data, start_time, end_time, fixed, triggered_by, duration, &downtimeid); json_decref(payload); }
/** * Function to initialize the user directories of a user. */ int initialize_user(const char *user) { char **local_dir = get_values(TT_SYS_DIR_KEY); if (local_dir == NULL) { fprintf(LOGFILE, "%s is not configured.\n", TT_SYS_DIR_KEY); return INVALID_TT_ROOT; } char *user_dir; char **local_dir_ptr = local_dir; int failed = 0; for(local_dir_ptr = local_dir; *local_dir_ptr != 0; ++local_dir_ptr) { user_dir = get_user_directory(*local_dir_ptr, user); if (user_dir == NULL) { fprintf(LOGFILE, "Couldn't get userdir directory for %s.\n", user); failed = 1; break; } if (create_directory_for_user(user_dir) != 0) { failed = 1; } free(user_dir); } free_values(local_dir); return failed ? INITIALIZE_USER_FAILED : 0; }
void process_pull_msg(zmq_msg_t * payload_msg) { char * type = NULL; json_t * payload = json_loadb(zmq_msg_data(payload_msg), zmq_msg_size(payload_msg), 0, NULL); if(payload == NULL) return; if(get_values(payload, "type", JSON_STRING, 1, &type, NULL) != 0) { json_decref(payload); return; } if(strcmp(type, "command") == 0) process_cmd(payload); else if(strcmp(type, "host_check_processed") == 0 || strcmp(type, "service_check_processed") == 0) process_status(payload); else if(strcmp(type, "acknowledgement") == 0) process_acknowledgement(payload); else if(strcmp(type, "comment_add") == 0) process_comment(payload); else if(strcmp(type, "downtime_add") == 0) process_downtime(payload); else if(strcmp(type, "state_data") == 0) process_bulkstate(payload); return; }
/* Retrieves a number of attributes of an XlcCharSet. Return NULL if successful, otherwise the name of the first argument specifiying a nonexistent attribute. */ char * _XlcGetCSValues(XlcCharSet charset, ...) { va_list var; XlcArgList args; char *ret; int num_args; va_start(var, charset); _XlcCountVaList(var, &num_args); va_end(var); va_start(var, charset); _XlcVaToArgList(var, num_args, &args); va_end(var); if (args == (XlcArgList) NULL) return (char *) NULL; ret = get_values(charset, args, num_args); Xfree(args); return ret; }
static gboolean deserialize_cache (MuContacts *self) { gchar **groups; gsize i, len; groups = g_key_file_get_groups (self->_ccache, &len); for (i = 0; i != len; ++i) { ContactInfo *cinfo; char *name, *email; size_t tstamp; if (!get_values (self->_ccache, groups[i], &email, &name, &tstamp)) continue; /* ignore this one... */ cinfo = contact_info_new (email, name, tstamp); /* note, we're using the groups[i], so don't free with g_strfreev */ g_hash_table_insert (self->_hash, groups[i], cinfo); } g_free (groups); return TRUE; }
/** * Delete the given directory as the user from each of the tt_root directories * user: the user doing the delete * subdir: the subdir to delete */ int delete_as_user(const char *user, const char *subdir) { int ret = 0; char** tt_roots = get_values(TT_SYS_DIR_KEY); char** ptr; if (tt_roots == NULL || *tt_roots == NULL) { fprintf(LOGFILE, "No %s defined in the configuration\n", TT_SYS_DIR_KEY); return INVALID_CONFIG_FILE; } // do the delete for(ptr = tt_roots; *ptr != NULL; ++ptr) { char* full_path = get_user_subdirectory(*ptr, user, subdir); if (full_path == NULL) { return -1; } int this_ret = delete_path(full_path, strlen(subdir) == 0); free(full_path); // delete as much as we can, but remember the error if (this_ret != 0) { ret = this_ret; } } free_values(tt_roots); return ret; }
static void process_comment(json_t * payload) { char * host_name, *service_description = NULL, *comment_data, *author_name; time_t expire_time = 0; int persistent = 0, expires = 0; struct timeval entry_time; if(get_values(payload, "host_name", JSON_STRING, 1, &host_name, "service_description", JSON_STRING, 0, &service_description, "comment_data", JSON_STRING, 1, &comment_data, "author_name", JSON_STRING, 1, &author_name, "timestamp", JSON_TIMEVAL, 1, &entry_time, "persistent", JSON_TRUE, 1, &persistent, "expires", JSON_TRUE, 1, &expires, "expire_time", JSON_INTEGER, 0, &expire_time, NULL) != 0) { json_decref(payload); return; } add_new_comment((service_description==NULL) ? HOST_COMMENT:SERVICE_COMMENT, USER_COMMENT, host_name, service_description, entry_time.tv_sec, author_name, comment_data, persistent, COMMENTSOURCE_EXTERNAL, expires, expire_time, NULL); json_decref(payload); }
void handle_get_response( sai_object_type_t object_type, uint32_t get_attr_count, sai_attribute_t* get_attr_list, const std::string& response) { SWSS_LOG_ENTER(); //std::cout << "processing " << response << std::endl; // timestamp|action|objecttype:objectid|attrid=value,... auto v = swss::tokenize(response, '|'); auto values = get_values(v); SaiAttributeList list(object_type, values, false); sai_attribute_t *attr_list = list.get_attr_list(); uint32_t attr_count = list.get_attr_count(); match_list_lengths(object_type, get_attr_count, get_attr_list, attr_count, attr_list); SWSS_LOG_DEBUG("list match"); match_redis_with_rec(object_type, get_attr_count, get_attr_list, attr_count, attr_list); // NOTE: Primitive values are not matched (recording vs switch/vs), we can add that check }
void GUIWIDGETLIST::UpdateList(const std::string &) { if (get_values.connected()) { m_values.resize(m_rows * m_cols); get_values(m_list_offset, m_values); } }
void GridmapLocations::updateObstacleTime(const CostMapList &cm_list){ double obs_ts = cm_list.obs_timestamp / 1.0e6; //kept as seconds double *topic_utime = get_values(cm_list.topic); for(int j=0; j < cm_list.indices.size(); j++){ topic_utime[cm_list.indices[j].index] = obs_ts; } }
/** * Is the user a real user account? * Checks: * 1. Not root * 2. UID is above the minimum configured. * 3. Not in banned user list * Returns NULL on failure */ struct passwd* check_user(const char *user) { if (strcmp(user, "root") == 0) { fprintf(LOGFILE, "Running as root is not allowed\n"); fflush(LOGFILE); return NULL; } char *min_uid_str = get_value(MIN_USERID_KEY); int min_uid = DEFAULT_MIN_USERID; if (min_uid_str != NULL) { char *end_ptr = NULL; min_uid = strtol(min_uid_str, &end_ptr, 10); if (min_uid_str == end_ptr || *end_ptr != '\0') { fprintf(LOGFILE, "Illegal value of %s for %s in configuration\n", min_uid_str, MIN_USERID_KEY); fflush(LOGFILE); free(min_uid_str); min_uid_str = NULL; return NULL; } free(min_uid_str); min_uid_str = NULL; } struct passwd *user_info = get_user_info(user); if (NULL == user_info) { fprintf(LOGFILE, "User %s not found\n", user); fflush(LOGFILE); return NULL; } if (user_info->pw_uid < min_uid) { fprintf(LOGFILE, "Requested user %s has id %d, which is below the " "minimum allowed %d\n", user, user_info->pw_uid, min_uid); fflush(LOGFILE); free(user_info); user_info = NULL; return NULL; } char **banned_users = get_values(BANNED_USERS_KEY); char **banned_user = (banned_users == NULL) ? (char**) DEFAULT_BANNED_USERS : banned_users; for(; *banned_user; ++banned_user) { if (strcmp(*banned_user, user) == 0) { free(user_info); user_info = NULL; if (banned_users != (char**)DEFAULT_BANNED_USERS) { free_values(banned_users); banned_users = NULL; } fprintf(LOGFILE, "Requested user %s is banned\n", user); return NULL; } } if (banned_users != NULL && banned_users != (char**)DEFAULT_BANNED_USERS) { free_values(banned_users); banned_users = NULL; } return user_info; }
void main_poller_loop(zbx_process_t p, int type, int num) { struct sigaction phan; int now; int nextcheck, sleeptime; int items; double sec; zabbix_log( LOG_LEVEL_DEBUG, "In main_poller_loop(type:%d,num:%d)", type, num); /* phan.sa_handler = child_signal_handler;*/ phan.sa_sigaction = child_signal_handler; sigemptyset(&phan.sa_mask); phan.sa_flags = SA_SIGINFO; sigaction(SIGALRM, &phan, NULL); zbx_process = p; poller_type = type; poller_num = num; DBconnect(ZBX_DB_CONNECT_NORMAL); for (;;) { zbx_setproctitle("poller [getting values]"); now = time(NULL); sec = zbx_time(); items = get_values(now, &nextcheck); sec = zbx_time() - sec; if (FAIL == nextcheck) sleeptime = POLLER_DELAY; else { sleeptime = nextcheck - time(NULL); if (sleeptime < 0) sleeptime = 0; if (sleeptime > POLLER_DELAY) sleeptime = POLLER_DELAY; } zabbix_log(LOG_LEVEL_DEBUG, "Poller spent " ZBX_FS_DBL " seconds while updating %3d values." " Sleeping for %d seconds", sec, items, sleeptime); if (sleeptime > 0) { zbx_setproctitle("poller [sleeping for %d seconds]", sleeptime); sleep(sleeptime); } } }
static void process_status(json_t * payload) { char * host_name, *service_description = NULL, *output = NULL; check_result * newcr = NULL, t; init_check_result(&t); t.output_file = NULL; t.output_file_fp = NULL; if(get_values(payload, "host_name", JSON_STRING, 1, &host_name, "service_description", JSON_STRING, 0, &service_description, "output", JSON_STRING, 1, &output, "return_code", JSON_INTEGER, 1, &t.return_code, "start_time", JSON_TIMEVAL, 0, &t.start_time, "finish_time", JSON_TIMEVAL, 1, &t.finish_time, "check_type", JSON_INTEGER, 1, &t.check_type, "check_options", JSON_INTEGER, 0, &t.check_options, "scheduled_check", JSON_INTEGER, 0, &t.scheduled_check, "reschedule_check", JSON_INTEGER, 0, &t.reschedule_check, "latency", JSON_REAL, 0, &t.latency, "early_timeout", JSON_INTEGER, 0, &t.early_timeout, "exited_ok", JSON_INTEGER, 0, &t.exited_ok, NULL) != 0) { json_decref(payload); return; } service * service_target = NULL; if(service_description) service_target = find_service(host_name, service_description); host * host_target = find_host(host_name); if(host_target == NULL || (service_description && !service_target)) { json_decref(payload); return; } newcr = malloc(sizeof(check_result)); memcpy(newcr, &t, sizeof(check_result)); newcr->host_name = strdup(host_name); if(service_target) { newcr->service_description = strdup(service_description); newcr->object_check_type = SERVICE_CHECK; } newcr->output = strdup(output); json_decref(payload); #ifdef HAVE_NAGIOS4 newcr->engine = &nagmq_check_engine; process_check_result(newcr); #else #ifdef HAVE_ADD_CHECK_RESULT_ONE add_check_result_to_list(newcr); #elif defined(HAVE_ADD_CHECK_RESULT_TWO) add_check_result_to_list(&check_result_list, newcr); #endif #endif }
static void init() { get_values(); // Create main Window element and assign to pointer s_main_window = window_create(); //window_set_background_color(s_main_window, PBL_IF_BW_ELSE(GColorBlack, GColorBabyBlueEyes)); // Set handlers to manage the elements inside the Window window_set_window_handlers(s_main_window, (WindowHandlers) { .load = main_window_load, .unload = main_window_unload });
observable<T> get_observable() const { auto keepAlive = s; auto observable = make_observable_dynamic<T>([=](subscriber<T> o){ if (keepAlive.get_subscription().is_subscribed()) { for (auto&& value: get_values()) o.on_next(value); } keepAlive.add(keepAlive.get_subscriber(), std::move(o)); }); return s.get_coordinator().in(observable); }
//------------------------------------------------------------------- // Process short form entry on single line // '#VAR=VAL "TITLE" [MIN MAX]' // or '#VAR=VAL "TITLE" {A B C D ...}' //------------------------------------------------------------------- static int process_single(const char *ptr) { sc_param *p; ptr = get_name(ptr, MAX_PARAM_NAME_LEN, &p, 1); if (p) { ptr = get_default(p, ptr, 1); ptr = skip_whitespace(ptr); if ((*ptr == '"') || (*ptr == '\'')) { const char *s = skip_tochar(ptr+1, *ptr); p->desc = malloc(s-ptr); strncpy(p->desc, ptr+1, s-ptr-1); p->desc[s-ptr-1] = 0; if (*s == *ptr) s++; ptr = skip_whitespace(s); } else { // Error - log to console and abort return 0; } if (*ptr == '[') { ptr = get_range(p, ptr+1, ']'); } else if (*ptr == '{') { ptr = get_values(p, ptr+1, '}'); ptr = skip_whitespace(ptr); if (strncmp(ptr,"table",5) == 0) { p->data_type = DTYPE_TABLE; p->val--; // Initial value is 1 based for Lua table, convert to 0 based for C code p->def_val--; // also adjust default } } ptr = skip_whitespace(ptr); if (strncmp(ptr,"bool",4) == 0) { p->range = MENU_MINMAX(1,0); // Force boolean data type in Lua (ToDo: this is clunky, needs fixing) p->range_type = MENUITEM_BOOL|MENUITEM_SCRIPT_PARAM; ptr = skip_token(ptr); } ptr = skip_whitespace(ptr); if (strncmp(ptr,"long",4) == 0) { p->range = 9999999; p->range_type = MENUITEM_INT|MENUITEM_SD_INT; ptr = skip_token(ptr); } } return 1; }
/** * Function to prepare the attempt directories for the task JVM. * It creates the task work and log directories. */ static int create_attempt_directories(const char* user, const char *job_id, const char *task_id) { // create dirs as 0750 const mode_t perms = S_IRWXU | S_IRGRP | S_IXGRP; if (job_id == NULL || task_id == NULL || user == NULL) { fprintf(LOGFILE, "Either task_id is null or the user passed is null.\n"); return -1; } int result = 0; char **local_dir = get_values(TT_SYS_DIR_KEY); if (local_dir == NULL) { fprintf(LOGFILE, "%s is not configured.\n", TT_SYS_DIR_KEY); return -1; } char **local_dir_ptr; for(local_dir_ptr = local_dir; *local_dir_ptr != NULL; ++local_dir_ptr) { char *task_dir = get_attempt_work_directory(*local_dir_ptr, user, job_id, task_id); if (task_dir == NULL) { free_values(local_dir); return -1; } if (mkdirs(task_dir, perms) != 0) { // continue on to create other task directories free(task_dir); } else { free(task_dir); } } free_values(local_dir); // also make the directory for the task logs char *job_task_name = malloc(strlen(job_id) + strlen(task_id) + 2); if (job_task_name == NULL) { fprintf(LOGFILE, "Malloc of job task name failed\n"); result = -1; } else { sprintf(job_task_name, "%s/%s", job_id, task_id); char *log_dir = get_job_log_directory(job_task_name); free(job_task_name); if (log_dir == NULL) { result = -1; } else if (mkdirs(log_dir, perms) != 0) { result = -1; } free(log_dir); } return result; }
int is_whitelisted(const char *user) { char **whitelist = get_values(ALLOWED_SYSTEM_USERS_KEY); char **users = whitelist; if (whitelist != NULL) { for(; *users; ++users) { if (strncmp(*users, user, LOGIN_NAME_MAX) == 0) { free_values(whitelist); return 1; } } free_values(whitelist); } return 0; }
void GuiWidgetList::UpdateList(const std::string & vnum) { if (!get_values.connected()) return; std::istringstream s(vnum); s >> m_list_size; if (m_list_size <= m_list_offset) m_list_offset = m_list_size - m_list_size % (m_rows * m_cols); m_values.resize(m_rows * m_cols); get_values(m_list_offset, m_values); }
void create_userlogs_dir() { char** tt_roots = get_values("mapred.local.dir"); char** tt_root; for(tt_root=tt_roots; *tt_root != NULL; ++tt_root) { char buffer[100000]; sprintf(buffer, "%s/userlogs", *tt_root); if (mkdir(buffer, 0755) != 0) { printf("FAIL: Can't create directory %s - %s\n", buffer, strerror(errno)); exit(1); } } free_values(tt_roots); }
bgfx_suppressor* suppressor_reader::read_from_value(const Value& value, std::string prefix, std::map<std::string, bgfx_slider*>& sliders) { if (!validate_parameters(value, prefix)) { return nullptr; } std::string name = value["name"].GetString(); uint32_t condition = uint32_t(get_enum_from_value(value, "condition", bgfx_suppressor::condition_type::CONDITION_EQUAL, CONDITION_NAMES, CONDITION_COUNT)); bgfx_suppressor::combine_mode mode = bgfx_suppressor::combine_mode(get_enum_from_value(value, "combine", bgfx_suppressor::combine_mode::COMBINE_OR, COMBINE_NAMES, COMBINE_COUNT)); std::vector<bgfx_slider*> check_sliders; check_sliders.push_back(sliders[name + "0"]); int slider_count; switch (check_sliders[0]->type()) { case bgfx_slider::slider_type::SLIDER_FLOAT: case bgfx_slider::slider_type::SLIDER_INT: case bgfx_slider::slider_type::SLIDER_INT_ENUM: slider_count = 1; break; case bgfx_slider::slider_type::SLIDER_VEC2: slider_count = 2; break; case bgfx_slider::slider_type::SLIDER_COLOR: slider_count = 3; break; default: slider_count = 0; break; } int values[4]; if (slider_count > 1) { get_values(value, prefix, "value", values, slider_count); if (!READER_CHECK(slider_count == value["value"].GetArray().Size(), (prefix + "Expected " + std::to_string(slider_count) + " values, got " + std::to_string(value["value"].GetArray().Size()) + "\n").c_str())) return nullptr; for (int index = 1; index < slider_count; index++) { check_sliders.push_back(sliders[name + std::to_string(index)]); } } else { values[0] = get_int(value, "value", 0); } return new bgfx_suppressor(check_sliders, condition, mode, values); }