id
stringlengths 8
32
| source_file
stringclasses 51
values | original_function_name
stringlengths 2
66
| anonymized_function_name
stringlengths 2
62
| function_code
stringlengths 15
623
| context
listlengths 0
12
| has_bug
bool 2
classes | bug_types
listlengths 0
3
| bug_line_offsets
listlengths 0
3
| bug_absolute_lines
listlengths 0
3
| bug_severities
listlengths 0
3
| bug_traces
listlengths 0
3
| category
stringclasses 7
values | requires_interprocedural
bool 2
classes | start_line
int32 8
932
| end_line
int32 8
936
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
abduce_001
|
pulse/abduce.c
|
const_local_no_abduce
|
const_local_no_abduce
|
int const_local_no_abduce(int* p) {
external_func(&p);
return p ? *p : 0;
// We shouldn't get a stack address escape warning here
}
|
[
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 12
| 16
|
abduce_002
|
pulse/abduce.c
|
set_ptr
|
set_ptr
|
void set_ptr(int* ptr, int val) { *ptr = val; }
|
[
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 18
| 18
|
abduce_003
|
pulse/abduce.c
|
set_ptr_local_array
|
set_ptr_local_array
|
int set_ptr_local_array() {
int buf[2];
set_ptr(buf, 1);
return buf[0];
}
|
[
"#include <stdlib.h>",
"void set_ptr(int* ptr, int val) { *ptr = val; }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 20
| 24
|
abduce_004
|
pulse/abduce.c
|
set_ptr_param_array
|
set_ptr_param_array
|
int set_ptr_param_array(int buf[]) {
set_ptr(buf, 1);
return buf[0];
}
|
[
"#include <stdlib.h>",
"void set_ptr(int* ptr, int val) { *ptr = val; }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 33
| 36
|
abduce_005
|
pulse/abduce.c
|
set_ptr_param_array_get_null_bad
|
set_ptr_param_array_get_null
|
void set_ptr_param_array_get_null() {
// A null pointer dereference is expected here
set_ptr_param_array(NULL);
}
|
[
"#include <stdlib.h>",
"int set_ptr_param_array(int buf[]) {\n set_ptr(buf, 1);\n return buf[0];\n}\n"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
2
] |
[
56
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,when calling `set_ptr_param_array` here,parameter `buf` of set_ptr_param_array,when calling `set_ptr` here,parameter `ptr` of set_ptr,invalid access occurs here"
] |
nullptr_dereference
| true
| 54
| 57
|
aliasing_001
|
pulse/aliasing.c
|
local_addr_noalias_bad
|
local_addr_noalias
|
void local_addr_noalias(int* p) {
int* q = NULL;
int x = 1;
if (&x != p) {
*q = 42;
}
}
|
[
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
22
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 18
| 24
|
aliasing_002
|
pulse/aliasing.c
|
global_addr_alias_bad
|
global_addr_alias
|
void global_addr_alias(int* p) {
int* q = NULL;
if (&g == p) {
*q = 42;
}
}
|
[
"#include <stdlib.h>",
"static int g = 0;"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
3
] |
[
30
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 27
| 32
|
angelism_001
|
pulse/angelism.c
|
by_ref_actual_already_in_footprint
|
by_ref_actual_already_in_footprint
|
void by_ref_actual_already_in_footprint(struct delicious* param) {
int i;
struct delicious* ret = bakery(¶m);
i = param->yum;
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 51
| 55
|
angelism_002
|
pulse/angelism.c
|
call_by_ref_actual_already_in_footprint_ok
|
call_by_ref_actual_already_in_footprint
|
void call_by_ref_actual_already_in_footprint() {
by_ref_actual_already_in_footprint(NULL); // should not report a warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};",
"void by_ref_actual_already_in_footprint(struct delicious* param) {\n int i;\n struct delicious* ret = bakery(¶m);\n i = param->yum;\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 57
| 59
|
angelism_003
|
pulse/angelism.c
|
by_ref_actual_already_in_footprint2
|
by_ref_actual_already_in_footprint2
|
void by_ref_actual_already_in_footprint2(struct delicious* param) {
int i;
i = param->yum; // should not report a warning
struct delicious* ret = bakery(¶m);
i = param->yum; // should not report a warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 61
| 66
|
angelism_004
|
pulse/angelism.c
|
call_by_ref_actual_already_in_footprint_bad
|
call_by_ref_actual_already_in_footprint
|
void call_by_ref_actual_already_in_footprint() {
by_ref_actual_already_in_footprint2(NULL); // should report a warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};",
"void by_ref_actual_already_in_footprint2(struct delicious* param) {\n int i;\n i = param->yum; // should not report a warning\n struct delicious* ret = bakery(¶m);\n i = param->yum; // should not report a warning\n}\n"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
1
] |
[
69
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,when calling `by_ref_actual_already_in_footprint2` here,parameter `param` of by_ref_actual_already_in_footprint2,invalid access occurs here"
] |
nullptr_dereference
| true
| 68
| 70
|
angelism_005
|
pulse/angelism.c
|
passByRefTwiceOk
|
passByRefTwiceOk
|
void passByRefTwiceOk() {
struct delicious* param;
bakery2(¶m, ¶m); // should not report a warning
int i = param->yum;
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 72
| 76
|
angelism_006
|
pulse/angelism.c
|
returnPassByRefDerefOk
|
returnPassByRefDerefOk
|
void returnPassByRefDerefOk() {
struct delicious* ret = returnPassByRef();
ret->yum = 2; // should not report a warning
free(ret);
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 85
| 89
|
angelism_007
|
pulse/angelism.c
|
struct_value_by_ref_ptr_ok
|
struct_value_by_ref_ptr
|
int struct_value_by_ref_ptr() {
struct delicious x;
struct_ptr_skip(&x);
return *x.ptr; // should not report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 95
| 99
|
angelism_008
|
pulse/angelism.c
|
struct_value_by_ref_ptr_write_before_ok
|
struct_value_by_ref_ptr_write_before
|
int struct_value_by_ref_ptr_write_before() {
struct delicious x;
x.ptr = NULL;
struct_ptr_skip(&x);
return *x.ptr; // should not report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 101
| 106
|
angelism_009
|
pulse/angelism.c
|
struct_value_by_ref_ptr_write_bad
|
struct_value_by_ref_ptr_write
|
int struct_value_by_ref_ptr_write() {
struct delicious x;
struct_ptr_skip(&x);
x.ptr = NULL;
return *x.ptr; // should report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
112
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 108
| 113
|
angelism_010
|
pulse/angelism.c
|
setF
|
setF
|
void setF(struct delicious* x, int val) { x->ptr = val; }
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 115
| 115
|
angelism_011
|
pulse/angelism.c
|
struct_value_by_ref_callee_write_no_skip_bad
|
struct_value_by_ref_callee_write_no_skip
|
int struct_value_by_ref_callee_write_no_skip() {
struct delicious x;
setF(&x, NULL);
return *x.ptr; // should report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};",
"void setF(struct delicious* x, int val) { x->ptr = val; }\n"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
3
] |
[
120
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,in call to `setF`,parameter `val` of setF,assigned,return from call to `setF`,invalid access occurs here"
] |
nullptr_dereference
| true
| 117
| 121
|
angelism_012
|
pulse/angelism.c
|
struct_value_by_ref_callee_write_skip_bad
|
struct_value_by_ref_callee_write_skip
|
int struct_value_by_ref_callee_write_skip() {
struct delicious x;
struct_ptr_skip(&x);
setF(&x, NULL);
return *x.ptr; // should report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};",
"void setF(struct delicious* x, int val) { x->ptr = val; }\n"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
127
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,in call to `setF`,parameter `val` of setF,assigned,return from call to `setF`,invalid access occurs here"
] |
nullptr_dereference
| true
| 123
| 128
|
angelism_013
|
pulse/angelism.c
|
struct_value_by_ref_write_then_skip_ok
|
struct_value_by_ref_write_then_skip
|
int struct_value_by_ref_write_then_skip() {
struct delicious x;
x.ptr = NULL;
struct_ptr_skip(&x);
return *x.ptr; // should not report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 130
| 135
|
angelism_014
|
pulse/angelism.c
|
struct_value_skip_null_deref_bad
|
struct_value_skip_null_deref
|
int struct_value_skip_null_deref() {
struct delicious x;
x.ptr = NULL;
struct_val_skip(x);
return *x.ptr; // should report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
141
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 137
| 142
|
angelism_015
|
pulse/angelism.c
|
struct_value_skip_ok
|
struct_value_skip
|
int struct_value_skip() {
struct delicious x;
x.yum = 7;
struct_val_skip(x);
return 1 / x.yum; // should not report div by zero warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 144
| 149
|
angelism_016
|
pulse/angelism.c
|
struct_value_from_pointer_skip_ok
|
struct_value_from_pointer_skip
|
int struct_value_from_pointer_skip(struct delicious* x) {
struct_val_skip(*x);
return 1 / x->yum; // should not report div by zero warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 151
| 154
|
angelism_017
|
pulse/angelism.c
|
struct_value_from_pointer_skip_bad
|
struct_value_from_pointer_skip
|
int struct_value_from_pointer_skip(struct delicious* x) {
x->ptr = NULL;
struct_val_skip(*x);
return 1 / *x->ptr; // should report null deref warning
}
|
[
"#include <stdlib.h>",
"struct delicious {\n int yum;\n int* ptr;\n};"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
3
] |
[
159
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 156
| 160
|
arithmetic_001
|
pulse/arithmetic.c
|
return_non_negative
|
return_non_negative
|
int return_non_negative() {
int x = random();
if (x < 0) {
exit(1);
}
return x;
}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 11
| 17
|
arithmetic_002
|
pulse/arithmetic.c
|
return_non_negative_is_non_negative_ok
|
return_non_negative_is_non_negative
|
void return_non_negative_is_non_negative() {
if (return_non_negative() < 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"int return_non_negative() {\n int x = random();\n if (x < 0) {\n exit(1);\n }\n return x;\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 19
| 24
|
arithmetic_003
|
pulse/arithmetic.c
|
assume_non_negative
|
assume_non_negative
|
void assume_non_negative(int x) {
if (x < 0) {
exit(1);
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 26
| 30
|
arithmetic_004
|
pulse/arithmetic.c
|
assume_non_negative_is_non_negative_ok
|
assume_non_negative_is_non_negative
|
void assume_non_negative_is_non_negative() {
int x = random();
assume_non_negative(x);
if (x < 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void assume_non_negative(int x) {\n if (x < 0) {\n exit(1);\n }\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 32
| 39
|
arithmetic_005
|
pulse/arithmetic.c
|
if_negative_then_crash_latent
|
if_negative_then_crash
|
void if_negative_then_crash(int x) {
assume_non_negative(-x);
int* p = NULL;
*p = 42;
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void assume_non_negative(int x) {\n if (x < 0) {\n exit(1);\n }\n}\n"
] | true
|
[
"NULLPTR_DEREFERENCE_LATENT"
] |
[
3
] |
[
44
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
other
| true
| 41
| 45
|
arithmetic_006
|
pulse/arithmetic.c
|
call_if_negative_then_crash_with_local_bad
|
call_if_negative_then_crash_with_local
|
void call_if_negative_then_crash_with_local() {
int x = random();
if_negative_then_crash_latent(x);
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void if_negative_then_crash_latent(int x) {\n assume_non_negative(-x);\n int* p = NULL;\n *p = 42;\n}\n"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
2
] |
[
55
] |
[
"ERROR"
] |
[
"when calling `if_negative_then_crash_latent` here,is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| true
| 53
| 56
|
arithmetic_007
|
pulse/arithmetic.c
|
return_non_negative_float
|
return_non_negative_float
|
float return_non_negative_float() {
float x = ((float)random()) / (2 ^ 31 - 1);
if (x < 0.) {
exit(1);
}
return x;
}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 58
| 64
|
arithmetic_008
|
pulse/arithmetic.c
|
return_non_negative_float_is_non_negative_ok
|
return_non_negative_float_is_non_negative
|
void return_non_negative_float_is_non_negative() {
if (return_non_negative_float() < 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"float return_non_negative_float() {\n float x = ((float)random()) / (2 ^ 31 - 1);\n if (x < 0.) {\n exit(1);\n }\n return x;\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 66
| 71
|
arithmetic_009
|
pulse/arithmetic.c
|
assume_non_negative_float
|
assume_non_negative_float
|
void assume_non_negative_float(float x) {
if (x < 0.) {
exit(1);
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 73
| 77
|
arithmetic_010
|
pulse/arithmetic.c
|
assume_non_negative_float_is_non_negative_ok
|
assume_non_negative_float_is_non_negative
|
void assume_non_negative_float_is_non_negative() {
float x = ((float)random()) / (2 ^ 31 - 1);
assume_non_negative_float(x);
if (x < 0.) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void assume_non_negative_float(float x) {\n if (x < 0.) {\n exit(1);\n }\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 79
| 86
|
array_out_of_bounds_001
|
pulse/array_out_of_bounds.c
|
nested_array_ok
|
nested_array
|
void nested_array() {
int a[3][4][5];
a[2][3][4] = 0;
}
|
[] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 18
| 21
|
assert_001
|
pulse/assert.c
|
report_on_line_offset_6_bad
|
report_on_line_offset_6
|
int report_on_line_offset_6(int* p) {
assert(p);
if (!p) {
*p = 42; // unreachable
}
int* q = NULL;
*q = 42;
}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
6
] |
[
19
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 13
| 20
|
assert_failure_001
|
pulse/assert_failure.c
|
simple_check
|
simple_check
|
void simple_check(int x) { assert(x < 3); }
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 13
| 13
|
assert_failure_002
|
pulse/assert_failure.c
|
simple_assertion_failure
|
simple_assertion_failure
|
void simple_assertion_failure() {
int x = 4;
simple_check(x);
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void simple_check(int x) { assert(x < 3); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 15
| 18
|
assert_failure_003
|
pulse/assert_failure.c
|
no_assertion_failure
|
no_assertion_failure
|
void no_assertion_failure() {
int x = 2;
simple_check(x);
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void simple_check(int x) { assert(x < 3); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 20
| 23
|
assert_failure_004
|
pulse/assert_failure.c
|
check_node
|
check_node
|
void check_node(node* n) { assert(n->value < 3); }
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"typedef struct {\n int value;\n} node;"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 29
| 29
|
assert_failure_005
|
pulse/assert_failure.c
|
assertion_failure_with_heap
|
assertion_failure_with_heap
|
node* assertion_failure_with_heap() {
node* n = malloc(sizeof(node));
if (n != NULL) {
n->value = 4;
check_node(n);
}
return n;
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"typedef struct {\n int value;\n} node;",
"void check_node(node* n) { assert(n->value < 3); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 31
| 38
|
assert_failure_006
|
pulse/assert_failure.c
|
no_assertion_failure_with_heap
|
no_assertion_failure_with_heap
|
node* no_assertion_failure_with_heap() {
node* n = malloc(sizeof(node));
if (n != NULL) {
n->value = 2;
check_node(n);
}
return n;
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"typedef struct {\n int value;\n} node;",
"void check_node(node* n) { assert(n->value < 3); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 40
| 47
|
assert_failure_007
|
pulse/assert_failure.c
|
my_assert
|
my_assert
|
void my_assert(int x) {
if (!x) {
__infer_fail("ASSERTION_FAILURE");
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 51
| 55
|
assert_failure_008
|
pulse/assert_failure.c
|
should_not_report_assertion_failure
|
should_not_report_assertion_failure
|
void should_not_report_assertion_failure(int x) { my_assert(x); }
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void my_assert(int x) {\n if (!x) {\n __infer_fail(\"ASSERTION_FAILURE\");\n }\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 57
| 57
|
assert_failure_009
|
pulse/assert_failure.c
|
should_report_assertion_failure
|
should_report_assertion_failure
|
void should_report_assertion_failure(int x) {
x = 0;
my_assert(x);
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void my_assert(int x) {\n if (!x) {\n __infer_fail(\"ASSERTION_FAILURE\");\n }\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 59
| 62
|
assert_failure_010
|
pulse/assert_failure.c
|
check_global
|
check_global
|
void check_global() { assert(global != 0); }
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 66
| 66
|
assert_failure_011
|
pulse/assert_failure.c
|
skip
|
skip
|
void skip() {}
|
[
"#include <assert.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 68
| 68
|
assert_failure_012
|
pulse/assert_failure.c
|
assignment_after_check
|
assignment_after_check
|
void assignment_after_check() {
check_global();
global = 0;
skip();
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void check_global() { assert(global != 0); }\n",
"void skip() {}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 70
| 74
|
assert_failure_013
|
pulse/assert_failure.c
|
assignemt_before_check
|
assignemt_before_check
|
void assignemt_before_check() {
global = 0;
check_global();
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void check_global() { assert(global != 0); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 76
| 79
|
assert_failure_014
|
pulse/assert_failure.c
|
failure_on_both_branches
|
failure_on_both_branches
|
void failure_on_both_branches(int x) {
if (x > 3) {
simple_check(x);
} else {
simple_check(42);
}
}
|
[
"#include <assert.h>",
"#include <stdlib.h>",
"void simple_check(int x) { assert(x < 3); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 81
| 87
|
cleanup_attribute_001
|
pulse/cleanup_attribute.c
|
cleanup_char
|
cleanup_char
|
void cleanup_char(char** x) { free(*x); }
|
[
"#include <stdlib.h>",
"#include <string.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 10
| 10
|
cleanup_attribute_002
|
pulse/cleanup_attribute.c
|
cleanup_int
|
cleanup_int
|
void cleanup_int(int** x) { free(*x); }
|
[
"#include <stdlib.h>",
"#include <string.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 12
| 12
|
cleanup_attribute_003
|
pulse/cleanup_attribute.c
|
no_cleanup
|
no_cleanup
|
void no_cleanup(int** x) { /* nothing */ }
|
[
"#include <stdlib.h>",
"#include <string.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 14
| 14
|
cleanup_attribute_004
|
pulse/cleanup_attribute.c
|
cleanup_malloc_ok
|
cleanup_malloc
|
void cleanup_malloc() {
__attribute__((cleanup(cleanup_int))) int* x;
// attribute cleanup is done on *x not x, resulting in NPE, Uninit, and
// memleak FPs
x = malloc(sizeof(int));
if (x != NULL) {
*x = 10;
}
/* x goes out of scope. Cleanup function called - no leak */
}
|
[
"#include <stdlib.h>",
"#include <string.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 16
| 25
|
cleanup_attribute_005
|
pulse/cleanup_attribute.c
|
cleanup_string_ok
|
cleanup_string
|
void cleanup_string() {
__attribute__((cleanup(cleanup_char))) char* s;
s = strdup("demo string");
/* s goes out of scope. Cleanup function called - no leak */
}
|
[
"#include <stdlib.h>",
"#include <string.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 34
| 38
|
compound_literal_001
|
pulse/compound_literal.c
|
return_zero
|
return_zero
|
int return_zero() { return ((struct point){.y = 32, .x = 0}).x; }
|
[
"#include <stdlib.h>",
"struct point {\n int x;\n int y;\n};"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 15
| 15
|
compound_literal_002
|
pulse/compound_literal.c
|
detect_zero_bad
|
detect_zero
|
int detect_zero() {
if (return_zero() == 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <stdlib.h>",
"struct point {\n int x;\n int y;\n};",
"int return_zero() { return ((struct point){.y = 32, .x = 0}).x; }\n"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
3
] |
[
20
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| true
| 17
| 22
|
compound_literal_003
|
pulse/compound_literal.c
|
detect_zero_ok
|
detect_zero
|
int detect_zero() {
if (return_zero() != 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <stdlib.h>",
"struct point {\n int x;\n int y;\n};",
"int return_zero() { return ((struct point){.y = 32, .x = 0}).x; }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 24
| 29
|
dangling_deref_001
|
pulse/dangling_deref.c
|
set42
|
set42
|
int* set42(int* x) {
*x = 42;
return x;
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 11
| 14
|
dangling_deref_002
|
pulse/dangling_deref.c
|
no_dangling_deref_ok
|
no_dangling_deref
|
void no_dangling_deref() {
int w, *z;
z = set42(&w);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>",
"int* set42(int* x) {\n *x = 42;\n return x;\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 16
| 19
|
dangling_deref_003
|
pulse/dangling_deref.c
|
no_dangling_deref1_ok
|
no_dangling_deref1
|
void no_dangling_deref1() {
int* y = malloc(sizeof(int));
int* z;
if (y) {
z = set42(y);
free(y);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>",
"int* set42(int* x) {\n *x = 42;\n return x;\n}\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 21
| 28
|
dangling_deref_004
|
pulse/dangling_deref.c
|
dangling_deref_bad
|
dangling_deref
|
void dangling_deref() {
int* y;
int* z;
z = set42(y);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>",
"int* set42(int* x) {\n *x = 42;\n return x;\n}\n"
] | true
|
[
"PULSE_UNINITIALIZED_VALUE"
] |
[
3
] |
[
33
] |
[
"ERROR"
] |
[
"variable `y` declared here,read to uninitialized value occurs here"
] |
uninitialized_value
| true
| 30
| 34
|
dangling_deref_005
|
pulse/dangling_deref.c
|
intraproc_dangling_deref_bad
|
intraproc_dangling_deref
|
void intraproc_dangling_deref() {
int* y;
int* z;
*y = 42;
z = y;
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"PULSE_UNINITIALIZED_VALUE"
] |
[
3
] |
[
39
] |
[
"ERROR"
] |
[
"variable `y` declared here,read to uninitialized value occurs here"
] |
uninitialized_value
| false
| 36
| 41
|
dangling_deref_006
|
pulse/dangling_deref.c
|
union_ok
|
union
|
short union(int* param) {
union {
int* a;
short* b;
} u;
u.a = param;
short* p = u.b;
return *p;
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 43
| 51
|
enum_001
|
pulse/enum.c
|
other_enum_main
|
other_enum_main
|
int other_enum_main() {
enum Foo foo_a = A;
enum Foo foo_b = B;
enum Foo foo_c = C;
enum Foo foo_d = D;
enum Foo foo_e = E;
enum Foo foo_f = F;
enum Foo foo_g = G;
}
|
[
"#include <stdlib.h>",
"enum Foo { A, B, C = 10, D, E = 1, F, G = F + C };"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 12
| 20
|
enum_002
|
pulse/enum.c
|
enum_values_ok
|
enum_values
|
void enum_values() {
enum Foo foo_g = G;
enum Foo foo_a = A;
if (foo_g != 12 || foo_a != 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <stdlib.h>",
"enum Foo { A, B, C = 10, D, E = 1, F, G = F + C };"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 22
| 29
|
enum_003
|
pulse/enum.c
|
enum_values_bad
|
enum_values
|
void enum_values() {
enum Foo foo_g = G;
enum Foo foo_a = A;
if (foo_g == 12 && foo_a == 0) {
int* p = NULL;
*p = 42;
}
}
|
[
"#include <stdlib.h>",
"enum Foo { A, B, C = 10, D, E = 1, F, G = F + C };"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
5
] |
[
36
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 31
| 38
|
exit_example_001
|
pulse/exit_example.c
|
exit_example_bad
|
exit_example
|
void exit_example() {
int* p = NULL;
if (p) {
exit(1);
}
*p = 42;
}
|
[
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
5
] |
[
14
] |
[
"ERROR"
] |
[
"is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 9
| 15
|
exit_example_002
|
pulse/exit_example.c
|
direct_exit_example_ok
|
direct_exit_example
|
void direct_exit_example() {
int* p = NULL;
exit(1);
*p = 42;
}
|
[
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 17
| 21
|
exit_example_003
|
pulse/exit_example.c
|
exit_wrapper
|
exit_wrapper
|
void exit_wrapper() { exit(1); }
|
[
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 23
| 23
|
exit_example_004
|
pulse/exit_example.c
|
indirect_exit_example_ok
|
indirect_exit_example
|
void indirect_exit_example() {
int* p = NULL;
exit_wrapper();
*p = 42;
}
|
[
"#include <stdlib.h>",
"void exit_wrapper() { exit(1); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 25
| 29
|
exit_example_005
|
pulse/exit_example.c
|
direct_abort_example_ok
|
direct_abort_example
|
void direct_abort_example() {
int* p = NULL;
abort();
*p = 42;
}
|
[
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 31
| 35
|
exit_example_006
|
pulse/exit_example.c
|
abort_wrapper
|
abort_wrapper
|
void abort_wrapper() { abort(); }
|
[
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 37
| 37
|
exit_example_007
|
pulse/exit_example.c
|
indirect_abort_example_ok
|
indirect_abort_example
|
void indirect_abort_example() {
int* p = NULL;
abort_wrapper();
*p = 42;
}
|
[
"#include <stdlib.h>",
"void abort_wrapper() { abort(); }\n"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| true
| 39
| 43
|
field_taint_001
|
pulse/field_taint.c
|
test_taint_field_bad
|
test_taint_field
|
void test_taint_field(structure s) {
taint_manipulated(s);
sink_int(s.manipulated);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
2
] |
[
28
] |
[
"ERROR"
] |
[
"source of the taint here: field `manipulated` of value passed as argument `#0` to `taint_manipulated` with kind `Simple`,flows to this sink: value passed as argument `#0` to `sink_int` with kind `Simple`"
] |
other
| false
| 26
| 29
|
field_taint_002
|
pulse/field_taint.c
|
test_taint_field_good
|
test_taint_field
|
void test_taint_field(structure s) {
taint_manipulated(s);
sink_int(s.other);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 31
| 34
|
field_taint_003
|
pulse/field_taint.c
|
test_sink_field_bad
|
test_sink_field
|
void test_sink_field(structure s) {
int tainted = int_source();
s.manipulated = tainted;
sink_manipulated(s);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
3
] |
[
39
] |
[
"ERROR"
] |
[
"source of the taint here: value returned from `int_source` with kind `Simple`,flows to this sink: field `manipulated` of value passed as argument `#0` to `sink_manipulated` with kind `Simple`"
] |
other
| false
| 36
| 40
|
field_taint_004
|
pulse/field_taint.c
|
test_sink_field_good
|
test_sink_field
|
void test_sink_field(structure s) {
int tainted = int_source();
s.other = tainted;
sink_manipulated(s);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 42
| 46
|
field_taint_005
|
pulse/field_taint.c
|
test_sanitize_field_bad
|
test_sanitize_field
|
void test_sanitize_field(structure s) {
// The 2 lines below are necessary because tainting propagates down
// what is known in the memory at the moment of tainting and it is never
// propagated again when a new manipulated appears. `s.other` and
// `s.manipulated` need to have different values otherwise they are both
// referencing the same value and sanitizing one would sanitize the other
s.other = 2; // makes s.other exist in memory before tainting s
s.manipulated = 1; // makes s.manipulated exist in memory before tainting s
taint_structure(s);
sanitize_manipulated(s);
sink_int(s.other);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
10
] |
[
58
] |
[
"ERROR"
] |
[
"source of the taint here: value passed as argument `#0` to `taint_structure` with kind `Simple`,flows to this sink: value passed as argument `#0` to `sink_int` with kind `Simple`"
] |
other
| false
| 48
| 59
|
field_taint_006
|
pulse/field_taint.c
|
test_sanitize_field_good
|
test_sanitize_field
|
void test_sanitize_field(structure s) {
s.other = 2; // makes s.other exist in memory before tainting s
s.manipulated = 1; // makes s.manipulated exist in memory before tainting s
taint_structure(s);
sanitize_manipulated(s);
sink_manipulated(s);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 61
| 67
|
field_taint_007
|
pulse/field_taint.c
|
test_propagate_to_field_bad
|
test_propagate_to_field
|
void test_propagate_to_field(structure s) {
int tainted = int_source();
propagate_to_manipulated(s, tainted);
sink_int(s.manipulated);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
3
] |
[
71
] |
[
"ERROR"
] |
[
"source of the taint here: value returned from `int_source` with kind `Simple`,in call to `propagate_to_manipulated`,flows to this sink: value passed as argument `#0` to `sink_int` with kind `Simple`"
] |
other
| false
| 68
| 72
|
field_taint_008
|
pulse/field_taint.c
|
test_propagate_to_field_good
|
test_propagate_to_field
|
void test_propagate_to_field(structure s) {
int tainted = int_source();
propagate_to_manipulated(s, tainted);
sink_int(s.other);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 74
| 78
|
field_taint_009
|
pulse/field_taint.c
|
test_taint_field_with_indirections_bad
|
test_taint_field_with_indirections
|
void test_taint_field_with_indirections(structure s) {
structure* s_ptr = &s;
structure** s_ptr_ptr = &s_ptr;
taint_manipulated_with_indirections(s_ptr_ptr);
sink_int((**s_ptr_ptr).manipulated);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
4
] |
[
84
] |
[
"ERROR"
] |
[
"source of the taint here: field `manipulated` of value passed as argument `#0` to `taint_manipulated_with_indirections` with kind `Simple`,flows to this sink: value passed as argument `#0` to `sink_int` with kind `Simple`"
] |
other
| false
| 80
| 85
|
field_taint_010
|
pulse/field_taint.c
|
test_taint_field_with_indirections_good
|
test_taint_field_with_indirections
|
void test_taint_field_with_indirections(structure s) {
structure* s_ptr = &s;
structure** s_ptr_ptr = &s_ptr;
taint_manipulated_with_indirections(s_ptr_ptr);
sink_int((**s_ptr_ptr).other);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 87
| 92
|
field_taint_011
|
pulse/field_taint.c
|
test_taint_previously_unaccessed_field_bad
|
test_taint_previously_unaccessed_field
|
void test_taint_previously_unaccessed_field(structure s) {
taint_structure(s);
sink_int(s.manipulated);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
2
] |
[
96
] |
[
"ERROR"
] |
[
"source of the taint here: value passed as argument `#0` to `taint_structure` with kind `Simple`,flows to this sink: value passed as argument `#0` to `sink_int` with kind `Simple`"
] |
other
| false
| 94
| 97
|
field_taint_012
|
pulse/field_taint.c
|
test_taint_logger_policy
|
test_taint_logger_policy
|
void test_taint_logger_policy(structure s) {
taint_manipulated(s);
sink_log(s.manipulated);
}
|
[
"typedef struct {\n int manipulated;\n int other;\n} structure;"
] | true
|
[
"TAINT_ERROR"
] |
[
2
] |
[
101
] |
[
"ERROR"
] |
[
"source of the taint here: field `manipulated` of value passed as argument `#0` to `taint_manipulated` with kind `Simple`,flows to this sink: value passed as argument `#0` to `sink_log` with kind `Logger`"
] |
other
| false
| 99
| 102
|
fopen_001
|
pulse/fopen.c
|
no_fopen_check_getc_bad
|
no_fopen_check_getc
|
void no_fopen_check_getc() {
FILE* f;
int i;
f = fopen("this_file_doesnt_exist", "r");
i = getc(f);
printf("i =%i\n", i);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
15
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 11
| 18
|
fopen_002
|
pulse/fopen.c
|
fopen_check_getc_ok
|
fopen_check_getc
|
void fopen_check_getc() {
FILE* f;
int i;
f = fopen("this_file_doesnt_exist", "r");
if (f) {
i = getc(f);
printf("i =%i\n", i);
fclose(f);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 20
| 29
|
fopen_003
|
pulse/fopen.c
|
fopen_no_fclose_bad
|
fopen_no_fclose
|
void fopen_no_fclose() {
FILE* f;
int i;
f = fopen("some_file", "r");
if (f) {
i = getc(f);
printf("i =%i\n", i);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"PULSE_RESOURCE_LEAK"
] |
[
5
] |
[
36
] |
[
"ERROR"
] |
[
"allocation part of the trace starts here,allocated by `fopen()` here,file descriptor becomes unreachable here"
] |
resource_leak
| false
| 31
| 39
|
fopen_004
|
pulse/fopen.c
|
no_fopen_check_fgetc_bad
|
no_fopen_check_fgetc
|
void no_fopen_check_fgetc() {
FILE* f;
int i;
f = fopen("this_file_doesnt_exist", "r");
i = fgetc(f);
printf("i =%i\n", i);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
45
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 41
| 48
|
fopen_005
|
pulse/fopen.c
|
fopen_check_fgetc_ok
|
fopen_check_fgetc
|
void fopen_check_fgetc() {
FILE* f;
int i;
f = fopen("this_file_doesnt_exist", "r");
if (f) {
i = fgetc(f);
printf("i =%i\n", i);
fclose(f);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 50
| 59
|
fopen_006
|
pulse/fopen.c
|
no_fopen_check_ungetc_bad
|
no_fopen_check_ungetc
|
void no_fopen_check_ungetc() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
int i = ungetc(10, f);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
3
] |
[
64
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 61
| 66
|
fopen_007
|
pulse/fopen.c
|
fopen_check_ungetc_ok
|
fopen_check_ungetc
|
void fopen_check_ungetc() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
if (f) {
int i = ungetc(10, f);
fclose(f);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 68
| 75
|
fopen_008
|
pulse/fopen.c
|
no_fopen_check_fputs_bad
|
no_fopen_check_fputs
|
void no_fopen_check_fputs() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
fputs("blablabla", f);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
3
] |
[
80
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 77
| 82
|
fopen_009
|
pulse/fopen.c
|
fopen_check_fputs_ok
|
fopen_check_fputs
|
void fopen_check_fputs() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
if (f) {
fputs("blablabla", f);
fclose(f);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 84
| 92
|
fopen_010
|
pulse/fopen.c
|
no_fopen_check_fputc_bad
|
no_fopen_check_fputc
|
void no_fopen_check_fputc() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
fputc(42, f);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
98
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 94
| 100
|
fopen_011
|
pulse/fopen.c
|
fopen_check_fputc_ok
|
fopen_check_fputc
|
void fopen_check_fputc() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
if (f) {
fputc(42, f);
fclose(f);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 102
| 110
|
fopen_012
|
pulse/fopen.c
|
no_fopen_check_putc_bad
|
no_fopen_check_putc
|
void no_fopen_check_putc() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
putc(42, f);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
116
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 112
| 118
|
fopen_013
|
pulse/fopen.c
|
fopen_check_putc_ok
|
fopen_check_putc
|
void fopen_check_putc() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
if (f) {
putc(42, f);
fclose(f);
}
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | false
|
[] |
[] |
[] |
[] |
[] |
safe
| false
| 120
| 128
|
fopen_014
|
pulse/fopen.c
|
no_fopen_check_fseek_bad
|
no_fopen_check_fseek
|
void no_fopen_check_fseek() {
FILE* f;
f = fopen("this_file_doesnt_exist", "r");
fseek(f, 7, SEEK_SET);
fclose(f);
}
|
[
"#include <stdio.h>",
"#include <stdlib.h>"
] | true
|
[
"NULLPTR_DEREFERENCE"
] |
[
4
] |
[
134
] |
[
"ERROR"
] |
[
"in call to `fopen` (modelled),is assigned to the null pointer,assigned,invalid access occurs here"
] |
nullptr_dereference
| false
| 130
| 136
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.