input stringlengths 16 454k | output stringlengths 13 350k | function_name stringlengths 1 100 | repo_name stringlengths 6 43 | category stringclasses 76
values | sample_id stringlengths 22 88 | decompiler stringclasses 1
value | opt_level stringclasses 1
value |
|---|---|---|---|---|---|---|---|
char *permission_strings_matched_str(const string_list *permissions,
mask_t mask) {
mask_t mask_raw;
mask_t mask_extended;
string_builder *sb;
unsigned long v7;
v7 = __readfsqword(0x28u);
sb = sb_create(0);
sb_append_str(sb, "{ ");
while (permissions) {
mask_raw... | static char *
permission_strings_matched_str(const struct string_list *permissions,
mask_t mask) {
struct string_builder *sb = sb_create(0);
sb_append_str(sb, "{ ");
for (; permissions; permissions = permissions->next) {
mask_t mask_raw = 0, mask_extended = 0;
str_to_mask(... | permission_strings_matched_str | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *permmacro_check(const char *a1, const string_list *permissions) {
unsigned short best_coverage;
unsigned short best_extending;
unsigned short coverage;
unsigned short extending;
mask_t mask_raw;
mask_t mask_extended;
mask_t best_mask_raw;
const perm_macro *category;
const char *best_name;
cons... | char *permmacro_check(const char *class,
const struct string_list *permissions) {
if (!initialized) {
visit_all_in_permmacros_map(load_permission_macro);
initialized = true;
}
const struct perm_macro *category;
if (0 == strcmp(class, "dir")) {
category = dir_macros;
} else ... | permmacro_check | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
unsigned int permmacros_map_count() {
if (permmacros_map)
return permmacros_map->hh_permmacros.tbl->num_items;
else
return 0;
} | unsigned int permmacros_map_count() {
return HASH_CNT(hh_permmacros, permmacros_map);
} | permmacros_map_count | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
unsigned short popcount(mask_t mask) {
unsigned short c;
c = 0;
while (mask) {
++c;
mask &= mask - 1;
}
return c;
} | unsigned short popcount(mask_t mask) {
unsigned short c = 0;
for (; mask != 0; mask &= mask - 1) {
c++;
}
return c;
} | popcount | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
ordering_metadata *prepare_ordering_metadata(const check_data *data,
const policy_node *head) {
unsigned int lineno;
const char *section;
ordering_metadata *result;
const policy_node *cur;
size_t count;
section_data *sections;
cur = head->next;
count = 0;
... | struct ordering_metadata *
prepare_ordering_metadata(const struct check_data *data,
const struct policy_node *head) {
const struct policy_node *cur = head->next;
size_t count = 0;
struct section_data *sections = calloc(1, sizeof(struct section_data));
while (cur) {
if (add_section... | prepare_ordering_metadata | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void print_if_verbose(const char *format, ...) {
long v1;
long v2;
long v3;
long v4;
long v5;
va_list args;
unsigned long v7;
long v8;
long v9;
long v10;
long v11;
long v12;
va_start(args, format);
v3 = va_arg(args, _QWORD);
v1 = va_arg(args, _QWORD);
v2 = va_arg(args, _QWORD);
v4 = v... | void print_if_verbose(const char *format, ...) {
if (!verbose_flag) {
return;
}
va_list args;
va_start(args, format);
vprintf(format, args);
va_end(args);
} | print_if_verbose | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
checks *register_checks(char level, const string_list *config_enabled_checks,
const string_list *config_disabled_checks,
const string_list *cl_enabled_checks,
const string_list *cl_disabled_checks,
int only_enabled) {
chec... | struct checks *register_checks(char level,
const struct string_list *config_enabled_checks,
const struct string_list *config_disabled_checks,
const struct string_list *cl_enabled_checks,
const str... | register_checks | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *replace_m4(const char *orig, const string_list *args) {
size_t v3;
int v4;
int after_num_pos;
int ret_count;
size_t len_to_malloc;
const string_list *cur;
const char *orig_pos;
char *ret_pos;
char *ret;
const char *dollar_pos;
unsigned long v13;
v13 = __readfsqword(0x28u);
len_to_malloc... | char *replace_m4(const char *orig, const struct string_list *args) {
size_t len_to_malloc = strlen(orig) + 1;
const struct string_list *cur = args;
while (cur) {
len_to_malloc += strlen(cur->string);
cur = cur->next;
}
char *ret = malloc(len_to_malloc);
*ret = '\0';
const char *orig_pos = orig;
... | replace_m4 | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
string_list *replace_m4_list(const string_list *replace_with,
const string_list *replace_from) {
string_list *replace_froma;
string_list *cur;
string_list *ret;
ret = (string_list *)calloc(1u, 0x18u);
cur = ret;
ret->string = replace_m4(replace_from->string, replace_with);
re... | struct string_list *replace_m4_list(const struct string_list *replace_with,
const struct string_list *replace_from) {
struct string_list *ret = calloc(1, sizeof(struct string_list));
struct string_list *cur = ret;
cur->string = replace_m4(replace_from->string, replace_with);
... | replace_m4_list | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void reset_current_lines() {
unsigned int i;
for (i = 0; i <= 4; ++i) {
free(current_lines[i]);
current_lines[i] = 0;
current_lines_alloc[i] = 0;
}
line_cache_index = 0;
current_line_len = 0;
current_line_sent = 0;
} | void reset_current_lines(void) {
for (unsigned i = 0; i < LINES_TO_CACHE; ++i) {
free(current_lines[i]);
current_lines[i] = NULL;
current_lines_alloc[i] = 0;
}
line_cache_index = 0;
current_line_sent = current_line_len = 0;
} | reset_current_lines | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
selint_error run_all_checks(checks *ck, file_flavor flavor,
policy_file_list *files,
const config_check_data *ccd) {
char *v4;
selint_error res;
policy_file_node *file;
char *copy;
check_data data;
unsigned long v11;
v11 = __readfsqword(0x28u);
fi... | enum selint_error run_all_checks(struct checks *ck, enum file_flavor flavor,
struct policy_file_list *files,
const struct config_check_data *ccd) {
struct policy_file_node *file = files->head;
struct check_data data;
data.flavor = flavor;
whi... | run_all_checks | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
selint_error run_analysis(checks *ck, policy_file_list *te_files,
policy_file_list *if_files,
policy_file_list *fc_files,
policy_file_list *context_te_files,
policy_file_list *context_if_files,
... | enum selint_error run_analysis(struct checks *ck,
struct policy_file_list *te_files,
struct policy_file_list *if_files,
struct policy_file_list *fc_files,
struct policy_file_list *context_te_files... | run_analysis | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
selint_error run_checks_on_one_file(checks *ck, const check_data *data,
const policy_node *head) {
selint_error res;
policy_node cleanup;
unsigned long v7;
v7 = __readfsqword(0x28u);
while (head) {
res = call_checks(ck, data, head);
if (res)
return res;
h... | enum selint_error run_checks_on_one_file(struct checks *ck,
const struct check_data *data,
const struct policy_node *head) {
const struct policy_node *current = head;
while (current) {
enum selint_error res = call_checks(ck, data... | run_checks_on_one_file | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
selint_error save_command(policy_node *cur, const char *comm) {
const char *comma;
const char *commb;
comma = comm;
if (!comm || !cur)
return selint_error_SELINT_BAD_ARG;
while (*comma != 115 && *comma)
++comma;
if (strncmp("selint-", comma, 7u))
return selint_error_SELINT_PARSE_ERROR;
commb ... | enum selint_error save_command(struct policy_node *cur, const char *comm) {
if (comm == NULL || cur == NULL) {
return SELINT_BAD_ARG;
}
while (*comm != 's' && *comm != '\0') {
comm++;
}
if (0 != strncmp("selint-", comm, 7)) {
return SELINT_PARSE_ERROR;
}
comm += strlen("selint-");
if (0 == s... | save_command | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void sb_append_str(string_builder *sb, const char *str) {
size_t v2;
v2 = strlen(str);
sb_append_strn(sb, str, v2);
} | static void sb_append_str(struct string_builder *sb, const char *str) {
sb_append_strn(sb, str, strlen(str));
} | sb_append_str | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void sb_append_strn(string_builder *sb, const char *str, size_t len) {
while (sb->len + len + 1 > sb->cap) {
sb->mem = (char *)realloc(sb->mem, 2 * sb->cap);
sb->cap *= 2LL;
}
memcpy(&sb->mem[sb->len], str, len);
sb->len += len;
sb->mem[sb->len] = 0;
} | static void sb_append_strn(struct string_builder *sb, const char *str,
size_t len) {
while (sb->len + len + 1 > sb->cap) {
sb->mem = realloc(sb->mem, 2 * sb->cap);
sb->cap = 2 * sb->cap;
}
memcpy(sb->mem + sb->len, str, len);
sb->len += len;
sb->mem[sb->len] = '\0';
} | sb_append_strn | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
string_builder *sb_create(size_t init_cap) {
size_t init_capa;
string_builder *ret;
init_capa = init_cap;
if (!init_cap)
init_capa = 32;
ret = (string_builder *)malloc(0x18u);
ret->mem = (char *)malloc(init_capa);
*ret->mem = 0;
ret->len = 0;
ret->cap = init_capa;
return ret;
} | static struct string_builder *sb_create(size_t init_cap) {
if (init_cap == 0) {
init_cap = 32;
}
struct string_builder *ret = malloc(sizeof(struct string_builder));
ret->mem = malloc(sizeof(char) * init_cap);
ret->mem[0] = '\0';
ret->len = 0;
ret->cap = init_cap;
return ret;
} | sb_create | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *sb_decouple_str(string_builder *sb) {
char *ret;
ret = sb->mem;
sb->mem = 0;
sb_destroy(sb);
return ret;
} | static char *sb_decouple_str(struct string_builder *sb) {
char *ret = sb->mem;
sb->mem = NULL;
sb_destroy(sb);
return ret;
} | sb_decouple_str | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void sb_destroy(string_builder *sb) {
if (sb) {
free(sb->mem);
free(sb);
}
} | static void sb_destroy(struct string_builder *sb) {
if (sb == NULL) {
return;
}
free(sb->mem);
free(sb);
} | sb_destroy | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void set_current_module_name(const char *mn) {
if (module_name)
free(module_name);
module_name = strdup(mn);
} | void set_current_module_name(const char *mn) {
if (module_name != NULL) {
free(module_name);
}
module_name = strdup(mn);
} | set_current_module_name | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
string_list *sl_from_str(const char *string) {
string_list *ret;
ret = (string_list *)malloc(0x18u);
ret->string = strdup(string);
ret->next = 0;
ret->has_incorrect_space = 0;
return ret;
} | struct string_list *sl_from_str(const char *string) {
struct string_list *ret = malloc(sizeof(struct string_list));
ret->string = strdup(string);
ret->next = NULL;
ret->has_incorrect_space = 0;
return ret;
} | sl_from_str | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
string_list *sl_from_str_consume(char *string) {
string_list *result;
result = (string_list *)malloc(0x18u);
result->string = string;
result->next = 0;
result->has_incorrect_space = 0;
return result;
} | struct string_list *sl_from_str_consume(char *string) {
struct string_list *ret = malloc(sizeof(struct string_list));
ret->string = string;
ret->next = NULL;
ret->has_incorrect_space = 0;
return ret;
} | sl_from_str_consume | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
string_list *sl_from_strn(const char *string, size_t len) {
string_list *ret;
ret = (string_list *)malloc(0x18u);
ret->string = strndup(string, len);
ret->next = 0;
ret->has_incorrect_space = 0;
return ret;
} | struct string_list *sl_from_strn(const char *string, size_t len) {
struct string_list *ret = malloc(sizeof(struct string_list));
ret->string = strndup(string, len);
ret->next = NULL;
ret->has_incorrect_space = 0;
return ret;
} | sl_from_strn | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
string_list *sl_from_strs(int count, ...) {
const char **v1;
long v2;
string_list *v3;
int i;
string_list *ret;
va_list args;
va_start(args, count);
ret = 0;
for (i = 0; i < count; ++i) {
if (args[0].gp_offset > 0x2F) {
v2 = va_arg(args, _QWORD);
v1 = (const char **)&v2;
} else {
... | struct string_list *sl_from_strs(int count, ...) {
struct string_list *ret = NULL;
va_list args;
va_start(args, count);
for (int i = 0; i < count; ++i) {
ret = concat_string_lists(ret, sl_from_str(va_arg(args, const char *)));
}
va_end(args);
return ret;
} | sl_from_strs | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
bool starts_with_module_prefix(const char *name) {
char *prefix;
size_t i;
char *search_mod;
for (prefix = strchr(name, 95); prefix; prefix = strchr(prefix + 1, 95)) {
search_mod = strndup(name, prefix - name);
if (look_up_in_mods_map(search_mod)) {
LABEL_3:
free(search_mod);
return 1;
... | static bool starts_with_module_prefix(const char *name) {
for (const char *prefix = strchr(name, '_'); prefix;
prefix = strchr(prefix + 1, '_')) {
char *search_mod = strndup(name, (size_t)(prefix - name));
if (look_up_in_mods_map(search_mod)) {
free(search_mod);
return true;
}
for ... | starts_with_module_prefix | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int str_in_sl(const char *str, const string_list *sl) {
const string_list *sla;
sla = sl;
if (!sl)
return 0;
while (sla) {
if (!strcmp(sla->string, str))
return 1;
sla = sla->next;
}
return 0;
} | int str_in_sl(const char *str, const struct string_list *sl) {
if (!sl) {
return 0;
}
while (sl) {
if (0 == strcmp(sl->string, str)) {
return 1;
}
sl = sl->next;
}
return 0;
} | str_in_sl | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void str_to_mask(const char *permission, mask_t *mask_raw,
mask_t *mask_extended) {
size_t i;
const string_list *macro_perms;
for (i = 0; i <= 0x1F; ++i) {
if (!strcmp(permission, pm_ltable_common_file[i].string)) {
*mask_raw |= pm_ltable_common_file[i].flag_raw;
*mask_extended |... | static void str_to_mask(const char *permission, mask_t *mask_raw,
mask_t *mask_extended) {
for (size_t i = 0;
i < (sizeof pm_ltable_common_file / sizeof *pm_ltable_common_file);
++i) {
if (0 == strcmp(permission, pm_ltable_common_file[i].string)) {
*mask_raw |= pm_ltabl... | str_to_mask | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *strip_space(char *str) {
char *end;
while (is_space(*str))
++str;
for (end = str; !is_space(*end); ++end)
;
*end = 0;
return str;
} | static char *strip_space(char *str) {
while (is_space(*str)) {
str++;
}
char *end = str;
while (!is_space(*end)) {
end++;
}
*end = '\0';
return str;
} | strip_space | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *trim_right(char *str) {
size_t len;
for (len = strlen(str);
len && ((*__ctype_b_loc())[(unsigned char)str[len - 1]] & 0x2000) != 0;
--len)
str[len - 1] = 0;
return str;
} | char *trim_right(char *str) {
size_t len = strlen(str);
while (len > 0 && isspace((unsigned char)str[len - 1])) {
str[len - 1] = '\0';
len--;
}
return str;
} | trim_right | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void usage() {
puts("Usage: selint [OPTIONS] FILE [...]\nPerform static code analysis on "
"SELinux policy source.\n");
puts(" -c, --config=CONFIGFILE\tOverride default config with config\n"
"\t\t\t\tspecified on command line. See\n"
"\t\t\t\tCONFIGURATION section for config file syntax.\n"
... | static void usage(void) {
printf("Usage: selint [OPTIONS] FILE [...]\n"
"Perform static code analysis on SELinux policy source.\n\n");
printf(
" -c, --config=CONFIGFILE\tOverride default config with config\n"
"\t\t\t\tspecified on command line. See\n"
"\t\t\t\tCONFIGURATION section for... | usage | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void visit_all_in_permmacros_map(void (*visitor)(const char *,
const string_list *)) {
const sl_hash_elem *next;
const sl_hash_elem *v2;
const sl_hash_elem *cur_sl;
const sl_hash_elem *tmp_sl;
cur_sl = permmacros_map;
if (permmacros_map)
next = (const sl... | void visit_all_in_permmacros_map(
void (*visitor)(const char *name, const struct string_list *permissions)) {
const struct sl_hash_elem *cur_sl, *tmp_sl;
HASH_ITER(hh_permmacros, permmacros_map, cur_sl, tmp_sl) {
visitor(cur_sl->key, cur_sl->val);
}
} | visit_all_in_permmacros_map | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
YY_BUFFER_STATE yy_create_buffer(FILE *file, int size, yyscan_t yyscanner) {
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE)yyalloc_0(0x40u, yyscanner);
if (!b)
yy_fatal_error("out of dynamic memory in yy_create_buffer()", yyscanner);
b->yy_buf_size = size;
b->yy_ch_buf = (char *)yyalloc_0(b->yy_buf_size + 2, y... | YY_BUFFER_STATE yy_create_buffer(FILE *file, int size, yyscan_t yyscanner) {
YY_BUFFER_STATE b;
b = (YY_BUFFER_STATE)yyalloc(sizeof(struct yy_buffer_state), yyscanner);
if (!b)
YY_FATAL_ERROR("out of dynamic memory in yy_create_buffer()");
b->yy_buf_size = size;
b->yy_ch_buf = (char *)yyalloc((yy_size_... | yy_create_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_delete_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner) {
yy_buffer_state *v2;
if (b) {
if (*((_QWORD *)yyscanner + 5))
v2 = *(yy_buffer_state **)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3));
else
v2 = 0;
if (v2 == b)
*(_QWORD *... | void yy_delete_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!b)
return;
if (b == YY_CURRENT_BUFFER)
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE)0;
if (b->yy_is_our_buffer)
yyfree((void *)b->yy_ch_buf, yyscanner);
yyfree((void *)b, yys... | yy_delete_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_fatal_error(const char *msg, yyscan_t yyscanner) {
fprintf(stderr, "%s\n", msg);
exit(2);
} | static void yynoreturn yy_fatal_error(const char *msg, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
(void)yyg;
fprintf(stderr, "%s\n", msg);
exit(YY_EXIT_FAILURE);
} | yy_fatal_error | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_flush_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner) {
yy_buffer_state *v2;
if (b) {
b->yy_n_chars = 0;
*b->yy_ch_buf = 0;
b->yy_ch_buf[1] = 0;
b->yy_buf_pos = b->yy_ch_buf;
b->yy_at_bol = 1;
b->yy_buffer_status = 0;
if (*((_QWORD *)yyscanner + 5))
v2 = *(yy_buffer_state **... | void yy_flush_buffer(YY_BUFFER_STATE b, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!b)
return;
b->yy_n_chars = 0;
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
b->yy_buf_pos = &b->yy_ch_buf[0];
b->yy_at_bol = 1;
b->yy_buffer... | yy_flush_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yy_get_next_buffer(yyscan_t yyscanner) {
char *v2;
char *v3;
long v4;
int i;
int ret_val;
int num_to_read;
int number_to_move;
int yy_c_buf_p_offset;
int new_size_0;
char *dest;
char *source;
size_t _avail;
ssize_t _res;
YY_BUFFER_STATE b;
dest = *(char **)(*(_QWORD *)(*((_QWORD *)yys... | static int yy_get_next_buffer(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
char *source = yyg->yytext_ptr;
int number_to_move, i;
int ret_val;
if (yyg->yy_c_buf_p >
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1... | yy_get_next_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
yy_state_type yy_get_previous_state(yyscan_t yyscanner) {
YY_CHAR v1;
YY_CHAR yy_c;
int yy_current_state;
char *yy_cp;
yy_current_state = *((_DWORD *)yyscanner + 19);
for (yy_cp = (char *)*((_QWORD *)yyscanner + 16);
(unsigned long)yy_cp < *((_QWORD *)yyscanner + 8); ++yy_cp) {
if (*yy_cp)
... | static yy_state_type yy_get_previous_state(yyscan_t yyscanner) {
yy_state_type yy_current_state;
char *yy_cp;
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yy_current_state = yyg->yy_start;
for (yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p;
++yy_cp) {
YY_CHAR yy_c = (*yy_... | yy_get_previous_state | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_init_buffer(YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner) {
yy_buffer_state *v3;
int v4;
int v5;
int oerrno;
oerrno = *__errno_location();
yy_flush_buffer(b, yyscanner);
b->yy_input_file = file;
b->yy_fill_buffer = 1;
if (*((_QWORD *)yyscanner + 5))
v3 = *(yy_buffer_state **)(*((_QWO... | static void yy_init_buffer(YY_BUFFER_STATE b, FILE *file, yyscan_t yyscanner)
{
int oerrno = errno;
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yy_flush_buffer(b, yyscanner);
b->yy_input_file = file;
b->yy_fill_buffer = 1;
if (b != YY_CURRENT_BUFFER) {
b->yy_bs_lineno = 1;
b->yy_bs_colu... | yy_init_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yy_init_globals(yyscan_t yyscanner) {
*((_QWORD *)yyscanner + 5) = 0;
*((_QWORD *)yyscanner + 3) = 0;
*((_QWORD *)yyscanner + 4) = 0;
*((_QWORD *)yyscanner + 8) = 0;
*((_DWORD *)yyscanner + 18) = 0;
*((_DWORD *)yyscanner + 19) = 0;
*((_DWORD *)yyscanner + 21) = 0;
*((_DWORD *)yyscanner + 22) = 0;
... | static int yy_init_globals(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yyg->yy_buffer_stack = NULL;
yyg->yy_buffer_stack_top = 0;
yyg->yy_buffer_stack_max = 0;
yyg->yy_c_buf_p = NULL;
yyg->yy_init = 0;
yyg->yy_start = 0;
yyg->yy_start_stack_ptr = 0;
yyg->yy_start_stack... | yy_init_globals | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_load_buffer_state(yyscan_t yyscanner) {
*((_DWORD *)yyscanner + 13) =
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)) +
28LL);
*((_QWORD *)yyscanner + 8) =
*(_QWORD *)(*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
... | static void yy_load_buffer_state(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
yyg->yy_hold_char = *yyg... | yy_load_buffer_state | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_reduce_print(yy_state_t *yyssp, YYSTYPE *yyvsp, location *yylsp,
int yyrule, yyscan_t scanner) {
int yyi;
int yynrhs;
yynrhs = yyr2[yyrule];
fprintf(stderr, "Reducing stack by rule %d (line %d):\n", yyrule - 1,
yyrline[yyrule]);
for (yyi = 0; yyi < yynrhs; ++yyi) {
... | while (0)
static void yy_reduce_print(yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
int yyrule, yyscan_t scanner) {
int yylno = yyrline[yyrule];
int yynrhs = yyr2[yyrule];
int yyi;
YYFPRINTF(stderr, "Reducing stack by rule %d (line %d):\n", yyrule - 1,
... | yy_reduce_print | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size, yyscan_t yyscanner) {
YY_BUFFER_STATE b;
if (size <= 1 || base[size - 2] || base[size - 1])
return 0;
b = (YY_BUFFER_STATE)yyalloc_0(0x40u, yyscanner);
if (!b)
yy_fatal_error("out of dynamic memory in yy_scan_buffer()", yyscanner);
b->yy_buf_... | YY_BUFFER_STATE yy_scan_buffer(char *base, yy_size_t size, yyscan_t yyscanner) {
YY_BUFFER_STATE b;
if (size < 2 || base[size - 2] != YY_END_OF_BUFFER_CHAR ||
base[size - 1] != YY_END_OF_BUFFER_CHAR)
return NULL;
b = (YY_BUFFER_STATE)yyalloc(sizeof(struct yy_buffer_state), yyscanner);
if (!b)
Y... | yy_scan_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
YY_BUFFER_STATE yy_scan_bytes(const char *yybytes, int _yybytes_len,
yyscan_t yyscanner) {
char *v3;
int i;
char *buf;
YY_BUFFER_STATE b;
buf = (char *)yyalloc_0(_yybytes_len + 2, yyscanner);
if (!buf)
yy_fatal_error("out of dynamic memory in yy_scan_bytes()", yyscanner);
... | YY_BUFFER_STATE yy_scan_bytes(const char *yybytes, int _yybytes_len,
yyscan_t yyscanner) {
YY_BUFFER_STATE b;
char *buf;
yy_size_t n;
int i;
n = (yy_size_t)(_yybytes_len + 2);
buf = (char *)yyalloc(n, yyscanner);
if (!buf)
YY_FATAL_ERROR("out of dynamic memory in yy_scan... | yy_scan_bytes | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
YY_BUFFER_STATE yy_scan_string(const char *yystr, yyscan_t yyscanner) {
int v2;
v2 = strlen(yystr);
return yy_scan_bytes(yystr, v2, yyscanner);
} | YY_BUFFER_STATE yy_scan_string(const char *yystr, yyscan_t yyscanner) {
return yy_scan_bytes(yystr, (int)strlen(yystr), yyscanner);
} | yy_scan_string | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_stack_print(yy_state_t *yybottom, yy_state_t *yytop) {
fwrite("Stack now", 1u, 9u, stderr);
while (yybottom <= yytop)
fprintf(stderr, " %d", *yybottom++);
fputc(10, stderr);
} | static void yy_stack_print(yy_state_t *yybottom, yy_state_t *yytop) {
YYFPRINTF(stderr, "Stack now");
for (; yybottom <= yytop; yybottom++) {
int yybot = *yybottom;
YYFPRINTF(stderr, " %d", yybot);
}
YYFPRINTF(stderr, "\n");
} | yy_stack_print | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner) {
yy_buffer_state *v2;
yyensure_buffer_stack(yyscanner);
if (*((_QWORD *)yyscanner + 5))
v2 = *(yy_buffer_state **)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3));
else
v2 = 0;
if (... | void yy_switch_to_buffer(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yyensure_buffer_stack(yyscanner);
if (YY_CURRENT_BUFFER == new_buffer)
return;
if (YY_CURRENT_BUFFER) {
*yyg->yy_c_buf_p = yyg->yy_hold_char;
YY_CURRENT_BUFFER_LVALUE->y... | yy_switch_to_buffer | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_symbol_print(FILE *yyo, int yytype, const YYSTYPE *const yyvaluep,
const location *const yylocationp, yyscan_t scanner) {
const char *v5;
if (yytype > 88)
v5 = "nterm";
else
v5 = "token";
fprintf(yyo, "%s %s (", v5, yytname[yytype]);
fwrite(": ", 1u, 2u, yyo);
yy_symbol... | static void yy_symbol_print(FILE *yyo, int yytype,
YYSTYPE const *const yyvaluep,
YYLTYPE const *const yylocationp,
yyscan_t scanner) {
YYFPRINTF(yyo, "%s %s (", yytype < YYNTOKENS ? "token" : "nterm",
yytname[yytype]);
... | yy_symbol_print | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yy_symbol_value_print(FILE *yyo, int yytype, const YYSTYPE *const yyvaluep,
const location *const yylocationp,
yyscan_t scanner) {
;
} | while (0)
static void yy_symbol_value_print(FILE *yyo, int yytype,
YYSTYPE const *const yyvaluep,
YYLTYPE const *const yylocationp,
yyscan_t scanner) {
FILE *yyoutput = yyo;
YYUSE(yyoutput);
YYUSE(... | yy_symbol_value_print | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state,
yyscan_t yyscanner) {
int yy_current_statea;
yy_state_type yy_current_stateb;
YY_CHAR yy_c;
char *yy_cp;
yy_current_statea = yy_current_state;
yy_cp = (char *)*((_QWORD *)yyscanner + 8);
yy_c = 1;
if (yy_accep... | static yy_state_type yy_try_NUL_trans(yy_state_type yy_current_state,
yyscan_t yyscanner) {
int yy_is_jam;
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
char *yy_cp = yyg->yy_c_buf_p;
YY_CHAR yy_c = 1;
if (yy_accept[yy_current_state]) {
yyg->yy_last_accepting_... | yy_try_NUL_trans | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep,
location *yylocationp, yyscan_t scanner) {
const char *yymsga;
yymsga = yymsg;
if (!yymsg)
yymsga = "Deleting";
if (yydebug) {
fprintf(stderr, "%s ", yymsga);
yy_symbol_print(stderr, yytype, yyvaluep, yylocationp, sca... | static void yydestruct(const char *yymsg, int yytype, YYSTYPE *yyvaluep,
YYLTYPE *yylocationp, yyscan_t scanner) {
YYUSE(yyvaluep);
YYUSE(yylocationp);
YYUSE(scanner);
if (!yymsg)
yymsg = "Deleting";
YY_SYMBOL_PRINT(yymsg, yytype, yyvaluep, yylocationp);
YY_IGNORE_MAYBE_UNINITIAL... | yydestruct | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyensure_buffer_stack(yyscan_t yyscanner) {
yy_size_t num_to_alloc;
if (*((_QWORD *)yyscanner + 5)) {
if (*((_QWORD *)yyscanner + 3) >=
(unsigned long)(*((_QWORD *)yyscanner + 4) - 1LL)) {
num_to_alloc = *((_QWORD *)yyscanner + 4) + 8LL;
*((_QWORD *)yyscanner + 5) =
yyrealloc... | static void yyensure_buffer_stack(yyscan_t yyscanner) {
yy_size_t num_to_alloc;
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!yyg->yy_buffer_stack) {
num_to_alloc = 1;
yyg->yy_buffer_stack = (struct yy_buffer_state **)yyalloc(
num_to_alloc * sizeof(struct yy_buffer_state *), yyscanne... | yyensure_buffer_stack | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyerror(const location *locp, yyscan_t scanner, const char *msg) {
unsigned int first_column;
unsigned int last_column;
int v5;
const char *v6;
const char *v7;
const char *v8;
const char *v9;
const char *v10;
const char *v11;
bool shortened;
unsigned int lines_to_print;
unsigned int k;
un... | static void yyerror(const YYLTYPE *locp,
__attribute__((unused)) yyscan_t scanner, char const *msg) {
{
struct check_result *res =
make_check_result('F', F_ID_POLICY_SYNTAX, "%s", msg);
res->lineno = locp->first_line;
struct check_data data;
data.mod_name = get_current_mo... | yyerror | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyfree(void *ptr, yyscan_t yyscanner) { free(ptr); } | void yyfree(void *ptr, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
(void)yyg;
free((char *)ptr);
} | yyfree | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yyget_column(yyscan_t yyscanner) {
if (*((_QWORD *)yyscanner + 5) &&
*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)))
return *(_DWORD *)(*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)) +
... | int yyget_column(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!YY_CURRENT_BUFFER)
return 0;
return yycolumn;
} | yyget_column | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yyget_debug(yyscan_t yyscanner) { return *((_DWORD *)yyscanner + 31); } | int yyget_debug(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yy_flex_debug;
} | yyget_debug | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void *yyget_extra(yyscan_t yyscanner) { return *(void **)yyscanner; } | while (0)
YY_EXTRA_TYPE yyget_extra(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yyextra;
} | yyget_extra | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
FILE *yyget_in(yyscan_t yyscanner) {
return (FILE *)*((_QWORD *)yyscanner + 1);
} | FILE *yyget_in(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yyin;
} | yyget_in | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yyget_leng(yyscan_t yyscanner) { return *((_DWORD *)yyscanner + 14); } | int yyget_leng(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yyleng;
} | yyget_leng | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yyget_lineno(yyscan_t yyscanner) {
if (*((_QWORD *)yyscanner + 5) &&
*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)))
return *(_DWORD *)(*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)) +
... | int yyget_lineno(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!YY_CURRENT_BUFFER)
return 0;
return yylineno;
} | yyget_lineno | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
YYLTYPE *yyget_lloc(yyscan_t yyscanner) {
return (YYLTYPE *)*((_QWORD *)yyscanner + 19);
} | YYLTYPE *yyget_lloc(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yylloc;
} | yyget_lloc | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
YYSTYPE *yyget_lval(yyscan_t yyscanner) {
return (YYSTYPE *)*((_QWORD *)yyscanner + 18);
} | YYSTYPE *yyget_lval(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yylval;
} | yyget_lval | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
FILE *yyget_out(yyscan_t yyscanner) {
return (FILE *)*((_QWORD *)yyscanner + 2);
} | FILE *yyget_out(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yyout;
} | yyget_out | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *yyget_text(yyscan_t yyscanner) {
return (char *)*((_QWORD *)yyscanner + 16);
} | char *yyget_text(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
return yytext;
} | yyget_text | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yylex_destroy(yyscan_t yyscanner) {
yy_buffer_state *v1;
while (*((_QWORD *)yyscanner + 5) &&
*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3))) {
if (*((_QWORD *)yyscanner + 5))
v1 = *(yy_buffer_state **)(*((_QWORD *)yyscanner + 5) +
... | int yylex_destroy(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
while (YY_CURRENT_BUFFER) {
yy_delete_buffer(YY_CURRENT_BUFFER, yyscanner);
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state(yyscanner);
}
yyfree(yyg->yy_buffer_stack, yyscanner);
yyg->yy_buffer_stack... | yylex_destroy | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yylex_init(yyscan_t *ptr_yy_globals) {
if (ptr_yy_globals) {
*ptr_yy_globals = yyalloc_0(0xA0u, 0);
if (*ptr_yy_globals) {
memset(*ptr_yy_globals, 0, 0xA0u);
return yy_init_globals(*ptr_yy_globals);
} else {
*__errno_location() = 12;
return 1;
}
} else {
*__errno_loca... | int yylex_init(yyscan_t *ptr_yy_globals) {
if (ptr_yy_globals == NULL) {
errno = EINVAL;
return 1;
}
*ptr_yy_globals = (yyscan_t)yyalloc(sizeof(struct yyguts_t), NULL);
if (*ptr_yy_globals == NULL) {
errno = ENOMEM;
return 1;
}
memset(*ptr_yy_globals, 0x00, sizeof(struct yyguts_t));
re... | yylex_init | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yylex_init_extra(void *yy_user_defined, yyscan_t *ptr_yy_globals) {
yyguts_t dummy_yyguts;
unsigned long v4;
v4 = __readfsqword(0x28u);
yyset_extra(yy_user_defined, &dummy_yyguts);
if (ptr_yy_globals) {
*ptr_yy_globals = yyalloc_0(0xA0u, &dummy_yyguts);
if (*ptr_yy_globals) {
memset(*ptr_yy... | int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined, yyscan_t *ptr_yy_globals) {
struct yyguts_t dummy_yyguts;
yyset_extra(yy_user_defined, &dummy_yyguts);
if (ptr_yy_globals == NULL) {
errno = EINVAL;
return 1;
}
*ptr_yy_globals = (yyscan_t)yyalloc(sizeof(struct yyguts_t), &dummy_yyguts);
if (*p... | yylex_init_extra | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yyparse(yyscan_t scanner) {
location *v1;
long v2;
long v3;
long v4;
long v5;
int v6;
short v7;
location *v8;
long v9;
yytype_int16 v10;
string_list *v11;
size_t v12;
string_list *v13;
size_t v14;
size_t v15;
size_t v16;
size_t v17;
location *v18;
long v19;
yy_state_fast_t v2... | int yyparse(yyscan_t scanner) {
int yychar;
YY_INITIAL_VALUE(static YYSTYPE yyval_default;)
YYSTYPE yylval YY_INITIAL_VALUE(= yyval_default);
static YYLTYPE yyloc_default
#if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
= {1, 1, 1, 1}
#endif
;
YYLTYPE yylloc = yyloc_default;
int yynerrs;
... | yyparse | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
policy_node *yyparse_wrapper(FILE *filefd, const char *filename,
node_flavor expected_flavor) {
int ret;
yyscan_t scanner;
policy_node *ast;
unsigned long v8;
v8 = __readfsqword(0x28u);
ast = (policy_node *)calloc(1u, 0x40u);
expected_node_flavor = expected_flavor;
ast->fla... | struct policy_node *yyparse_wrapper(FILE *filefd, const char *filename,
enum node_flavor expected_flavor) {
struct policy_node *ast = calloc(1, sizeof(struct policy_node));
ast->flavor = expected_node_flavor = expected_flavor;
yyscan_t scanner;
yylex_init(&scanner);
yyresta... | yyparse_wrapper | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yypop_buffer_state(yyscan_t yyscanner) {
yy_buffer_state *v1;
if (*((_QWORD *)yyscanner + 5) &&
*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3))) {
if (*((_QWORD *)yyscanner + 5))
v1 = *(yy_buffer_state **)(*((_QWORD *)yyscanner + 5) +
... | void yypop_buffer_state(yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!YY_CURRENT_BUFFER)
return;
yy_delete_buffer(YY_CURRENT_BUFFER, yyscanner);
YY_CURRENT_BUFFER_LVALUE = NULL;
if (yyg->yy_buffer_stack_top > 0)
--yyg->yy_buffer_stack_top;
if (YY_CURRENT_BUFFER) {... | yypop_buffer_state | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yypush_buffer_state(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner) {
if (new_buffer) {
yyensure_buffer_stack(yyscanner);
if (*((_QWORD *)yyscanner + 5) &&
*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3))) {
**((_BYTE **)yyscanner + 8) = *((_BYT... | void yypush_buffer_state(YY_BUFFER_STATE new_buffer, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (new_buffer == NULL)
return;
yyensure_buffer_stack(yyscanner);
if (YY_CURRENT_BUFFER) {
*yyg->yy_c_buf_p = yyg->yy_hold_char;
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = y... | yypush_buffer_state | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void *yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner) {
return realloc(ptr, size);
} | void *yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
(void)yyg;
return realloc(ptr, size);
} | yyrealloc | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyrestart(FILE *input_file, yyscan_t yyscanner) {
YY_BUFFER_STATE *v2;
yy_buffer_state *v3;
if (!*((_QWORD *)yyscanner + 5) ||
!*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3))) {
yyensure_buffer_stack(yyscanner);
v2 = (YY_BUFFER_STATE *)(*((_QWORD ... | void yyrestart(FILE *input_file, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!YY_CURRENT_BUFFER) {
yyensure_buffer_stack(yyscanner);
YY_CURRENT_BUFFER_LVALUE = yy_create_buffer(yyin, YY_BUF_SIZE, yyscanner);
}
yy_init_buffer(YY_CURRENT_BUFFER, input_file, yyscanner);... | yyrestart | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_column(int _column_no, yyscan_t yyscanner) {
if (!*((_QWORD *)yyscanner + 5) ||
!*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)))
yy_fatal_error("yyset_column called with no buffer", yyscanner);
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
... | void yyset_column(int _column_no, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!YY_CURRENT_BUFFER)
YY_FATAL_ERROR("yyset_column called with no buffer");
yycolumn = _column_no;
} | yyset_column | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_debug(int _bdebug, yyscan_t yyscanner) {
*((_DWORD *)yyscanner + 31) = _bdebug;
} | void yyset_debug(int _bdebug, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yy_flex_debug = _bdebug;
} | yyset_debug | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_extra(void *user_defined, yyscan_t yyscanner) {
*(_QWORD *)yyscanner = user_defined;
} | void yyset_extra(YY_EXTRA_TYPE user_defined, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yyextra = user_defined;
} | yyset_extra | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_in(FILE *_in_str, yyscan_t yyscanner) {
*((_QWORD *)yyscanner + 1) = _in_str;
} | void yyset_in(FILE *_in_str, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yyin = _in_str;
} | yyset_in | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_lineno(int _line_number, yyscan_t yyscanner) {
if (!*((_QWORD *)yyscanner + 5) ||
!*(_QWORD *)(*((_QWORD *)yyscanner + 5) +
8LL * *((_QWORD *)yyscanner + 3)))
yy_fatal_error("yyset_lineno called with no buffer", yyscanner);
*(_DWORD *)(*(_QWORD *)(*((_QWORD *)yyscanner + 5) +... | void yyset_lineno(int _line_number, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
if (!YY_CURRENT_BUFFER)
YY_FATAL_ERROR("yyset_lineno called with no buffer");
yylineno = _line_number;
} | yyset_lineno | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_lloc(YYLTYPE *yylloc_param, yyscan_t yyscanner) {
*((_QWORD *)yyscanner + 19) = yylloc_param;
} | void yyset_lloc(YYLTYPE *yylloc_param, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yylloc = yylloc_param;
} | yyset_lloc | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_lval(YYSTYPE *yylval_param, yyscan_t yyscanner) {
*((_QWORD *)yyscanner + 18) = yylval_param;
} | void yyset_lval(YYSTYPE *yylval_param, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yylval = yylval_param;
} | yyset_lval | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
void yyset_out(FILE *_out_str, yyscan_t yyscanner) {
*((_QWORD *)yyscanner + 2) = _out_str;
} | void yyset_out(FILE *_out_str, yyscan_t yyscanner) {
struct yyguts_t *yyg = (struct yyguts_t *)yyscanner;
yyout = _out_str;
} | yyset_out | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
char *yystpcpy(char *yydest, const char *yysrc) {
const char *v2;
char *v3;
do {
v2 = yysrc++;
v3 = yydest++;
*v3 = *v2;
} while (*v3);
return yydest - 1;
} | static char *yystpcpy(char *yydest, const char *yysrc) {
char *yyd = yydest;
const char *yys = yysrc;
while ((*yyd++ = *yys++) != '\0')
continue;
return yyd - 1;
} | yystpcpy | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int yysyntax_error(long *yymsg_alloc, char **yymsg, yy_state_t *yyssp,
int yytoken) {
int v4;
int v5;
int v6;
int v8;
int yycount;
int yyx;
int yyi;
int yyn;
int yyxbegin;
int yyxend;
const char *yyformat;
long yysize;
char *yyp;
long yysize0;
long yysize1;
signed long... | static int yysyntax_error(YYPTRDIFF_T *yymsg_alloc, char **yymsg,
yy_state_t *yyssp, int yytoken) {
enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
const char *yyformat = YY_NULLPTR;
char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
int yycount = 0;
YYPTRDIFF_T yysize = 0;
if (yytok... | yysyntax_error | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
long yytnamerr(char *yyres, const char *yystr) {
int v2;
long yyn;
char *yyp;
if (*yystr != 34) {
LABEL_17:
if (yyres)
return yystpcpy(yyres, yystr) - yyres;
else
return strlen(yystr);
}
yyn = 0;
yyp = (char *)yystr;
while (1) {
v2 = *++yyp;
if (v2 != 92)
break;
... | static YYPTRDIFF_T yytnamerr(char *yyres, const char *yystr) {
if (*yystr == '"') {
YYPTRDIFF_T yyn = 0;
char const *yyp = yystr;
for (;;)
switch (*++yyp) {
case '\'':
case ',':
goto do_not_strip_quotes;
case '\\':
if (*++yyp != '\\')
goto do_not_strip_q... | yytnamerr | selint-1.2.0 | app-admin | O0/app-admin/selint-1.2.0/selint | ida | O0 |
int am_in_initrd() {
const char *v1;
int ret;
FILE *mi;
char buffer[4104];
unsigned long v5;
v5 = __readfsqword(0x28u);
ret = 0;
mi = fopen64("/lib/bootchart/tmpfs/proc/self/mountinfo", "r");
if (!mi)
return 0;
while (fgets(buffer, 4096, mi)) {
if (!strncmp(buffer, "1 1 ", 4u)) {
ret ... | static int am_in_initrd(void) {
FILE *mi;
int ret = 0;
char buffer[4096];
mi = fopen(PROC_PATH "/self/mountinfo", "r");
if (!mi)
return ret;
while (fgets(buffer, 4096, mi)) {
if (!strncmp(buffer, "1 1 ", 4)) {
ret = 1;
break;
}
}
fclose(mi);
log("bootchart-collector run %ss... | am_in_initrd | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void arguments_free(Arguments *args) {
if (args->dump_path)
free(args->dump_path);
} | void arguments_free(Arguments *args) {
if (args->dump_path)
free(args->dump_path);
} | arguments_free | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void arguments_parse(Arguments *args, int argc, char **argv) {
int i;
char *param;
for (i = 1; i < argc; ++i) {
if (argv[i]) {
if (i < argc - 1) {
param = argv[i + 1];
if (!strcmp(argv[i], "--usleep")) {
args->usleep_time = strtoul(param, 0, 0);
} else if (!strcmp(argv... | void arguments_parse(Arguments *args, int argc, char **argv) {
int i;
for (i = 1; i < argc; i++) {
if (!argv[i])
continue;
if (i < argc - 1) {
const char *param = argv[i + 1];
if (!strcmp(argv[i], "--usleep"))
args->usleep_time = strtoul(param, NULL, 0);
else if (!strcmp(... | arguments_parse | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void arguments_set_defaults(Arguments *args) {
memset(args, 0, sizeof(Arguments));
} | void arguments_set_defaults(Arguments *args) {
memset(args, 0, sizeof(Arguments));
} | arguments_set_defaults | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
int bootchart_find_running_pid(Arguments *opt_args) {
int pid;
int harmless;
int i;
int argc;
int len;
int lena;
int p;
Arguments *args;
DIR *proc;
dirent *ent;
FILE *argf;
Arguments sargs;
char *argv[128];
char exe_path[1024];
char link_target[1024];
char abuffer[4104];
unsigned long ... | int bootchart_find_running_pid(Arguments *opt_args) {
DIR *proc;
struct dirent *ent;
int pid = -1;
char exe_path[1024];
Arguments sargs, *args;
if (opt_args) {
args = opt_args;
} else {
args = &sargs;
arguments_set_defaults(args);
}
proc = opendir(PROC_PATH);
while ((ent = readdir(proc... | bootchart_find_running_pid | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void buffer_file_append(BufferFile *file, const char *str, size_t len) {
unsigned long v3;
unsigned long to_write;
do {
v3 = 131000 - file->cur->length;
if (len <= v3)
v3 = len;
to_write = v3;
memcpy(&file->cur->data[file->cur->length], str, v3);
str += to_write;
len -= to_write;
... | void buffer_file_append(BufferFile *file, const char *str, size_t len) {
do {
unsigned long to_write = MIN(CHUNK_PAYLOAD - file->cur->length, len);
memcpy(file->cur->data + file->cur->length, str, to_write);
str += to_write;
len -= to_write;
file->cur->length += to_write;
if (file->cur->length... | buffer_file_append | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void buffer_file_dump(BufferFile *file, int input_fd) {
long to_read;
while (1) {
to_read = read(input_fd, &file->cur->data[file->cur->length],
131000 - file->cur->length);
if (to_read < 0)
break;
if (!to_read)
return;
file->cur->length += to_read;
if (file->cur->... | void buffer_file_dump(BufferFile *file, int input_fd) {
for (;;) {
ssize_t to_read = CHUNK_PAYLOAD - file->cur->length;
to_read = read(input_fd, file->cur->data + file->cur->length, to_read);
if (to_read < 0) {
perror("read error");
break;
} else if (to_read == 0) {
break;
}
... | buffer_file_dump | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void buffer_file_dump_frame_with_timestamp(BufferFile *file, int input_fd,
const char *uptime,
size_t uptimelen) {
buffer_file_append(file, uptime, uptimelen);
lseek64(input_fd, 0, 0);
buffer_file_dump(file, input_fd);
buffer_... | void buffer_file_dump_frame_with_timestamp(BufferFile *file, int input_fd,
const char *uptime,
size_t uptimelen) {
buffer_file_append(file, uptime, uptimelen);
lseek(input_fd, SEEK_SET, 0);
buffer_file_dump(file, input_fd);
... | buffer_file_dump_frame_with_timestamp | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
BufferFile *buffer_file_new(StackMap *sm, const char *output_fname) {
BufferFile *b;
b = (BufferFile *)calloc(0x18u, 1u);
b->sm = sm;
b->dest = output_fname;
b->cur = chunk_alloc(b->sm, b->dest);
return b;
} | BufferFile *buffer_file_new(StackMap *sm, const char *output_fname) {
BufferFile *b = calloc(sizeof(BufferFile), 1);
b->sm = sm;
b->dest = output_fname;
b->cur = chunk_alloc(b->sm, b->dest);
return b;
} | buffer_file_new | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
int buffers_extract_and_dump(const char *output_path, Arguments *remote_args) {
const char *v3;
int i;
int ret;
int pid;
DumpState *state;
ret = 0;
chdir(output_path);
pid = bootchart_find_running_pid(remote_args);
if (pid >= 0) {
fprintf(stderr, "[bootchart] Extracting profile data from pid %d\n... | int buffers_extract_and_dump(const char *output_path, Arguments *remote_args) {
int i, pid, ret = 0;
DumpState *state;
assert(!chdir(output_path));
pid = bootchart_find_running_pid(remote_args);
if (pid < 0) {
log("Failed to find the collector's pid\n");
return 1;
}
log("Extracting profile data ... | buffers_extract_and_dump | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
int chroot_into_dev() {
int *v0;
char *v1;
int *v3;
char *v4;
int *v5;
char *v6;
fwrite("[bootchart] bootchart-collector - migrating into /dev/\n", 1u, 0x37u,
stderr);
if (!mkdir("/dev/.bootchart", 0x1FFu) || *__errno_location() == 17) {
if (mount("/lib/bootchart/tmpfs", "/dev/.bootchart",... | static int chroot_into_dev(void) {
log("bootchart-collector - migrating into /dev/\n");
if (mkdir(MOVE_DEV_PATH, 0777)) {
if (errno != EEXIST) {
log("bootchart-collector - failed to create " MOVE_DEV_PATH
" move mount-point: '%s'\n",
strerror(errno));
return 1;
}
}
if (m... | chroot_into_dev | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
Chunk *chunk_alloc(StackMap *sm, const char *dest) {
int max_chunk;
Chunk *c;
pthread_mutex_lock(&guard_1);
if (sm->max_chunk == 1024) {
if (!overflowed_0) {
fwrite("[bootchart] bootchart-collector - internal buffer overflow! did "
"you set hz too high, or is your boot time too long ?\n"... | static Chunk *chunk_alloc(StackMap *sm, const char *dest) {
Chunk *c;
static pthread_mutex_t guard = PTHREAD_MUTEX_INITIALIZER;
pthread_mutex_lock(&guard);
if (sm->max_chunk == sizeof(sm->chunks) / sizeof(sm->chunks[0])) {
static int overflowed = 0;
if (!overflowed) {
log("bootchart-collector - ... | chunk_alloc | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
int clean_enviroment() {
int ret;
ret = 0;
if (umount2("/lib/bootchart/tmpfs/proc", 2) < 0) {
perror("umount /lib/bootchart/tmpfs/proc");
ret = 1;
}
if (unlink("/lib/bootchart/tmpfs/kmsg") < 0) {
perror("unlinking /lib/bootchart/tmpfs/kmsg");
ret = 1;
}
if (umount2("/lib/bootchart/tmpfs",... | static int clean_enviroment(void) {
int ret = 0;
if (umount2(PROC_PATH, MNT_DETACH) < 0) {
perror("umount " PROC_PATH);
ret = 1;
}
if (unlink(TMPFS_PATH "/kmsg") < 0) {
perror("unlinking " TMPFS_PATH "/kmsg");
ret = 1;
}
if (umount2(TMPFS_PATH, MNT_DETACH) < 0) {
perror("umount " TMPF... | clean_enviroment | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void cleanup_dev() {
if (!access("/dev/.bootchart/kmsg", 2)) {
umount2("/dev/.bootchart/lib/bootchart/tmpfs/proc", 2);
umount2("/dev/.bootchart", 2);
rmdir("/dev/.bootchart");
}
} | static void cleanup_dev(void) {
if (!access(MOVE_DEV_PATH "/kmsg", W_OK)) {
umount2(MOVE_DEV_PATH PROC_PATH, MNT_DETACH);
umount2(MOVE_DEV_PATH, MNT_DETACH);
rmdir(MOVE_DEV_PATH);
}
} | cleanup_dev | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
int close_pid(DumpState *s, int avoid_kill) {
int *v2;
char *v3;
int pid;
if (!avoid_kill && kill(s->pid, 15)) {
v2 = __errno_location();
v3 = strerror(*v2);
fprintf(stderr, "[bootchart] failed to terminate pid %d: %s\n", s->pid, v3);
}
ptrace(__ptrace_request_PTRACE_DETACH, (unsigned int)s->pi... | static int close_pid(DumpState *s, int avoid_kill) {
int pid;
if (!avoid_kill && kill(s->pid, SIGTERM))
log("failed to terminate pid %d: %s\n", s->pid, strerror(errno));
ptrace(PTRACE_DETACH, s->pid, 0, 0);
close(s->mem);
pid = s->pid;
free(s);
return pid;
} | close_pid | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void close_wait_pid(DumpState *s, int avoid_kill) {
int i;
int pid;
char buffer[1032];
unsigned long v5;
v5 = __readfsqword(0x28u);
pid = close_pid(s, avoid_kill);
for (i = 0; i <= 99; ++i) {
sprintf(buffer, "/lib/bootchart/tmpfs/proc/%d/cmdline", pid);
if (access(buffer, 4))
break;
usl... | static void close_wait_pid(DumpState *s, int avoid_kill) {
int i, pid;
pid = close_pid(s, avoid_kill);
for (i = 0; i < 100; i++) {
char buffer[1024];
sprintf(buffer, PROC_PATH "/%d/cmdline", pid);
if (access(buffer, R_OK))
break;
usleep(10 * 1000);
}
} | close_wait_pid | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
void dump_buffers(DumpState *s) {
int v1;
long v2;
int i;
int max_chunk;
size_t bytes_dumped;
FILE *output;
char buffer[131072];
unsigned long v8;
v8 = __readfsqword(0x28u);
bytes_dumped = 0;
if (s->map.max_chunk > 0x3FEu)
v1 = 1023;
else
v1 = s->map.max_chunk;
max_chunk = v1;
fprin... | static void dump_buffers(DumpState *s) {
int i, max_chunk;
size_t bytes_dumped = 0;
max_chunk = MIN(s->map.max_chunk,
sizeof(s->map.chunks) / sizeof(s->map.chunks[0]) - 1);
log("reading %d chunks (of %d) ...\n", max_chunk, s->map.max_chunk);
for (i = 0; i < max_chunk; i++) {
FILE *outp... | dump_buffers | bootchart2-0.14.9-r1 | app-benchmarks | O0/app-benchmarks/bootchart2-0.14.9-r1/bootchart-collector | ida | O0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.