/* * machine_id records are used to get the selinux context associated to a * guest. */ int process_machine_id_event(auparse_state_t *au) { uid_t uid; time_t time; const char *seclevel, *uuid, *name; struct event *event; int success; seclevel = get_seclevel(auparse_find_field(au, "vm-ctx")); if (seclevel == NULL) { if (debug) fprintf(stderr, "Security context not found for " "MACHINE_ID event.\n"); } if (extract_virt_fields(au, &uuid, &uid, &time, &name, &success)) return 0; event = event_alloc(); if (event == NULL) return 1; event->type = ET_MACHINE_ID; event->uuid = copy_str(uuid); event->name = copy_str(name); event->success = success; event->seclevel = copy_str(seclevel); event->uid = uid; event->start = time; add_proof(event, au); if (list_append(events, event) == NULL) { event_free(event); return 1; } return 0; }
/* copy location_t to location */ struct Location* copy_location( struct Location_t* loc, FILE* file ) { int i, stars; struct Location* copy; FILE* file_t = file; char str[10000]; copy = (struct Location*)malloc( sizeof(struct Location) ); copy->address = copy_str(loc->address); copy->city = copy_str(loc->city); copy->state = copy_str(loc->state); copy->zip_code = copy_str(loc->zip_code); copy->num_reviews = loc->num_reviews; copy->reviews = NULL; if( copy->num_reviews >0 ) { copy->reviews = (struct Review*)malloc( sizeof(struct Review)*copy->num_reviews ); for( i=0 ; i<copy->num_reviews ; i++ ) { // transform offset to actually review text fseek( file_t, loc->reviews[i].offset, SEEK_SET); fscanf( file_t, "%*d %d %*d %*d %*d ", &stars ); copy->reviews[i].stars = stars; fgets(str, 10000, file_t); copy->reviews[i].text = copy_str(str); } } /* for( i=0 ; i<copy->num_reviews ; i++ ) { printf( "%d, %s\n" , i, copy->reviews[i].text ); } */ return copy; }
const char * apply_mods(const char path[], const char parent[], const char mod[], int for_shell) { static char buf[PATH_MAX]; int napplied = 0; copy_str(buf, sizeof(buf), path); while(*mod != '\0') { int mod_len; const char *const p = apply_mod(buf, parent, mod, &mod_len, for_shell); if(p == NULL) { break; } copy_str(buf, sizeof(buf), p); mod += mod_len; napplied++; } #ifdef _WIN32 /* This is needed to run something like explorer.exe, which isn't smart enough * to understand forward slashes. */ if(for_shell && curr_stats.shell_type != ST_CMD && napplied == 0) { to_back_slash(buf); } #endif return buf; }
int main(){ String s; char* str; init_string( &s ); copy_str( s, "Hello world..." ); print_string( s ); putchar( '\n' ); concat_str( s, " my name is Blur." ); print_string( s ); putchar( '\n' ); copy_str( s, "Hi" ); print_string( s ); putchar( '\n' ); printf( "Is it equal to hi? %d\n", compare_str( s, "hi" ) ); printf( "Is it equal to Hi? %d\n", compare_str( s, "Hi" ) ); printf( "Is it equal to hello? %d\n", compare_str( s, "hello" ) ); printf( "Is it equal to Hello? %d\n", compare_str( s, "Hello" ) ); str = to_c_str( s ); printf( "%s\n", str ); free( str ); clear_string( &s ); return 0; }
/* Compares two filenames. Returns positive value if s greater than t, zero if * they are equal, otherwise negative value is returned. */ static int compare_file_names(int dirs, const char s[], const char t[], int ignore_case) { char s_buf[NAME_MAX]; char t_buf[NAME_MAX]; /* TODO: FIXME: get rid of this when slash is removed from directory names. */ if(dirs) { copy_substr(s_buf, sizeof(s_buf), s, '/'); s = s_buf; copy_substr(t_buf, sizeof(t_buf), t, '/'); t = t_buf; } if(ignore_case) { if(!dirs) { copy_str(s_buf, sizeof(s_buf), s); s = s_buf; copy_str(t_buf, sizeof(t_buf), t); t = t_buf; } strtolower(s_buf); strtolower(t_buf); } return cfg.sort_numbers ? strnumcmp(s, t) : strcmp(s, t); }
/* Navigates the view to a given dir/file combination specified by the path. */ static void navigate_to_selected_file(FileView *view, const char path[]) { char name[NAME_MAX]; char *dir = strdup(path); char *const last_slash = find_slashr(dir); if(last_slash == NULL) { copy_str(name, sizeof(name), dir); } else { *last_slash = '\0'; copy_str(name, sizeof(name), last_slash + 1); } if(change_directory(view, dir) >= 0) { ui_sb_quick_msgf("%s", "Finding the correct directory..."); load_dir_list(view, 0); (void)ensure_file_is_selected(view, name); } else { show_error_msgf("Invalid path", "Cannot change dir to \"%s\"", dir); } free(dir); }
void do_tests(int do_cmp, int ttype[3], f_ectx alg[1], const unsigned long blen, const unsigned long klen) { char name1[128], name2[128], *sp1, *sp2; int i; FILE *outf; printf("\nGenerate%s tests for aes (AES_BLOCK_SIZE = %lu, key size = %lu)\n", (do_cmp ? " and verify" : ""), 8 * blen, 8 * klen); for(i = 0; i < 8; ++i) // for each type of test /k /x /e /c (2 tests each) if(ttype[i / 2]) // if this test required { // name of file for output of generated test vectors sp1 = copy_str(name1, ar_path); sp1 = copy_str(sp1, out_path); sp2 = copy_str(name2, ar_path); sp2 = copy_str(sp2, ref_path); file_name(sp1, 128, i, blen, klen); copy_str(sp2, sp1); if(!fopen_s(&outf, name1, "w")) { header(outf, i, blen, klen); f_ptr[i](outf, alg, blen, klen); fprintf(outf, "\n"); fclose(outf); if(do_cmp) // compare it with reference if required comp_vecs(name2, name1); } else { printf("ERROR: failed to open %s for writing\n", name1); } } }
void encode_entry( char *str ) { int match_cnt; int len; char buf[ MAX_STR ]; if ( cur_entry - 1 >= 0 ) { compare_entry(str, &match_cnt); /* need to match more than one char to be useful */ if ( match_cnt > 1 ) { buf[0] = (signed char) - match_cnt; copy_str(&buf[1], str + match_cnt); len = get_strlen( buf ); entry[ cur_entry ] = (char *) malloc( len + 1 ); copy_str( entry[ cur_entry ], buf ); } else { entry[ cur_entry ] = (char *) strdup( str ); } } else { entry[ cur_entry ] = (char *) strdup( str ); } }
static void decode_detailed_monitor(edid1_detailed_monitor *monitor, const edid1_detailed_monitor_raw *raw, bool enableExtra) { int i, j; for (i = 0; i < EDID1_NUM_DETAILED_MONITOR_DESC; ++i, ++monitor, ++raw) { // workaround: normally, all four bytes must be zero for detailed // description, but at least some Formac monitors violate that: // they have some additional info that start at zero_4(!), // so even if only the first two _or_ the other two bytes are // zero, we accept it as a monitor description block if (enableExtra && ((raw->extra.zero_0[0] == 0 && raw->extra.zero_0[1] == 0) || (raw->extra.zero_0[2] == 0 && raw->extra.zero_4 == 0))) { monitor->monitor_desc_type = raw->extra.monitor_desc_type; switch (raw->extra.monitor_desc_type) { case EDID1_SERIAL_NUMBER: copy_str(monitor->data.serial_number, raw->extra.data.serial_number, EDID1_EXTRA_STRING_LEN); break; case EDID1_ASCII_DATA: copy_str(monitor->data.ascii_data, raw->extra.data.ascii_data, EDID1_EXTRA_STRING_LEN); break; case EDID1_MONITOR_RANGES: monitor->data.monitor_range = raw->extra.data.monitor_range; break; case EDID1_MONITOR_NAME: copy_str(monitor->data.monitor_name, raw->extra.data.monitor_name, EDID1_EXTRA_STRING_LEN); break; case EDID1_ADD_COLOUR_POINTER: decode_whitepoint(monitor->data.whitepoint, &raw->extra.data.whitepoint); break; case EDID1_ADD_STD_TIMING: for (j = 0; j < EDID1_NUM_EXTRA_STD_TIMING; ++j) { decode_std_timing(&monitor->data.std_timing[j], &raw->extra.data.std_timing[j]); } break; } } else if (raw->detailed_timing.pixel_clock > 0) { monitor->monitor_desc_type = EDID1_IS_DETAILED_TIMING; decode_detailed_timing(&monitor->data.detailed_timing, &raw->detailed_timing); } } }
static enum Nagios_status get_hlth_status_str (struct ilo_oid_list **oid_list_ptr, void *data) { enum Nagios_status n_status = NAGIOS_UNKNOWN; int hlth_status; struct ilo_snmp_priv *priv_ptr = NULL; struct ilo_oid_info *oid_info_ptr = (struct ilo_oid_info *) data; char *status_str[] = {"N/A", "Other", "OK", "Degraded", "Failed"}; hlth_status = (*oid_list_ptr)->integer; copy_str(&(*oid_list_ptr)->string, (*oid_list_ptr)->value_len, status_str[hlth_status]); (*oid_list_ptr)->value_len = strlen((*oid_list_ptr)->string); (*oid_list_ptr)->type = ASN_OCTET_STR; switch (hlth_status) { case ILO_HLTH_STATUS_NA: case ILO_HLTH_STATUS_OTHER: n_status = NAGIOS_UNKNOWN; break; case ILO_HLTH_STATUS_DEGRADED: if (oid_info_ptr->oid_pool[HLTH_COMP_OID].oid_len) get_failed_component_status(oid_list_ptr, oid_info_ptr, status_str); n_status = NAGIOS_WARNING; break; case ILO_HLTH_STATUS_FAILED: priv_ptr = container_of((struct ilo_oid_list **) oid_list_ptr, struct ilo_snmp_priv, oid_list); if (oid_info_ptr->oid_pool[HLTH_COMP_OID].oid_len) get_failed_component_status(oid_list_ptr, oid_info_ptr, status_str); if(priv_ptr->err_str) { copy_str(&priv_ptr->err_str, strlen(priv_ptr->err_str), (*oid_list_ptr)->string); } else { asprintf(&priv_ptr->err_str, (*oid_list_ptr)->string); } n_status = NAGIOS_CRITICAL; break; case ILO_HLTH_STATUS_OK: n_status = NAGIOS_OK; break; } return n_status; }
int add_start_guest_event(auparse_state_t *au) { struct event *start; uid_t uid; time_t time; const char *uuid, *name; int success; list_node_t *it; /* Just skip this record if it failed to get some of the fields */ if (extract_virt_fields(au, &uuid, &uid, &time, &name, &success)) return 0; /* On failure, loop backwards to update all the resources associated to * the last session of this guest. When a machine_id or a stop event is * found the loop can be broken because a machine_id is created at the * beginning of a session and a stop event indicates a previous * session. */ if (!success) { for (it = events->tail; it; it = it->prev) { struct event *event = it->data; if (event->success && event->uuid && strcmp(uuid, event->uuid) == 0) { if (event->type == ET_STOP || event->type == ET_MACHINE_ID) { /* An old session found. */ break; } else if (event->type == ET_RES && event->end == 0) { event->end = time; add_proof(event, au); } } } } start = event_alloc(); if (start == NULL) return 1; start->type = ET_START; start->uuid = copy_str(uuid); start->name = copy_str(name); start->success = success; start->uid = uid; start->start = time; auparse_first_record(au); if (auparse_find_field(au, "vm-pid")) start->pid = auparse_get_field_int(au); add_proof(start, au); if (list_append(events, start) == NULL) { event_free(start); return 1; } return 0; }
/* Implementation of :. filename modifier. */ static int apply_dot_mod(const char *path, char *buf, size_t buf_len) { size_t len = strlen(curr_view->curr_dir); if(strnoscmp(path, curr_view->curr_dir, len) != 0 || path[len] == '\0') copy_str(buf, buf_len, path); else copy_str(buf, buf_len, path + len + 1); return 0; }
/* Completely resets the cs to builtin default color scheme. Changes: colors, * name, state. */ static void reset_to_default_color_scheme(col_scheme_t *cs) { reset_color_scheme_colors(cs); copy_str(cs->name, sizeof(cs->name), DEF_CS_NAME); copy_str(cs->dir, sizeof(cs->dir), "/"); cs->state = CSS_NORMAL; }
void do_tests(const bool vkt, const bool ecb, const bool cbc, AESREF alg) { char path[128], *sp; con_string("\nRun tests for the "); con_string(alg.name()); con_string(" algorithm"); sp = copy_str(path, ref_path); sp = copy_str(sp, alg.name()); if(vkt) { copy_str(sp, aes_name[0]); ref_test(path, 1, ecb_vk, alg); copy_str(sp, aes_name[1]); ref_test(path, 1, ecb_vt, alg); } if(ecb) { copy_str(sp, aes_name[2]); ref_test(path, 10000, ecb_me, alg); copy_str(sp, aes_name[3]); ref_test(path, 10000, ecb_md, alg); } if(cbc) { copy_str(sp, aes_name[4]); ref_test(path, 10000, cbc_me, alg); copy_str(sp, aes_name[5]); ref_test(path, 10000, cbc_md, alg); } }
/* Compares two file names according to grouping regular expression. Returns * standard -1, 0, 1 for comparisons. */ static int compare_group(const char f[], const char s[], regex_t *regex) { char fname[NAME_MAX + 1], sname[NAME_MAX + 1]; regmatch_t fmatch = get_group_match(regex, f); regmatch_t smatch = get_group_match(regex, s); copy_str(fname, MIN(sizeof(fname), fmatch.rm_eo - fmatch.rm_so + 1U), f + fmatch.rm_so); copy_str(sname, MIN(sizeof(sname), smatch.rm_eo - smatch.rm_so + 1U), s + smatch.rm_so); return strcmp(fname, sname); }
int disk_set_fname (disk_t* disk, const char* fname) { if (disk == NULL) return ERR_INVALIDARG; return copy_str(fname, &disk->fname); }
/* Appends path to the entry to the expanded string. Returns new value of * expanded string. */ static char * append_entry(FileView *view, char expanded[], PathType type, dir_entry_t *entry, int quotes, const char mod[], int for_shell) { char path[PATH_MAX]; const char *modified; switch(type) { case PT_NAME: copy_str(path, sizeof(path), entry->name); break; case PT_REL: get_short_path_of(view, entry, 0, sizeof(path), path); break; case PT_FULL: get_full_path_of(entry, sizeof(path), path); break; default: assert(0 && "Unexpected path type"); path[0] = '\0'; break; } modified = apply_mods(path, flist_get_dir(view), mod, for_shell); expanded = append_path_to_expanded(expanded, quotes, modified); return expanded; }
char *replace_by_alias(char *str, t_alias *list) { char *new_str; char *word; int save; int x; x = -1; if ((new_str = copy_str(str)) == NULL) return (NULL); while (new_str[++x]) { if (new_str[x] != ';' && new_str[x] != ' ' && new_str[x] != '\t' && new_str[x] != '|' && new_str[x] != '&') { save = x; if ((word = get_a_word(new_str, &x)) && is_alias(&word, list)) { if ((new_str = replace_word(word, new_str, save, &x)) == NULL) return (NULL); } else if (word) free(word); } } return (new_str); }
/* Appends slash to the name and stores result in the buffer. */ static void append_slash(const char name[], char buf[], size_t buf_size) { const size_t nchars = copy_str(buf, buf_size - 1, name); buf[nchars - 1] = '/'; buf[nchars] = '\0'; }
char* parse_string_internal(const char** input, JzonAllocator* allocator) { if (current(input) != '"') return NULL; if (is_multiline_string_quotes(*input)) return parse_multiline_string(input, allocator); next(input); char* start = (char*)*input; while (current(input)) { if (current(input) == '"') { char* end = (char*)*input; next(input); return copy_str(allocator, start, (unsigned)(end - start)); break; } next(input); } return NULL; }
/* Writes path configuration file and directories for further usage. */ static void store_config_paths(void) { LOG_FUNC_ENTER; const char *const trash_dir_fmt = #ifndef _WIN32 "%%r/.vifm-Trash-%%u,%s/" TRASH ",%%r/.vifm-Trash"; #else "%%r/.vifm-Trash,%s/" TRASH; #endif char *fuse_home; const char *trash_base = path_exists_at(env_get(VIFM_EV), TRASH, DEREF) ? cfg.config_dir : cfg.data_dir; const char *base = path_exists(cfg.data_dir, DEREF) ? cfg.data_dir : cfg.config_dir; snprintf(cfg.home_dir, sizeof(cfg.home_dir), "%s/", env_get(HOME_EV)); copy_str(cfg.config_dir, sizeof(cfg.config_dir), env_get(VIFM_EV)); snprintf(cfg.colors_dir, sizeof(cfg.colors_dir), "%s/colors/", cfg.config_dir); snprintf(cfg.trash_dir, sizeof(cfg.trash_dir), trash_dir_fmt, trash_base); snprintf(cfg.log_file, sizeof(cfg.log_file), "%s/" LOG, base); fuse_home = format_str("%s/fuse/", base); (void)cfg_set_fuse_home(fuse_home); free(fuse_home); }
/* find or add value and return pointer */ struct udvt_entry * add_udv(int t_num) { char varname[MAX_ID_LEN+1]; copy_str(varname, t_num, MAX_ID_LEN); return add_udv_by_name(varname); }
/* find or add function at index <t_num>, and return pointer */ struct udft_entry * add_udf(int t_num) { struct udft_entry **udf_ptr = &first_udf; int i; while (*udf_ptr) { if (equals(t_num, (*udf_ptr)->udf_name)) return (*udf_ptr); udf_ptr = &((*udf_ptr)->next_udf); } /* get here => not found. udf_ptr points at first_udf or * next_udf field of last udf */ if (is_builtin_function(t_num)) int_warn(t_num, "Warning : udf shadowed by built-in function of the same name"); /* create and return a new udf slot */ *udf_ptr = (struct udft_entry *) gp_alloc(sizeof(struct udft_entry), "function"); (*udf_ptr)->next_udf = (struct udft_entry *) NULL; (*udf_ptr)->definition = NULL; (*udf_ptr)->at = NULL; (*udf_ptr)->udf_name = gp_alloc (token_len(t_num)+1, "user func"); copy_str((*udf_ptr)->udf_name, t_num, token_len(t_num)+1); for (i = 0; i < MAX_NUM_VAR; i++) (void) Ginteger(&((*udf_ptr)->dummy_values[i]), 0); return (*udf_ptr); }
op_set op_decl_set_core ( int size, char const * name ) { if ( size < 0 ) { printf ( " op_decl_set error -- negative/zero size for set: %s\n", name ); exit ( -1 ); } if ( OP_set_index == OP_set_max ) { OP_set_max += 10; OP_set_list = ( op_set * ) realloc ( OP_set_list, OP_set_max * sizeof ( op_set ) ); if ( OP_set_list == NULL ) { printf ( " op_decl_set error -- error reallocating memory\n" ); exit ( -1 ); } } op_set set = ( op_set ) malloc ( sizeof ( op_set_core ) ); set->index = OP_set_index; set->size = size; set->core_size = size; set->name = copy_str( name ); set->exec_size = 0; set->nonexec_size = 0; OP_set_list[OP_set_index++] = set; return set; }
op_map op_decl_map_core ( op_set from, op_set to, int dim, int * imap, char const * name ) { if ( from == NULL ) { printf ( " op_decl_map error -- invalid 'from' set for map %s\n", name ); exit ( -1 ); } if ( to == NULL ) { printf ( "op_decl_map error -- invalid 'to' set for map %s\n", name ); exit ( -1 ); } if ( dim <= 0 ) { printf ( "op_decl_map error -- negative/zero dimension for map %s\n", name ); exit ( -1 ); } /*This check breaks for MPI - need to fix this */ /*for ( int d = 0; d < dim; d++ ) { for ( int n = 0; n < from->size; n++ ) { if ( imap[d + n * dim] < 0 || imap[d + n * dim] >= to->size ) { printf ( "op_decl_map error -- invalid data for map %s\n", name ); printf ( "element = %d, dimension = %d, map = %d\n", n, d, imap[d + n * dim] ); exit ( -1 ); } } }*/ if ( OP_map_index == OP_map_max ) { OP_map_max += 10; OP_map_list = ( op_map * ) realloc ( OP_map_list, OP_map_max * sizeof ( op_map ) ); if ( OP_map_list == NULL ) { printf ( " op_decl_map error -- error reallocating memory\n" ); exit ( -1 ); } } op_map map = ( op_map ) malloc ( sizeof ( op_map_core ) ); map->index = OP_map_index; map->from = from; map->to = to; map->dim = dim; map->map = imap; map->name = copy_str( name ); map->user_managed = 1; OP_map_list[OP_map_index++] = map; return map; }
/* copy Business_t to Business ,and * state code and ZIP code to filter locations by, or NULL * to include all states. */ struct Business* copy_filte_business( struct Business_t* business, char* state, char* zip_code, FILE* file ) { int i; struct Business* ret; struct Location_t *loc_t; ret = (struct Business*)malloc( sizeof(struct Business) ); ret->name = copy_str(business->name); ret->locations = NULL; ret->num_locations = 0; for( i=0 ; i<business->num_locations ; i++ ) { loc_t = &(business->locations[i]); if( (state==NULL || !strcmp(state, loc_t->state)) && (zip_code==NULL || !strcmp(zip_code, loc_t->zip_code)) ) { // Using state and ZIP_code to filter locations by ret->locations = (struct Location*)realloc( ret->locations, (ret->num_locations+1)*sizeof(struct Location) ); ret->locations[ ret->num_locations ] = *copy_location( loc_t, file ); ret->num_locations ++; } } /* struct Business* bis = ret; printf( "num_locations = %d\n" , bis->num_locations ); for( int i=0 ; i<bis->num_locations ; i++ ) { printf( "location = %s\n", bis->locations[i].address ); }printf( "\n" ); */ return ret; }
int find_cmd_in_path(const char cmd[], size_t path_len, char path[]) { size_t i; size_t paths_count; char **paths; paths = get_paths(&paths_count); for(i = 0; i < paths_count; i++) { char tmp_path[PATH_MAX]; snprintf(tmp_path, sizeof(tmp_path), "%s/%s", paths[i], cmd); /* Need to check for executable, not just a file, as this additionally * checks for path with different executable extensions on Windows. */ if(executable_exists(tmp_path)) { if(path != NULL) { copy_str(path, path_len, tmp_path); } return 0; } } return 1; }
void vle_aucmd_remove(const char event[], const char patterns[]) { int i; int len; char **pats = get_patterns(patterns, &len); for(i = (int)DA_SIZE(autocmds) - 1; i >= 0; --i) { char pat[1U + strlen(autocmds[i].pattern) + 1U]; copy_str(&pat[1], sizeof(pat) - 1U, autocmds[i].pattern); pat[0] = autocmds[i].negated ? '!' : '='; if(event != NULL && strcasecmp(event, autocmds[i].event) != 0) { continue; } if(patterns != NULL && !is_in_string_array(pats, len, pat)) { continue; } free_autocmd_data(&autocmds[i]); DA_REMOVE(autocmds, &autocmds[i]); } free_string_array(pats, len); }
void vle_aucmd_list(const char event[], const char patterns[], vle_aucmd_list_cb cb, void *arg) { size_t i; int len; char **pats = get_patterns(patterns, &len); for(i = 0U; i < DA_SIZE(autocmds); ++i) { char pat[1U + strlen(autocmds[i].pattern) + 1U]; copy_str(&pat[1], sizeof(pat) - 1U, autocmds[i].pattern); pat[0] = autocmds[i].negated ? '!' : '='; if(event != NULL && strcasecmp(event, autocmds[i].event) != 0) { continue; } if(patterns != NULL && !is_in_string_array(pats, len, pat)) { continue; } cb(autocmds[i].event, autocmds[i].pattern, autocmds[i].negated, autocmds[i].action, arg); } free_string_array(pats, len); }
void expand_str(char *buf, int idx) { int len; if ( (signed char) entry[ idx ][ 0 ] >= 0 ) { copy_str(buf, entry[ idx ]); } else { expand_str(buf, idx - 1); len = - (signed char) entry[ idx ][ 0 ]; buf += len; copy_str(buf, &entry[ idx ][ 1 ]); } }