instruction
stringclasses 1
value | input
stringlengths 31
235k
| output
class label 2
classes |
|---|---|---|
Categorize the following code snippet as vulnerable or not. True or False
|
static void main_external_compression_cleanup ( void ) {
int i ;
for ( i = 0 ;
i < num_subprocs ;
i += 1 ) {
if ( ! ext_subprocs [ i ] ) {
continue ;
}
kill ( ext_subprocs [ i ] , SIGTERM ) ;
ext_subprocs [ i ] = 0 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void selinux_secmark_refcount_inc ( void ) {
atomic_inc ( & selinux_secmark_refcount ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void update_quantizer_histogram ( struct stream_state * stream ) {
if ( stream -> config . cfg . g_pass != VPX_RC_FIRST_PASS ) {
int q ;
vpx_codec_control ( & stream -> encoder , VP8E_GET_LAST_QUANTIZER_64 , & q ) ;
ctx_exit_on_error ( & stream -> encoder , "Failed to read quantizer" ) ;
stream -> counts [ q ] ++ ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void dissect_zcl_on_off_attr_data ( proto_tree * tree , tvbuff_t * tvb , guint * offset , guint16 attr_id , guint data_type ) {
switch ( attr_id ) {
case ZBEE_ZCL_ON_OFF_ATTR_ID_ONOFF : proto_tree_add_item ( tree , hf_zbee_zcl_on_off_attr_onoff , tvb , * offset , 1 , ENC_NA ) ;
* offset += 1 ;
break ;
default : dissect_zcl_attr_data ( tvb , tree , offset , data_type ) ;
break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( DownloadExtensionTest , DownloadExtensionTest_OnDeterminingFilename_IncognitoSpanning ) {
LoadExtension ( "downloads_spanning" ) ;
ASSERT_TRUE ( StartEmbeddedTestServer ( ) ) ;
std : : string download_url = embedded_test_server ( ) -> GetURL ( "/slow?0" ) . spec ( ) ;
GoOnTheRecord ( ) ;
AddFilenameDeterminer ( ) ;
GoOnTheRecord ( ) ;
std : : unique_ptr < base : : Value > result ( RunFunctionAndReturnResult ( new DownloadsDownloadFunction ( ) , base : : StringPrintf ( "[{
\"url\": \"%s\"}
]" , download_url . c_str ( ) ) ) ) ;
ASSERT_TRUE ( result . get ( ) ) ;
int result_id = - 1 ;
ASSERT_TRUE ( result -> GetAsInteger ( & result_id ) ) ;
DownloadItem * item = GetCurrentManager ( ) -> GetDownload ( result_id ) ;
ASSERT_TRUE ( item ) ;
ScopedCancellingItem canceller ( item ) ;
ASSERT_EQ ( download_url , item -> GetOriginalUrl ( ) . spec ( ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnCreated : : kEventName , base : : StringPrintf ( "[{
\"danger\": \"safe\"," " \"incognito\": false," " \"id\": %d," " \"mime\": \"text/plain\"," " \"paused\": false," " \"url\": \"%s\"}
]" , result_id , download_url . c_str ( ) ) ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnDeterminingFilename : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"incognito\": false," " \"filename\":\"slow.txt\"}
]" , result_id ) ) ) ;
ASSERT_TRUE ( item -> GetTargetFilePath ( ) . empty ( ) ) ;
ASSERT_EQ ( DownloadItem : : IN_PROGRESS , item -> GetState ( ) ) ;
std : : string error ;
ASSERT_TRUE ( ExtensionDownloadsEventRouter : : DetermineFilename ( current_browser ( ) -> profile ( ) , true , GetExtensionId ( ) , result_id , base : : FilePath ( FILE_PATH_LITERAL ( "42.txt" ) ) , downloads : : FILENAME_CONFLICT_ACTION_UNIQUIFY , & error ) ) ;
EXPECT_EQ ( "" , error ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnChanged : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"filename\": {
" " \"previous\": \"\"," " \"current\": \"%s\"}
}
]" , result_id , GetFilename ( "42.txt" ) . c_str ( ) ) ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnChanged : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"state\": {
" " \"previous\": \"in_progress\"," " \"current\": \"complete\"}
}
]" , result_id ) ) ) ;
GoOffTheRecord ( ) ;
result . reset ( RunFunctionAndReturnResult ( new DownloadsDownloadFunction ( ) , base : : StringPrintf ( "[{
\"url\": \"%s\"}
]" , download_url . c_str ( ) ) ) ) ;
ASSERT_TRUE ( result . get ( ) ) ;
result_id = - 1 ;
ASSERT_TRUE ( result -> GetAsInteger ( & result_id ) ) ;
item = GetCurrentManager ( ) -> GetDownload ( result_id ) ;
ASSERT_TRUE ( item ) ;
ScopedCancellingItem canceller2 ( item ) ;
ASSERT_EQ ( download_url , item -> GetOriginalUrl ( ) . spec ( ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnCreated : : kEventName , base : : StringPrintf ( "[{
\"danger\": \"safe\"," " \"incognito\": true," " \"id\": %d," " \"mime\": \"text/plain\"," " \"paused\": false," " \"url\": \"%s\"}
]" , result_id , download_url . c_str ( ) ) ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnDeterminingFilename : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"incognito\": true," " \"filename\":\"slow.txt\"}
]" , result_id ) ) ) ;
ASSERT_TRUE ( item -> GetTargetFilePath ( ) . empty ( ) ) ;
ASSERT_EQ ( DownloadItem : : IN_PROGRESS , item -> GetState ( ) ) ;
error = "" ;
ASSERT_TRUE ( ExtensionDownloadsEventRouter : : DetermineFilename ( current_browser ( ) -> profile ( ) , true , GetExtensionId ( ) , result_id , base : : FilePath ( FILE_PATH_LITERAL ( "42.txt" ) ) , downloads : : FILENAME_CONFLICT_ACTION_UNIQUIFY , & error ) ) ;
EXPECT_EQ ( "" , error ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnChanged : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"filename\": {
" " \"previous\": \"\"," " \"current\": \"%s\"}
}
]" , result_id , GetFilename ( "42 (1).txt" ) . c_str ( ) ) ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnChanged : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"state\": {
" " \"previous\": \"in_progress\"," " \"current\": \"complete\"}
}
]" , result_id ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int asv2_decode_block ( ASV1Context * a , int16_t block [ 64 ] ) {
int i , count , ccp ;
count = asv2_get_bits ( & a -> gb , 4 ) ;
block [ 0 ] = 8 * asv2_get_bits ( & a -> gb , 8 ) ;
ccp = get_vlc2 ( & a -> gb , dc_ccp_vlc . table , VLC_BITS , 1 ) ;
if ( ccp ) {
if ( ccp & 4 ) block [ a -> scantable . permutated [ 1 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 1 ] ) >> 4 ;
if ( ccp & 2 ) block [ a -> scantable . permutated [ 2 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 2 ] ) >> 4 ;
if ( ccp & 1 ) block [ a -> scantable . permutated [ 3 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 3 ] ) >> 4 ;
}
for ( i = 1 ;
i < count + 1 ;
i ++ ) {
const int ccp = get_vlc2 ( & a -> gb , ac_ccp_vlc . table , VLC_BITS , 1 ) ;
if ( ccp ) {
if ( ccp & 8 ) block [ a -> scantable . permutated [ 4 * i + 0 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 4 * i + 0 ] ) >> 4 ;
if ( ccp & 4 ) block [ a -> scantable . permutated [ 4 * i + 1 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 4 * i + 1 ] ) >> 4 ;
if ( ccp & 2 ) block [ a -> scantable . permutated [ 4 * i + 2 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 4 * i + 2 ] ) >> 4 ;
if ( ccp & 1 ) block [ a -> scantable . permutated [ 4 * i + 3 ] ] = ( asv2_get_level ( & a -> gb ) * a -> intra_matrix [ 4 * i + 3 ] ) >> 4 ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dct_quantize_refine ( MpegEncContext * s , int16_t * block , int16_t * weight , int16_t * orig , int n , int qscale ) {
int16_t rem [ 64 ] ;
LOCAL_ALIGNED_16 ( int16_t , d1 , [ 64 ] ) ;
const uint8_t * scantable = s -> intra_scantable . scantable ;
const uint8_t * perm_scantable = s -> intra_scantable . permutated ;
int run_tab [ 65 ] ;
int prev_run = 0 ;
int prev_level = 0 ;
int qmul , qadd , start_i , last_non_zero , i , dc ;
uint8_t * length ;
uint8_t * last_length ;
int lambda ;
int rle_index , run , q = 1 , sum ;
# ifdef REFINE_STATS static int count = 0 ;
static int after_last = 0 ;
static int to_zero = 0 ;
static int from_zero = 0 ;
static int raise = 0 ;
static int lower = 0 ;
static int messed_sign = 0 ;
# endif if ( basis [ 0 ] [ 0 ] == 0 ) build_basis ( s -> dsp . idct_permutation ) ;
qmul = qscale * 2 ;
qadd = ( qscale - 1 ) | 1 ;
if ( s -> mb_intra ) {
if ( ! s -> h263_aic ) {
if ( n < 4 ) q = s -> y_dc_scale ;
else q = s -> c_dc_scale ;
}
else {
q = 1 ;
qadd = 0 ;
}
q <<= RECON_SHIFT - 3 ;
dc = block [ 0 ] * q ;
start_i = 1 ;
length = s -> intra_ac_vlc_length ;
last_length = s -> intra_ac_vlc_last_length ;
}
else {
dc = 0 ;
start_i = 0 ;
length = s -> inter_ac_vlc_length ;
last_length = s -> inter_ac_vlc_last_length ;
}
last_non_zero = s -> block_last_index [ n ] ;
# ifdef REFINE_STATS {
START_TIMER # endif dc += ( 1 << ( RECON_SHIFT - 1 ) ) ;
for ( i = 0 ;
i < 64 ;
i ++ ) {
rem [ i ] = dc - ( orig [ i ] << RECON_SHIFT ) ;
}
# ifdef REFINE_STATS STOP_TIMER ( "memset rem[]" ) }
# endif sum = 0 ;
for ( i = 0 ;
i < 64 ;
i ++ ) {
int one = 36 ;
int qns = 4 ;
int w ;
w = FFABS ( weight [ i ] ) + qns * one ;
w = 15 + ( 48 * qns * one + w / 2 ) / w ;
weight [ i ] = w ;
assert ( w > 0 ) ;
assert ( w < ( 1 << 6 ) ) ;
sum += w * w ;
}
lambda = sum * ( uint64_t ) s -> lambda2 >> ( FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6 ) ;
# ifdef REFINE_STATS {
START_TIMER # endif run = 0 ;
rle_index = 0 ;
for ( i = start_i ;
i <= last_non_zero ;
i ++ ) {
int j = perm_scantable [ i ] ;
const int level = block [ j ] ;
int coeff ;
if ( level ) {
if ( level < 0 ) coeff = qmul * level - qadd ;
else coeff = qmul * level + qadd ;
run_tab [ rle_index ++ ] = run ;
run = 0 ;
s -> dsp . add_8x8basis ( rem , basis [ j ] , coeff ) ;
}
else {
run ++ ;
}
}
# ifdef REFINE_STATS if ( last_non_zero > 0 ) {
STOP_TIMER ( "init rem[]" ) }
}
{
START_TIMER # endif for ( ;
;
) {
int best_score = s -> dsp . try_8x8basis ( rem , weight , basis [ 0 ] , 0 ) ;
int best_coeff = 0 ;
int best_change = 0 ;
int run2 , best_unquant_change = 0 , analyze_gradient ;
# ifdef REFINE_STATS {
START_TIMER # endif analyze_gradient = last_non_zero > 2 || s -> quantizer_noise_shaping >= 3 ;
if ( analyze_gradient ) {
# ifdef REFINE_STATS {
START_TIMER # endif for ( i = 0 ;
i < 64 ;
i ++ ) {
int w = weight [ i ] ;
d1 [ i ] = ( rem [ i ] * w * w + ( 1 << ( RECON_SHIFT + 12 - 1 ) ) ) >> ( RECON_SHIFT + 12 ) ;
}
# ifdef REFINE_STATS STOP_TIMER ( "rem*w*w" ) }
{
START_TIMER # endif s -> dsp . fdct ( d1 ) ;
# ifdef REFINE_STATS STOP_TIMER ( "dct" ) }
# endif }
if ( start_i ) {
const int level = block [ 0 ] ;
int change , old_coeff ;
assert ( s -> mb_intra ) ;
old_coeff = q * level ;
for ( change = - 1 ;
change <= 1 ;
change += 2 ) {
int new_level = level + change ;
int score , new_coeff ;
new_coeff = q * new_level ;
if ( new_coeff >= 2048 || new_coeff < 0 ) continue ;
score = s -> dsp . try_8x8basis ( rem , weight , basis [ 0 ] , new_coeff - old_coeff ) ;
if ( score < best_score ) {
best_score = score ;
best_coeff = 0 ;
best_change = change ;
best_unquant_change = new_coeff - old_coeff ;
}
}
}
run = 0 ;
rle_index = 0 ;
run2 = run_tab [ rle_index ++ ] ;
prev_level = 0 ;
prev_run = 0 ;
for ( i = start_i ;
i < 64 ;
i ++ ) {
int j = perm_scantable [ i ] ;
const int level = block [ j ] ;
int change , old_coeff ;
if ( s -> quantizer_noise_shaping < 3 && i > last_non_zero + 1 ) break ;
if ( level ) {
if ( level < 0 ) old_coeff = qmul * level - qadd ;
else old_coeff = qmul * level + qadd ;
run2 = run_tab [ rle_index ++ ] ;
}
else {
old_coeff = 0 ;
run2 -- ;
assert ( run2 >= 0 || i >= last_non_zero ) ;
}
for ( change = - 1 ;
change <= 1 ;
change += 2 ) {
int new_level = level + change ;
int score , new_coeff , unquant_change ;
score = 0 ;
if ( s -> quantizer_noise_shaping < 2 && FFABS ( new_level ) > FFABS ( level ) ) continue ;
if ( new_level ) {
if ( new_level < 0 ) new_coeff = qmul * new_level - qadd ;
else new_coeff = qmul * new_level + qadd ;
if ( new_coeff >= 2048 || new_coeff <= - 2048 ) continue ;
if ( level ) {
if ( level < 63 && level > - 63 ) {
if ( i < last_non_zero ) score += length [ UNI_AC_ENC_INDEX ( run , new_level + 64 ) ] - length [ UNI_AC_ENC_INDEX ( run , level + 64 ) ] ;
else score += last_length [ UNI_AC_ENC_INDEX ( run , new_level + 64 ) ] - last_length [ UNI_AC_ENC_INDEX ( run , level + 64 ) ] ;
}
}
else {
assert ( FFABS ( new_level ) == 1 ) ;
if ( analyze_gradient ) {
int g = d1 [ scantable [ i ] ] ;
if ( g && ( g ^ new_level ) >= 0 ) continue ;
}
if ( i < last_non_zero ) {
int next_i = i + run2 + 1 ;
int next_level = block [ perm_scantable [ next_i ] ] + 64 ;
if ( next_level & ( ~ 127 ) ) next_level = 0 ;
if ( next_i < last_non_zero ) score += length [ UNI_AC_ENC_INDEX ( run , 65 ) ] + length [ UNI_AC_ENC_INDEX ( run2 , next_level ) ] - length [ UNI_AC_ENC_INDEX ( run + run2 + 1 , next_level ) ] ;
else score += length [ UNI_AC_ENC_INDEX ( run , 65 ) ] + last_length [ UNI_AC_ENC_INDEX ( run2 , next_level ) ] - last_length [ UNI_AC_ENC_INDEX ( run + run2 + 1 , next_level ) ] ;
}
else {
score += last_length [ UNI_AC_ENC_INDEX ( run , 65 ) ] ;
if ( prev_level ) {
score += length [ UNI_AC_ENC_INDEX ( prev_run , prev_level ) ] - last_length [ UNI_AC_ENC_INDEX ( prev_run , prev_level ) ] ;
}
}
}
}
else {
new_coeff = 0 ;
assert ( FFABS ( level ) == 1 ) ;
if ( i < last_non_zero ) {
int next_i = i + run2 + 1 ;
int next_level = block [ perm_scantable [ next_i ] ] + 64 ;
if ( next_level & ( ~ 127 ) ) next_level = 0 ;
if ( next_i < last_non_zero ) score += length [ UNI_AC_ENC_INDEX ( run + run2 + 1 , next_level ) ] - length [ UNI_AC_ENC_INDEX ( run2 , next_level ) ] - length [ UNI_AC_ENC_INDEX ( run , 65 ) ] ;
else score += last_length [ UNI_AC_ENC_INDEX ( run + run2 + 1 , next_level ) ] - last_length [ UNI_AC_ENC_INDEX ( run2 , next_level ) ] - length [ UNI_AC_ENC_INDEX ( run , 65 ) ] ;
}
else {
score += - last_length [ UNI_AC_ENC_INDEX ( run , 65 ) ] ;
if ( prev_level ) {
score += last_length [ UNI_AC_ENC_INDEX ( prev_run , prev_level ) ] - length [ UNI_AC_ENC_INDEX ( prev_run , prev_level ) ] ;
}
}
}
score *= lambda ;
unquant_change = new_coeff - old_coeff ;
assert ( ( score < 100 * lambda && score > - 100 * lambda ) || lambda == 0 ) ;
score += s -> dsp . try_8x8basis ( rem , weight , basis [ j ] , unquant_change ) ;
if ( score < best_score ) {
best_score = score ;
best_coeff = i ;
best_change = change ;
best_unquant_change = unquant_change ;
}
}
if ( level ) {
prev_level = level + 64 ;
if ( prev_level & ( ~ 127 ) ) prev_level = 0 ;
prev_run = run ;
run = 0 ;
}
else {
run ++ ;
}
}
# ifdef REFINE_STATS STOP_TIMER ( "iterative step" ) }
# endif if ( best_change ) {
int j = perm_scantable [ best_coeff ] ;
block [ j ] += best_change ;
if ( best_coeff > last_non_zero ) {
last_non_zero = best_coeff ;
assert ( block [ j ] ) ;
# ifdef REFINE_STATS after_last ++ ;
# endif }
else {
# ifdef REFINE_STATS if ( block [ j ] ) {
if ( block [ j ] - best_change ) {
if ( FFABS ( block [ j ] ) > FFABS ( block [ j ] - best_change ) ) {
raise ++ ;
}
else {
lower ++ ;
}
}
else {
from_zero ++ ;
}
}
else {
to_zero ++ ;
}
# endif for ( ;
last_non_zero >= start_i ;
last_non_zero -- ) {
if ( block [ perm_scantable [ last_non_zero ] ] ) break ;
}
}
# ifdef REFINE_STATS count ++ ;
if ( 256 * 256 * 256 * 64 % count == 0 ) {
printf ( "after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n" , after_last , to_zero , from_zero , raise , lower , messed_sign , s -> mb_x , s -> mb_y , s -> picture_number ) ;
}
# endif run = 0 ;
rle_index = 0 ;
for ( i = start_i ;
i <= last_non_zero ;
i ++ ) {
int j = perm_scantable [ i ] ;
const int level = block [ j ] ;
if ( level ) {
run_tab [ rle_index ++ ] = run ;
run = 0 ;
}
else {
run ++ ;
}
}
s -> dsp . add_8x8basis ( rem , basis [ j ] , best_unquant_change ) ;
}
else {
break ;
}
}
# ifdef REFINE_STATS if ( last_non_zero > 0 ) {
STOP_TIMER ( "iterative search" ) }
}
# endif return last_non_zero ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int change_to_newfile ( const char * filename , const char * old_ext , const char * new_ext , myf MyFlags ) {
char old_filename [ FN_REFLEN ] , new_filename [ FN_REFLEN ] ;
( void ) fn_format ( old_filename , filename , "" , old_ext , 2 + 4 + 32 ) ;
return my_redel ( old_filename , fn_format ( new_filename , old_filename , "" , new_ext , 2 + 4 ) , MYF ( MY_WME | MY_LINK_WARNING | MyFlags ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int qemuMonitorJSONGetBlockJobInfo ( virJSONValuePtr reply , const char * device , virDomainBlockJobInfoPtr info ) {
virJSONValuePtr data ;
int nr_results , i ;
if ( ! info ) return - 1 ;
if ( ( data = virJSONValueObjectGet ( reply , "return" ) ) == NULL ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "reply was missing return data" ) ) ;
return - 1 ;
}
if ( data -> type != VIR_JSON_TYPE_ARRAY ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "urecognized format of block job information" ) ) ;
return - 1 ;
}
if ( ( nr_results = virJSONValueArraySize ( data ) ) < 0 ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "unable to determine array size" ) ) ;
return - 1 ;
}
for ( i = 0 ;
i < nr_results ;
i ++ ) {
virJSONValuePtr entry = virJSONValueArrayGet ( data , i ) ;
if ( ! entry ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "missing array element" ) ) ;
return - 1 ;
}
if ( qemuMonitorJSONGetBlockJobInfoOne ( entry , device , info ) == 0 ) return 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static UChar32 ucnv_getNextUChar_UTF8 ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
UConverter * cnv ;
const uint8_t * sourceInitial ;
const uint8_t * source ;
uint16_t extraBytesToWrite ;
uint8_t myByte ;
UChar32 ch ;
int8_t i , isLegalSequence ;
cnv = args -> converter ;
sourceInitial = source = ( const uint8_t * ) args -> source ;
if ( source >= ( const uint8_t * ) args -> sourceLimit ) {
* err = U_INDEX_OUTOFBOUNDS_ERROR ;
return 0xffff ;
}
myByte = ( uint8_t ) * ( source ++ ) ;
if ( myByte < 0x80 ) {
args -> source = ( const char * ) source ;
return ( UChar32 ) myByte ;
}
extraBytesToWrite = ( uint16_t ) bytesFromUTF8 [ myByte ] ;
if ( extraBytesToWrite == 0 ) {
cnv -> toUBytes [ 0 ] = myByte ;
cnv -> toULength = 1 ;
* err = U_ILLEGAL_CHAR_FOUND ;
args -> source = ( const char * ) source ;
return 0xffff ;
}
if ( ( ( const char * ) source + extraBytesToWrite - 1 ) > args -> sourceLimit ) {
cnv -> toUBytes [ 0 ] = myByte ;
i = 1 ;
* err = U_TRUNCATED_CHAR_FOUND ;
while ( source < ( const uint8_t * ) args -> sourceLimit ) {
if ( U8_IS_TRAIL ( myByte = * source ) ) {
cnv -> toUBytes [ i ++ ] = myByte ;
++ source ;
}
else {
* err = U_ILLEGAL_CHAR_FOUND ;
break ;
}
}
cnv -> toULength = i ;
args -> source = ( const char * ) source ;
return 0xffff ;
}
isLegalSequence = 1 ;
ch = myByte << 6 ;
switch ( extraBytesToWrite ) {
case 6 : ch += ( myByte = * source ) ;
ch <<= 6 ;
if ( ! U8_IS_TRAIL ( myByte ) ) {
isLegalSequence = 0 ;
break ;
}
++ source ;
U_FALLTHROUGH ;
case 5 : ch += ( myByte = * source ) ;
ch <<= 6 ;
if ( ! U8_IS_TRAIL ( myByte ) ) {
isLegalSequence = 0 ;
break ;
}
++ source ;
U_FALLTHROUGH ;
case 4 : ch += ( myByte = * source ) ;
ch <<= 6 ;
if ( ! U8_IS_TRAIL ( myByte ) ) {
isLegalSequence = 0 ;
break ;
}
++ source ;
U_FALLTHROUGH ;
case 3 : ch += ( myByte = * source ) ;
ch <<= 6 ;
if ( ! U8_IS_TRAIL ( myByte ) ) {
isLegalSequence = 0 ;
break ;
}
++ source ;
U_FALLTHROUGH ;
case 2 : ch += ( myByte = * source ) ;
if ( ! U8_IS_TRAIL ( myByte ) ) {
isLegalSequence = 0 ;
break ;
}
++ source ;
}
;
ch -= offsetsFromUTF8 [ extraBytesToWrite ] ;
args -> source = ( const char * ) source ;
if ( isLegalSequence && ( uint32_t ) ch <= MAXIMUM_UTF && ( uint32_t ) ch >= utf8_minChar32 [ extraBytesToWrite ] && ! U_IS_SURROGATE ( ch ) ) {
return ch ;
}
for ( i = 0 ;
sourceInitial < source ;
++ i ) {
cnv -> toUBytes [ i ] = * sourceInitial ++ ;
}
cnv -> toULength = i ;
* err = U_ILLEGAL_CHAR_FOUND ;
return 0xffff ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void SRP_user_pwd_free ( SRP_user_pwd * user_pwd ) {
if ( user_pwd == NULL ) return ;
BN_free ( user_pwd -> s ) ;
BN_clear_free ( user_pwd -> v ) ;
OPENSSL_free ( user_pwd -> id ) ;
OPENSSL_free ( user_pwd -> info ) ;
OPENSSL_free ( user_pwd ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static struct sk_buff * pfkey_xfrm_policy2msg_prep ( const struct xfrm_policy * xp ) {
struct sk_buff * skb ;
int size ;
size = pfkey_xfrm_policy2msg_size ( xp ) ;
skb = alloc_skb ( size + 16 , GFP_ATOMIC ) ;
if ( skb == NULL ) return ERR_PTR ( - ENOBUFS ) ;
return skb ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void saturate_output_float ( COOKContext * q , float * out ) {
q -> dsp . vector_clipf ( out , q -> mono_mdct_output + q -> samples_per_channel , - 1.0f , 1.0f , FFALIGN ( q -> samples_per_channel , 8 ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void s390_init ( ram_addr_t ram_size , const char * boot_device , const char * kernel_filename , const char * kernel_cmdline , const char * initrd_filename , const char * cpu_model ) {
CPUState * env = NULL ;
ram_addr_t ram_addr ;
ram_addr_t kernel_size = 0 ;
ram_addr_t initrd_offset ;
ram_addr_t initrd_size = 0 ;
int i ;
if ( ! kvm_enabled ( ) ) {
fprintf ( stderr , "The S390 target only works with KVM enabled\n" ) ;
exit ( 1 ) ;
}
s390_bus = s390_virtio_bus_init ( & ram_size ) ;
ram_addr = qemu_ram_alloc ( ram_size ) ;
cpu_register_physical_memory ( 0 , ram_size , ram_addr ) ;
if ( cpu_model == NULL ) {
cpu_model = "host" ;
}
ipi_states = qemu_malloc ( sizeof ( CPUState * ) * smp_cpus ) ;
for ( i = 0 ;
i < smp_cpus ;
i ++ ) {
CPUState * tmp_env ;
tmp_env = cpu_init ( cpu_model ) ;
if ( ! env ) {
env = tmp_env ;
}
ipi_states [ i ] = tmp_env ;
tmp_env -> halted = 1 ;
tmp_env -> exception_index = EXCP_HLT ;
}
env -> halted = 0 ;
env -> exception_index = 0 ;
if ( kernel_filename ) {
kernel_size = load_image ( kernel_filename , qemu_get_ram_ptr ( 0 ) ) ;
if ( lduw_phys ( KERN_IMAGE_START ) != 0x0dd0 ) {
fprintf ( stderr , "Specified image is not an s390 boot image\n" ) ;
exit ( 1 ) ;
}
cpu_synchronize_state ( env ) ;
env -> psw . addr = KERN_IMAGE_START ;
env -> psw . mask = 0x0000000180000000ULL ;
}
if ( initrd_filename ) {
initrd_offset = INITRD_START ;
while ( kernel_size + 0x100000 > initrd_offset ) {
initrd_offset += 0x100000 ;
}
initrd_size = load_image ( initrd_filename , qemu_get_ram_ptr ( initrd_offset ) ) ;
stq_phys ( INITRD_PARM_START , initrd_offset ) ;
stq_phys ( INITRD_PARM_SIZE , initrd_size ) ;
}
if ( kernel_cmdline ) {
cpu_physical_memory_rw ( KERN_PARM_AREA , ( uint8_t * ) kernel_cmdline , strlen ( kernel_cmdline ) , 1 ) ;
}
for ( i = 0 ;
i < nb_nics ;
i ++ ) {
NICInfo * nd = & nd_table [ i ] ;
DeviceState * dev ;
if ( ! nd -> model ) {
nd -> model = qemu_strdup ( "virtio" ) ;
}
if ( strcmp ( nd -> model , "virtio" ) ) {
fprintf ( stderr , "S390 only supports VirtIO nics\n" ) ;
exit ( 1 ) ;
}
dev = qdev_create ( ( BusState * ) s390_bus , "virtio-net-s390" ) ;
qdev_set_nic_properties ( dev , nd ) ;
qdev_init_nofail ( dev ) ;
}
for ( i = 0 ;
i < MAX_BLK_DEVS ;
i ++ ) {
DriveInfo * dinfo ;
DeviceState * dev ;
dinfo = drive_get ( IF_IDE , 0 , i ) ;
if ( ! dinfo ) {
continue ;
}
dev = qdev_create ( ( BusState * ) s390_bus , "virtio-blk-s390" ) ;
qdev_prop_set_drive ( dev , "drive" , dinfo ) ;
qdev_init_nofail ( dev ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_view_insert ( ) {
MYSQL_STMT * insert_stmt , * select_stmt ;
int rc , i ;
MYSQL_BIND my_bind [ 1 ] ;
int my_val = 0 ;
ulong my_length = 0L ;
long my_null = 0L ;
const char * query = "insert into v1 values (?)" ;
myheader ( "test_view_insert" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS t1,v1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP VIEW IF EXISTS t1,v1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create table t1 (a int, primary key (a))" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create view v1 as select a from t1 where a>=1" ) ;
myquery ( rc ) ;
insert_stmt = mysql_stmt_init ( mysql ) ;
rc = mysql_stmt_prepare ( insert_stmt , query , strlen ( query ) ) ;
check_execute ( insert_stmt , rc ) ;
query = "select * from t1" ;
select_stmt = mysql_stmt_init ( mysql ) ;
rc = mysql_stmt_prepare ( select_stmt , query , strlen ( query ) ) ;
check_execute ( select_stmt , rc ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . buffer = ( char * ) & my_val ;
my_bind [ 0 ] . length = & my_length ;
my_bind [ 0 ] . is_null = ( char * ) & my_null ;
rc = mysql_stmt_bind_param ( insert_stmt , my_bind ) ;
check_execute ( insert_stmt , rc ) ;
for ( i = 0 ;
i < 3 ;
i ++ ) {
int rowcount = 0 ;
my_val = i ;
rc = mysql_stmt_execute ( insert_stmt ) ;
check_execute ( insert_stmt , rc ) ;
rc = mysql_stmt_execute ( select_stmt ) ;
check_execute ( select_stmt , rc ) ;
rowcount = ( int ) my_process_stmt_result ( select_stmt ) ;
DIE_UNLESS ( ( i + 1 ) == rowcount ) ;
}
mysql_stmt_close ( insert_stmt ) ;
mysql_stmt_close ( select_stmt ) ;
rc = mysql_query ( mysql , "DROP VIEW v1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP TABLE t1" ) ;
myquery ( rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static xmlLinkPtr xmlListLinkReverseSearch ( xmlListPtr l , void * data ) {
xmlLinkPtr lk ;
if ( l == NULL ) return ( NULL ) ;
lk = xmlListHigherSearch ( l , data ) ;
if ( lk == l -> sentinel ) return NULL ;
else {
if ( l -> linkCompare ( lk -> data , data ) == 0 ) return lk ;
return NULL ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static struct cvec * range ( struct vars * v , celt a , celt b , int cases ) {
int nchrs ;
struct cvec * cv ;
celt c , cc ;
if ( a != b && ! before ( a , b ) ) {
ERR ( REG_ERANGE ) ;
return NULL ;
}
if ( ! cases ) {
cv = getcvec ( v , 0 , 1 ) ;
NOERRN ( ) ;
addrange ( cv , a , b ) ;
return cv ;
}
nchrs = b - a + 1 ;
if ( nchrs <= 0 || nchrs > 100000 ) nchrs = 100000 ;
cv = getcvec ( v , nchrs , 1 ) ;
NOERRN ( ) ;
addrange ( cv , a , b ) ;
for ( c = a ;
c <= b ;
c ++ ) {
cc = pg_wc_tolower ( ( chr ) c ) ;
if ( cc != c && ( before ( cc , a ) || before ( b , cc ) ) ) {
if ( cv -> nchrs >= cv -> chrspace ) {
ERR ( REG_ETOOBIG ) ;
return NULL ;
}
addchr ( cv , cc ) ;
}
cc = pg_wc_toupper ( ( chr ) c ) ;
if ( cc != c && ( before ( cc , a ) || before ( b , cc ) ) ) {
if ( cv -> nchrs >= cv -> chrspace ) {
ERR ( REG_ETOOBIG ) ;
return NULL ;
}
addchr ( cv , cc ) ;
}
if ( CANCEL_REQUESTED ( v -> re ) ) {
ERR ( REG_CANCEL ) ;
return NULL ;
}
}
return cv ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_channel ( RALFContext * ctx , GetBitContext * gb , int ch , int length , int mode , int bits ) {
int i , t ;
int code_params ;
VLCSet * set = ctx -> sets + mode ;
VLC * code_vlc ;
int range , range2 , add_bits ;
int * dst = ctx -> channel_data [ ch ] ;
ctx -> filter_params = get_vlc2 ( gb , set -> filter_params . table , 9 , 2 ) ;
ctx -> filter_bits = ( ctx -> filter_params - 2 ) >> 6 ;
ctx -> filter_length = ctx -> filter_params - ( ctx -> filter_bits << 6 ) - 1 ;
if ( ctx -> filter_params == FILTER_RAW ) {
for ( i = 0 ;
i < length ;
i ++ ) dst [ i ] = get_bits ( gb , bits ) ;
ctx -> bias [ ch ] = 0 ;
return 0 ;
}
ctx -> bias [ ch ] = get_vlc2 ( gb , set -> bias . table , 9 , 2 ) ;
ctx -> bias [ ch ] = extend_code ( gb , ctx -> bias [ ch ] , 127 , 4 ) ;
if ( ctx -> filter_params == FILTER_NONE ) {
memset ( dst , 0 , sizeof ( * dst ) * length ) ;
return 0 ;
}
if ( ctx -> filter_params > 1 ) {
int cmode = 0 , coeff = 0 ;
VLC * vlc = set -> filter_coeffs [ ctx -> filter_bits ] + 5 ;
add_bits = ctx -> filter_bits ;
for ( i = 0 ;
i < ctx -> filter_length ;
i ++ ) {
t = get_vlc2 ( gb , vlc [ cmode ] . table , vlc [ cmode ] . bits , 2 ) ;
t = extend_code ( gb , t , 21 , add_bits ) ;
if ( ! cmode ) coeff -= 12 << add_bits ;
coeff = t - coeff ;
ctx -> filter [ i ] = coeff ;
cmode = coeff >> add_bits ;
if ( cmode < 0 ) {
cmode = - 1 - av_log2 ( - cmode ) ;
if ( cmode < - 5 ) cmode = - 5 ;
}
else if ( cmode > 0 ) {
cmode = 1 + av_log2 ( cmode ) ;
if ( cmode > 5 ) cmode = 5 ;
}
}
}
code_params = get_vlc2 ( gb , set -> coding_mode . table , set -> coding_mode . bits , 2 ) ;
if ( code_params >= 15 ) {
add_bits = av_clip ( ( code_params / 5 - 3 ) / 2 , 0 , 10 ) ;
if ( add_bits > 9 && ( code_params % 5 ) != 2 ) add_bits -- ;
range = 10 ;
range2 = 21 ;
code_vlc = set -> long_codes + code_params - 15 ;
}
else {
add_bits = 0 ;
range = 6 ;
range2 = 13 ;
code_vlc = set -> short_codes + code_params ;
}
for ( i = 0 ;
i < length ;
i += 2 ) {
int code1 , code2 ;
t = get_vlc2 ( gb , code_vlc -> table , code_vlc -> bits , 2 ) ;
code1 = t / range2 ;
code2 = t % range2 ;
dst [ i ] = extend_code ( gb , code1 , range , 0 ) << add_bits ;
dst [ i + 1 ] = extend_code ( gb , code2 , range , 0 ) << add_bits ;
if ( add_bits ) {
dst [ i ] |= get_bits ( gb , add_bits ) ;
dst [ i + 1 ] |= get_bits ( gb , add_bits ) ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
proto_item * proto_tree_add_item_ret_length ( proto_tree * tree , int hfindex , tvbuff_t * tvb , const gint start , gint length , const guint encoding , gint * lenretval ) {
register header_field_info * hfinfo ;
PROTO_REGISTRAR_GET_NTH ( hfindex , hfinfo ) ;
return proto_tree_add_item_new_ret_length ( tree , hfinfo , tvb , start , length , encoding , lenretval ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void kadm5_set_use_password_server ( void ) {
use_password_server = 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * composite_memcpy ( tvbuff_t * tvb , void * _target , guint abs_offset , guint abs_length ) {
struct tvb_composite * composite_tvb = ( struct tvb_composite * ) tvb ;
guint8 * target = ( guint8 * ) _target ;
guint i , num_members ;
tvb_comp_t * composite ;
tvbuff_t * member_tvb = NULL ;
guint member_offset , member_length ;
GSList * slist ;
composite = & composite_tvb -> composite ;
num_members = g_slist_length ( composite -> tvbs ) ;
for ( i = 0 ;
i < num_members ;
i ++ ) {
if ( abs_offset <= composite -> end_offsets [ i ] ) {
slist = g_slist_nth ( composite -> tvbs , i ) ;
member_tvb = ( tvbuff_t * ) slist -> data ;
break ;
}
}
if ( ! member_tvb ) {
DISSECTOR_ASSERT ( abs_offset == tvb -> length && abs_length == 0 ) ;
return target ;
}
member_offset = abs_offset - composite -> start_offsets [ i ] ;
if ( tvb_bytes_exist ( member_tvb , member_offset , abs_length ) ) {
DISSECTOR_ASSERT ( ! tvb -> real_data ) ;
return tvb_memcpy ( member_tvb , target , member_offset , abs_length ) ;
}
else {
member_length = tvb_captured_length_remaining ( member_tvb , member_offset ) ;
DISSECTOR_ASSERT ( member_length > 0 ) ;
tvb_memcpy ( member_tvb , target , member_offset , member_length ) ;
abs_offset += member_length ;
abs_length -= member_length ;
if ( abs_length > 0 ) {
composite_memcpy ( tvb , target + member_length , abs_offset , abs_length ) ;
}
return target ;
}
DISSECTOR_ASSERT_NOT_REACHED ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
REGRESSION_TEST ( SDK_API_TSContSchedule ) ( RegressionTest * test , int , int * pstatus ) {
* pstatus = REGRESSION_TEST_INPROGRESS ;
SDK_ContSchedule_test = test ;
SDK_ContSchedule_pstatus = pstatus ;
TSCont contp = TSContCreate ( cont_schedule_handler , TSMutexCreate ( ) ) ;
TSCont contp2 = TSContCreate ( cont_schedule_handler , TSMutexCreate ( ) ) ;
TSContSchedule ( contp , 0 , TS_THREAD_POOL_DEFAULT ) ;
TSContSchedule ( contp2 , 10 , TS_THREAD_POOL_DEFAULT ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void xps_deobfuscate_font_resource ( xps_document * doc , xps_part * part ) {
unsigned char buf [ 33 ] ;
unsigned char key [ 16 ] ;
char * p ;
int i ;
p = strrchr ( part -> name , '/' ) ;
if ( ! p ) p = part -> name ;
for ( i = 0 ;
i < 32 && * p ;
p ++ ) {
if ( ishex ( * p ) ) buf [ i ++ ] = * p ;
}
buf [ i ] = 0 ;
if ( i != 32 ) {
fz_warn ( doc -> ctx , "cannot extract GUID from obfuscated font part name" ) ;
return ;
}
for ( i = 0 ;
i < 16 ;
i ++ ) key [ i ] = unhex ( buf [ i * 2 + 0 ] ) * 16 + unhex ( buf [ i * 2 + 1 ] ) ;
for ( i = 0 ;
i < 16 ;
i ++ ) {
part -> data [ i ] ^= key [ 15 - i ] ;
part -> data [ i + 16 ] ^= key [ 15 - i ] ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileObject , fpassthru ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
RETURN_LONG ( php_stream_passthru ( intern -> u . file . stream ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorJSONGetPtyPaths ( qemuMonitorPtr mon , virHashTablePtr paths ) {
int ret ;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand ( "query-chardev" , NULL ) ;
virJSONValuePtr reply = NULL ;
if ( ! cmd ) return - 1 ;
ret = qemuMonitorJSONCommand ( mon , cmd , & reply ) ;
if ( ret == 0 ) ret = qemuMonitorJSONCheckError ( cmd , reply ) ;
if ( ret == 0 ) ret = qemuMonitorJSONExtractPtyPaths ( reply , paths ) ;
virJSONValueFree ( cmd ) ;
virJSONValueFree ( reply ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int libopenjpeg_matches_pix_fmt ( const opj_image_t * img , enum AVPixelFormat pix_fmt ) {
const AVPixFmtDescriptor * desc = av_pix_fmt_desc_get ( pix_fmt ) ;
int match = 1 ;
if ( desc -> nb_components != img -> numcomps ) {
return 0 ;
}
switch ( desc -> nb_components ) {
case 4 : match = match && desc -> comp [ 3 ] . depth_minus1 + 1 >= img -> comps [ 3 ] . prec && 1 == img -> comps [ 3 ] . dx && 1 == img -> comps [ 3 ] . dy ;
case 3 : match = match && desc -> comp [ 2 ] . depth_minus1 + 1 >= img -> comps [ 2 ] . prec && 1 << desc -> log2_chroma_w == img -> comps [ 2 ] . dx && 1 << desc -> log2_chroma_h == img -> comps [ 2 ] . dy ;
case 2 : match = match && desc -> comp [ 1 ] . depth_minus1 + 1 >= img -> comps [ 1 ] . prec && 1 << desc -> log2_chroma_w == img -> comps [ 1 ] . dx && 1 << desc -> log2_chroma_h == img -> comps [ 1 ] . dy ;
case 1 : match = match && desc -> comp [ 0 ] . depth_minus1 + 1 >= img -> comps [ 0 ] . prec && 1 == img -> comps [ 0 ] . dx && 1 == img -> comps [ 0 ] . dy ;
default : break ;
}
return match ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void mpi_clear ( MPI a ) {
a -> nlimbs = 0 ;
a -> nbits = 0 ;
a -> flags = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_PictureReference ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_PictureReference , PictureReference_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int virtio_blk_init_pci ( PCIDevice * pci_dev ) {
VirtIOPCIProxy * proxy = DO_UPCAST ( VirtIOPCIProxy , pci_dev , pci_dev ) ;
VirtIODevice * vdev ;
if ( proxy -> class_code != PCI_CLASS_STORAGE_SCSI && proxy -> class_code != PCI_CLASS_STORAGE_OTHER ) proxy -> class_code = PCI_CLASS_STORAGE_SCSI ;
if ( ! proxy -> dinfo ) {
qemu_error ( "virtio-blk-pci: drive property not set\n" ) ;
return - 1 ;
}
vdev = virtio_blk_init ( & pci_dev -> qdev , proxy -> dinfo ) ;
vdev -> nvectors = proxy -> nvectors ;
virtio_init_pci ( proxy , vdev , PCI_VENDOR_ID_REDHAT_QUMRANET , PCI_DEVICE_ID_VIRTIO_BLOCK , proxy -> class_code , 0x00 ) ;
proxy -> nvectors = vdev -> nvectors ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vdpau_h264_clear_rf ( VdpReferenceFrameH264 * rf ) {
rf -> surface = VDP_INVALID_HANDLE ;
rf -> is_long_term = VDP_FALSE ;
rf -> top_is_reference = VDP_FALSE ;
rf -> bottom_is_reference = VDP_FALSE ;
rf -> field_order_cnt [ 0 ] = 0 ;
rf -> field_order_cnt [ 1 ] = 0 ;
rf -> frame_idx = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool has_lock_conflicts ( TocEntry * te1 , TocEntry * te2 ) {
int j , k ;
for ( j = 0 ;
j < te1 -> nLockDeps ;
j ++ ) {
for ( k = 0 ;
k < te2 -> nDeps ;
k ++ ) {
if ( te1 -> lockDeps [ j ] == te2 -> dependencies [ k ] ) return true ;
}
}
return false ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int read_inter_segment_id ( VP9_COMMON * const cm , MACROBLOCKD * const xd , int mi_row , int mi_col , vp9_reader * r ) {
struct segmentation * const seg = & cm -> seg ;
MB_MODE_INFO * const mbmi = & xd -> mi [ 0 ] -> mbmi ;
const BLOCK_SIZE bsize = mbmi -> sb_type ;
int predicted_segment_id , segment_id ;
if ( ! seg -> enabled ) return 0 ;
predicted_segment_id = vp9_get_segment_id ( cm , cm -> last_frame_seg_map , bsize , mi_row , mi_col ) ;
if ( ! seg -> update_map ) return predicted_segment_id ;
if ( seg -> temporal_update ) {
const vp9_prob pred_prob = vp9_get_pred_prob_seg_id ( seg , xd ) ;
mbmi -> seg_id_predicted = vp9_read ( r , pred_prob ) ;
segment_id = mbmi -> seg_id_predicted ? predicted_segment_id : read_segment_id ( r , seg ) ;
}
else {
segment_id = read_segment_id ( r , seg ) ;
}
set_segment_id ( cm , bsize , mi_row , mi_col , segment_id ) ;
return segment_id ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline __uint32_t __uint32_identity ( __uint32_t __x ) {
return __x ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void * hb_shape_plan_get_user_data ( hb_shape_plan_t * shape_plan , hb_user_data_key_t * key ) {
return hb_object_get_user_data ( shape_plan , key ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_copy_gstate ( fz_context * ctx , pdf_gstate * gs , pdf_gstate * old ) {
pdf_drop_gstate ( ctx , gs ) ;
* gs = * old ;
pdf_keep_gstate ( ctx , gs ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int32_t u_scanf_integer_handler ( UFILE * input , u_scanf_spec_info * info , ufmt_args * args , const UChar * fmt , int32_t * fmtConsumed , int32_t * argConverted ) {
int32_t len ;
void * num = ( void * ) ( args [ 0 ] . ptrValue ) ;
UNumberFormat * format ;
int32_t parsePos = 0 ;
int32_t skipped ;
UErrorCode status = U_ZERO_ERROR ;
int64_t result ;
skipped = u_scanf_skip_leading_ws ( input , info -> fPadChar ) ;
ufile_fill_uchar_buffer ( input ) ;
len = ( int32_t ) ( input -> str . fLimit - input -> str . fPos ) ;
if ( info -> fWidth != - 1 ) len = ufmt_min ( len , info -> fWidth ) ;
format = u_locbund_getNumberFormat ( & input -> str . fBundle , UNUM_DECIMAL ) ;
if ( format == 0 ) return 0 ;
skipped += u_scanf_skip_leading_positive_sign ( input , format , & status ) ;
result = unum_parseInt64 ( format , input -> str . fPos , len , & parsePos , & status ) ;
if ( ! info -> fSkipArg ) {
if ( info -> fIsShort ) * ( int16_t * ) num = ( int16_t ) ( UINT16_MAX & result ) ;
else if ( info -> fIsLongLong ) * ( int64_t * ) num = result ;
else * ( int32_t * ) num = ( int32_t ) ( UINT32_MAX & result ) ;
}
input -> str . fPos += parsePos ;
* argConverted = ! info -> fSkipArg ;
return parsePos + skipped ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint16 de_tp_loop_ack ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len _U_ , gchar * add_string _U_ , int string_len _U_ ) {
guint32 curr_offset = offset ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_channel_coding30 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_loop_mechanism0E , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_multislot_tch , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset += 1 ;
return ( curr_offset - offset ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void Init_ossl_asn1 ( void ) {
VALUE ary ;
int i ;
# if 0 mOSSL = rb_define_module ( "OpenSSL" ) ;
eOSSLError = rb_define_class_under ( mOSSL , "OpenSSLError" , rb_eStandardError ) ;
# endif sym_UNIVERSAL = ID2SYM ( rb_intern_const ( "UNIVERSAL" ) ) ;
sym_CONTEXT_SPECIFIC = ID2SYM ( rb_intern_const ( "CONTEXT_SPECIFIC" ) ) ;
sym_APPLICATION = ID2SYM ( rb_intern_const ( "APPLICATION" ) ) ;
sym_PRIVATE = ID2SYM ( rb_intern_const ( "PRIVATE" ) ) ;
sym_EXPLICIT = ID2SYM ( rb_intern_const ( "EXPLICIT" ) ) ;
sym_IMPLICIT = ID2SYM ( rb_intern_const ( "IMPLICIT" ) ) ;
sivVALUE = rb_intern ( "@value" ) ;
sivTAG = rb_intern ( "@tag" ) ;
sivTAGGING = rb_intern ( "@tagging" ) ;
sivTAG_CLASS = rb_intern ( "@tag_class" ) ;
sivINFINITE_LENGTH = rb_intern ( "@infinite_length" ) ;
sivUNUSED_BITS = rb_intern ( "@unused_bits" ) ;
mASN1 = rb_define_module_under ( mOSSL , "ASN1" ) ;
eASN1Error = rb_define_class_under ( mASN1 , "ASN1Error" , eOSSLError ) ;
rb_define_module_function ( mASN1 , "traverse" , ossl_asn1_traverse , 1 ) ;
rb_define_module_function ( mASN1 , "decode" , ossl_asn1_decode , 1 ) ;
rb_define_module_function ( mASN1 , "decode_all" , ossl_asn1_decode_all , 1 ) ;
ary = rb_ary_new ( ) ;
rb_define_const ( mASN1 , "UNIVERSAL_TAG_NAME" , ary ) ;
for ( i = 0 ;
i < ossl_asn1_info_size ;
i ++ ) {
if ( ossl_asn1_info [ i ] . name [ 0 ] == '[' ) continue ;
rb_define_const ( mASN1 , ossl_asn1_info [ i ] . name , INT2NUM ( i ) ) ;
rb_ary_store ( ary , i , rb_str_new2 ( ossl_asn1_info [ i ] . name ) ) ;
}
cASN1Data = rb_define_class_under ( mASN1 , "ASN1Data" , rb_cObject ) ;
rb_attr ( cASN1Data , rb_intern ( "value" ) , 1 , 1 , 0 ) ;
rb_attr ( cASN1Data , rb_intern ( "tag" ) , 1 , 1 , 0 ) ;
rb_attr ( cASN1Data , rb_intern ( "tag_class" ) , 1 , 1 , 0 ) ;
rb_attr ( cASN1Data , rb_intern ( "infinite_length" ) , 1 , 1 , 0 ) ;
rb_define_method ( cASN1Data , "initialize" , ossl_asn1data_initialize , 3 ) ;
rb_define_method ( cASN1Data , "to_der" , ossl_asn1data_to_der , 0 ) ;
cASN1Primitive = rb_define_class_under ( mASN1 , "Primitive" , cASN1Data ) ;
rb_attr ( cASN1Primitive , rb_intern ( "tagging" ) , 1 , 1 , Qtrue ) ;
rb_undef_method ( cASN1Primitive , "infinite_length=" ) ;
rb_define_method ( cASN1Primitive , "initialize" , ossl_asn1_initialize , - 1 ) ;
rb_define_method ( cASN1Primitive , "to_der" , ossl_asn1prim_to_der , 0 ) ;
cASN1Constructive = rb_define_class_under ( mASN1 , "Constructive" , cASN1Data ) ;
rb_include_module ( cASN1Constructive , rb_mEnumerable ) ;
rb_attr ( cASN1Constructive , rb_intern ( "tagging" ) , 1 , 1 , Qtrue ) ;
rb_define_method ( cASN1Constructive , "initialize" , ossl_asn1_initialize , - 1 ) ;
rb_define_method ( cASN1Constructive , "to_der" , ossl_asn1cons_to_der , 0 ) ;
rb_define_method ( cASN1Constructive , "each" , ossl_asn1cons_each , 0 ) ;
# define OSSL_ASN1_DEFINE_CLASS ( name , super ) do {
cASN1 ## name = rb_define_class_under ( mASN1 , # name , cASN1 ## super ) ;
rb_define_module_function ( mASN1 , # name , ossl_asn1_ ## name , - 1 ) ;
\ }
while ( 0 ) OSSL_ASN1_DEFINE_CLASS ( Boolean , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( Integer , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( Enumerated , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( BitString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( OctetString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( UTF8String , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( NumericString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( PrintableString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( T61String , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( VideotexString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( IA5String , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( GraphicString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( ISO64String , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( GeneralString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( UniversalString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( BMPString , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( Null , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( ObjectId , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( UTCTime , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( GeneralizedTime , Primitive ) ;
OSSL_ASN1_DEFINE_CLASS ( Sequence , Constructive ) ;
OSSL_ASN1_DEFINE_CLASS ( Set , Constructive ) ;
OSSL_ASN1_DEFINE_CLASS ( EndOfContent , Data ) ;
# if 0 cASN1ObjectId = rb_define_class_under ( mASN1 , "ObjectId" , cASN1Primitive ) ;
# endif rb_define_singleton_method ( cASN1ObjectId , "register" , ossl_asn1obj_s_register , 3 ) ;
rb_define_method ( cASN1ObjectId , "sn" , ossl_asn1obj_get_sn , 0 ) ;
rb_define_method ( cASN1ObjectId , "ln" , ossl_asn1obj_get_ln , 0 ) ;
rb_define_method ( cASN1ObjectId , "oid" , ossl_asn1obj_get_oid , 0 ) ;
rb_define_alias ( cASN1ObjectId , "short_name" , "sn" ) ;
rb_define_alias ( cASN1ObjectId , "long_name" , "ln" ) ;
rb_attr ( cASN1BitString , rb_intern ( "unused_bits" ) , 1 , 1 , 0 ) ;
rb_define_method ( cASN1EndOfContent , "initialize" , ossl_asn1eoc_initialize , 0 ) ;
class_tag_map = rb_hash_new ( ) ;
rb_hash_aset ( class_tag_map , cASN1EndOfContent , INT2NUM ( V_ASN1_EOC ) ) ;
rb_hash_aset ( class_tag_map , cASN1Boolean , INT2NUM ( V_ASN1_BOOLEAN ) ) ;
rb_hash_aset ( class_tag_map , cASN1Integer , INT2NUM ( V_ASN1_INTEGER ) ) ;
rb_hash_aset ( class_tag_map , cASN1BitString , INT2NUM ( V_ASN1_BIT_STRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1OctetString , INT2NUM ( V_ASN1_OCTET_STRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1Null , INT2NUM ( V_ASN1_NULL ) ) ;
rb_hash_aset ( class_tag_map , cASN1ObjectId , INT2NUM ( V_ASN1_OBJECT ) ) ;
rb_hash_aset ( class_tag_map , cASN1Enumerated , INT2NUM ( V_ASN1_ENUMERATED ) ) ;
rb_hash_aset ( class_tag_map , cASN1UTF8String , INT2NUM ( V_ASN1_UTF8STRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1Sequence , INT2NUM ( V_ASN1_SEQUENCE ) ) ;
rb_hash_aset ( class_tag_map , cASN1Set , INT2NUM ( V_ASN1_SET ) ) ;
rb_hash_aset ( class_tag_map , cASN1NumericString , INT2NUM ( V_ASN1_NUMERICSTRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1PrintableString , INT2NUM ( V_ASN1_PRINTABLESTRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1T61String , INT2NUM ( V_ASN1_T61STRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1VideotexString , INT2NUM ( V_ASN1_VIDEOTEXSTRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1IA5String , INT2NUM ( V_ASN1_IA5STRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1UTCTime , INT2NUM ( V_ASN1_UTCTIME ) ) ;
rb_hash_aset ( class_tag_map , cASN1GeneralizedTime , INT2NUM ( V_ASN1_GENERALIZEDTIME ) ) ;
rb_hash_aset ( class_tag_map , cASN1GraphicString , INT2NUM ( V_ASN1_GRAPHICSTRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1ISO64String , INT2NUM ( V_ASN1_ISO64STRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1GeneralString , INT2NUM ( V_ASN1_GENERALSTRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1UniversalString , INT2NUM ( V_ASN1_UNIVERSALSTRING ) ) ;
rb_hash_aset ( class_tag_map , cASN1BMPString , INT2NUM ( V_ASN1_BMPSTRING ) ) ;
rb_global_variable ( & class_tag_map ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void update_vlc_state ( VlcState * const state , const int v ) {
int drift = state -> drift ;
int count = state -> count ;
state -> error_sum += FFABS ( v ) ;
drift += v ;
if ( count == 128 ) {
count >>= 1 ;
drift >>= 1 ;
state -> error_sum >>= 1 ;
}
count ++ ;
if ( drift <= - count ) {
if ( state -> bias > - 128 ) state -> bias -- ;
drift += count ;
if ( drift <= - count ) drift = - count + 1 ;
}
else if ( drift > 0 ) {
if ( state -> bias < 127 ) state -> bias ++ ;
drift -= count ;
if ( drift > 0 ) drift = 0 ;
}
state -> drift = drift ;
state -> count = count ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int tipc_nl_compat_sk_dump ( struct tipc_nl_compat_msg * msg , struct nlattr * * attrs ) {
int err ;
u32 sock_ref ;
struct nlattr * sock [ TIPC_NLA_SOCK_MAX + 1 ] ;
if ( ! attrs [ TIPC_NLA_SOCK ] ) return - EINVAL ;
err = nla_parse_nested ( sock , TIPC_NLA_SOCK_MAX , attrs [ TIPC_NLA_SOCK ] , NULL ) ;
if ( err ) return err ;
sock_ref = nla_get_u32 ( sock [ TIPC_NLA_SOCK_REF ] ) ;
tipc_tlv_sprintf ( msg -> rep , "%u:" , sock_ref ) ;
if ( sock [ TIPC_NLA_SOCK_CON ] ) {
u32 node ;
struct nlattr * con [ TIPC_NLA_CON_MAX + 1 ] ;
nla_parse_nested ( con , TIPC_NLA_CON_MAX , sock [ TIPC_NLA_SOCK_CON ] , NULL ) ;
node = nla_get_u32 ( con [ TIPC_NLA_CON_NODE ] ) ;
tipc_tlv_sprintf ( msg -> rep , " connected to <%u.%u.%u:%u>" , tipc_zone ( node ) , tipc_cluster ( node ) , tipc_node ( node ) , nla_get_u32 ( con [ TIPC_NLA_CON_SOCK ] ) ) ;
if ( con [ TIPC_NLA_CON_FLAG ] ) tipc_tlv_sprintf ( msg -> rep , " via {
%u,%u}
\n" , nla_get_u32 ( con [ TIPC_NLA_CON_TYPE ] ) , nla_get_u32 ( con [ TIPC_NLA_CON_INST ] ) ) ;
else tipc_tlv_sprintf ( msg -> rep , "\n" ) ;
}
else if ( sock [ TIPC_NLA_SOCK_HAS_PUBL ] ) {
tipc_tlv_sprintf ( msg -> rep , " bound to" ) ;
err = tipc_nl_compat_publ_dump ( msg , sock_ref ) ;
if ( err ) return err ;
}
tipc_tlv_sprintf ( msg -> rep , "\n" ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dvvideo_close ( AVCodecContext * c ) {
DVVideoContext * s = c -> priv_data ;
av_frame_unref ( & s -> picture ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( CrossOriginXHR , BackgroundPage ) {
ASSERT_TRUE ( StartFTPServer ( base : : FilePath ( kFtpDocRoot ) ) ) ;
ASSERT_TRUE ( RunExtensionTest ( "cross_origin_xhr/background_page" ) ) << message_ ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ff_get_qtpalette ( int codec_id , AVIOContext * pb , uint32_t * palette ) {
int tmp , bit_depth , color_table_id , greyscale , i ;
avio_seek ( pb , 82 , SEEK_CUR ) ;
tmp = avio_rb16 ( pb ) ;
bit_depth = tmp & 0x1F ;
greyscale = tmp & 0x20 ;
color_table_id = avio_rb16 ( pb ) ;
if ( greyscale && codec_id == AV_CODEC_ID_CINEPAK ) return 0 ;
if ( ( bit_depth == 1 || bit_depth == 2 || bit_depth == 4 || bit_depth == 8 ) ) {
int color_count , color_start , color_end ;
uint32_t a , r , g , b ;
if ( greyscale && bit_depth > 1 && color_table_id ) {
int color_index , color_dec ;
color_count = 1 << bit_depth ;
color_index = 255 ;
color_dec = 256 / ( color_count - 1 ) ;
for ( i = 0 ;
i < color_count ;
i ++ ) {
r = g = b = color_index ;
palette [ i ] = ( 0xFFU << 24 ) | ( r << 16 ) | ( g << 8 ) | ( b ) ;
color_index -= color_dec ;
if ( color_index < 0 ) color_index = 0 ;
}
}
else if ( color_table_id ) {
const uint8_t * color_table ;
color_count = 1 << bit_depth ;
if ( bit_depth == 1 ) color_table = ff_qt_default_palette_2 ;
else if ( bit_depth == 2 ) color_table = ff_qt_default_palette_4 ;
else if ( bit_depth == 4 ) color_table = ff_qt_default_palette_16 ;
else color_table = ff_qt_default_palette_256 ;
for ( i = 0 ;
i < color_count ;
i ++ ) {
r = color_table [ i * 3 + 0 ] ;
g = color_table [ i * 3 + 1 ] ;
b = color_table [ i * 3 + 2 ] ;
palette [ i ] = ( 0xFFU << 24 ) | ( r << 16 ) | ( g << 8 ) | ( b ) ;
}
}
else {
color_start = avio_rb32 ( pb ) ;
avio_rb16 ( pb ) ;
color_end = avio_rb16 ( pb ) ;
if ( ( color_start <= 255 ) && ( color_end <= 255 ) ) {
for ( i = color_start ;
i <= color_end ;
i ++ ) {
a = avio_r8 ( pb ) ;
avio_r8 ( pb ) ;
r = avio_r8 ( pb ) ;
avio_r8 ( pb ) ;
g = avio_r8 ( pb ) ;
avio_r8 ( pb ) ;
b = avio_r8 ( pb ) ;
avio_r8 ( pb ) ;
palette [ i ] = ( a << 24 ) | ( r << 16 ) | ( g << 8 ) | ( b ) ;
}
}
}
return 1 ;
}
return 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
ExprState * ExecInitExpr ( Expr * node , PlanState * parent ) {
ExprState * state ;
if ( node == NULL ) return NULL ;
check_stack_depth ( ) ;
switch ( nodeTag ( node ) ) {
case T_Var : if ( ( ( Var * ) node ) -> varattno == InvalidAttrNumber ) {
WholeRowVarExprState * wstate = makeNode ( WholeRowVarExprState ) ;
wstate -> parent = parent ;
wstate -> wrv_tupdesc = NULL ;
wstate -> wrv_junkFilter = NULL ;
state = ( ExprState * ) wstate ;
state -> evalfunc = ( ExprStateEvalFunc ) ExecEvalWholeRowVar ;
}
else {
state = ( ExprState * ) makeNode ( ExprState ) ;
state -> evalfunc = ExecEvalScalarVar ;
}
break ;
case T_Const : state = ( ExprState * ) makeNode ( ExprState ) ;
state -> evalfunc = ExecEvalConst ;
break ;
case T_Param : state = ( ExprState * ) makeNode ( ExprState ) ;
switch ( ( ( Param * ) node ) -> paramkind ) {
case PARAM_EXEC : state -> evalfunc = ExecEvalParamExec ;
break ;
case PARAM_EXTERN : state -> evalfunc = ExecEvalParamExtern ;
break ;
default : elog ( ERROR , "unrecognized paramkind: %d" , ( int ) ( ( Param * ) node ) -> paramkind ) ;
break ;
}
break ;
case T_CoerceToDomainValue : state = ( ExprState * ) makeNode ( ExprState ) ;
state -> evalfunc = ExecEvalCoerceToDomainValue ;
break ;
case T_CaseTestExpr : state = ( ExprState * ) makeNode ( ExprState ) ;
state -> evalfunc = ExecEvalCaseTestExpr ;
break ;
case T_Aggref : {
AggrefExprState * astate = makeNode ( AggrefExprState ) ;
astate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalAggref ;
if ( parent && IsA ( parent , AggState ) ) {
AggState * aggstate = ( AggState * ) parent ;
aggstate -> aggs = lcons ( astate , aggstate -> aggs ) ;
aggstate -> numaggs ++ ;
}
else {
elog ( ERROR , "Aggref found in non-Agg plan node" ) ;
}
state = ( ExprState * ) astate ;
}
break ;
case T_GroupingFunc : {
GroupingFunc * grp_node = ( GroupingFunc * ) node ;
GroupingFuncExprState * grp_state = makeNode ( GroupingFuncExprState ) ;
Agg * agg = NULL ;
if ( ! parent || ! IsA ( parent , AggState ) || ! IsA ( parent -> plan , Agg ) ) elog ( ERROR , "parent of GROUPING is not Agg node" ) ;
grp_state -> aggstate = ( AggState * ) parent ;
agg = ( Agg * ) ( parent -> plan ) ;
if ( agg -> groupingSets ) grp_state -> clauses = grp_node -> cols ;
else grp_state -> clauses = NIL ;
state = ( ExprState * ) grp_state ;
state -> evalfunc = ( ExprStateEvalFunc ) ExecEvalGroupingFuncExpr ;
}
break ;
case T_WindowFunc : {
WindowFunc * wfunc = ( WindowFunc * ) node ;
WindowFuncExprState * wfstate = makeNode ( WindowFuncExprState ) ;
wfstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalWindowFunc ;
if ( parent && IsA ( parent , WindowAggState ) ) {
WindowAggState * winstate = ( WindowAggState * ) parent ;
int nfuncs ;
winstate -> funcs = lcons ( wfstate , winstate -> funcs ) ;
nfuncs = ++ winstate -> numfuncs ;
if ( wfunc -> winagg ) winstate -> numaggs ++ ;
wfstate -> args = ( List * ) ExecInitExpr ( ( Expr * ) wfunc -> args , parent ) ;
wfstate -> aggfilter = ExecInitExpr ( wfunc -> aggfilter , parent ) ;
if ( nfuncs != winstate -> numfuncs ) ereport ( ERROR , ( errcode ( ERRCODE_WINDOWING_ERROR ) , errmsg ( "window function calls cannot be nested" ) ) ) ;
}
else {
elog ( ERROR , "WindowFunc found in non-WindowAgg plan node" ) ;
}
state = ( ExprState * ) wfstate ;
}
break ;
case T_ArrayRef : {
ArrayRef * aref = ( ArrayRef * ) node ;
ArrayRefExprState * astate = makeNode ( ArrayRefExprState ) ;
astate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalArrayRef ;
astate -> refupperindexpr = ( List * ) ExecInitExpr ( ( Expr * ) aref -> refupperindexpr , parent ) ;
astate -> reflowerindexpr = ( List * ) ExecInitExpr ( ( Expr * ) aref -> reflowerindexpr , parent ) ;
astate -> refexpr = ExecInitExpr ( aref -> refexpr , parent ) ;
astate -> refassgnexpr = ExecInitExpr ( aref -> refassgnexpr , parent ) ;
astate -> refattrlength = get_typlen ( aref -> refarraytype ) ;
get_typlenbyvalalign ( aref -> refelemtype , & astate -> refelemlength , & astate -> refelembyval , & astate -> refelemalign ) ;
state = ( ExprState * ) astate ;
}
break ;
case T_FuncExpr : {
FuncExpr * funcexpr = ( FuncExpr * ) node ;
FuncExprState * fstate = makeNode ( FuncExprState ) ;
fstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalFunc ;
fstate -> args = ( List * ) ExecInitExpr ( ( Expr * ) funcexpr -> args , parent ) ;
fstate -> func . fn_oid = InvalidOid ;
state = ( ExprState * ) fstate ;
}
break ;
case T_OpExpr : {
OpExpr * opexpr = ( OpExpr * ) node ;
FuncExprState * fstate = makeNode ( FuncExprState ) ;
fstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalOper ;
fstate -> args = ( List * ) ExecInitExpr ( ( Expr * ) opexpr -> args , parent ) ;
fstate -> func . fn_oid = InvalidOid ;
state = ( ExprState * ) fstate ;
}
break ;
case T_DistinctExpr : {
DistinctExpr * distinctexpr = ( DistinctExpr * ) node ;
FuncExprState * fstate = makeNode ( FuncExprState ) ;
fstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalDistinct ;
fstate -> args = ( List * ) ExecInitExpr ( ( Expr * ) distinctexpr -> args , parent ) ;
fstate -> func . fn_oid = InvalidOid ;
state = ( ExprState * ) fstate ;
}
break ;
case T_NullIfExpr : {
NullIfExpr * nullifexpr = ( NullIfExpr * ) node ;
FuncExprState * fstate = makeNode ( FuncExprState ) ;
fstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalNullIf ;
fstate -> args = ( List * ) ExecInitExpr ( ( Expr * ) nullifexpr -> args , parent ) ;
fstate -> func . fn_oid = InvalidOid ;
state = ( ExprState * ) fstate ;
}
break ;
case T_ScalarArrayOpExpr : {
ScalarArrayOpExpr * opexpr = ( ScalarArrayOpExpr * ) node ;
ScalarArrayOpExprState * sstate = makeNode ( ScalarArrayOpExprState ) ;
sstate -> fxprstate . xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalScalarArrayOp ;
sstate -> fxprstate . args = ( List * ) ExecInitExpr ( ( Expr * ) opexpr -> args , parent ) ;
sstate -> fxprstate . func . fn_oid = InvalidOid ;
sstate -> element_type = InvalidOid ;
state = ( ExprState * ) sstate ;
}
break ;
case T_BoolExpr : {
BoolExpr * boolexpr = ( BoolExpr * ) node ;
BoolExprState * bstate = makeNode ( BoolExprState ) ;
switch ( boolexpr -> boolop ) {
case AND_EXPR : bstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalAnd ;
break ;
case OR_EXPR : bstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalOr ;
break ;
case NOT_EXPR : bstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalNot ;
break ;
default : elog ( ERROR , "unrecognized boolop: %d" , ( int ) boolexpr -> boolop ) ;
break ;
}
bstate -> args = ( List * ) ExecInitExpr ( ( Expr * ) boolexpr -> args , parent ) ;
state = ( ExprState * ) bstate ;
}
break ;
case T_SubPlan : {
SubPlan * subplan = ( SubPlan * ) node ;
SubPlanState * sstate ;
if ( ! parent ) elog ( ERROR , "SubPlan found with no parent plan" ) ;
sstate = ExecInitSubPlan ( subplan , parent ) ;
parent -> subPlan = lappend ( parent -> subPlan , sstate ) ;
state = ( ExprState * ) sstate ;
}
break ;
case T_AlternativeSubPlan : {
AlternativeSubPlan * asplan = ( AlternativeSubPlan * ) node ;
AlternativeSubPlanState * asstate ;
if ( ! parent ) elog ( ERROR , "AlternativeSubPlan found with no parent plan" ) ;
asstate = ExecInitAlternativeSubPlan ( asplan , parent ) ;
state = ( ExprState * ) asstate ;
}
break ;
case T_FieldSelect : {
FieldSelect * fselect = ( FieldSelect * ) node ;
FieldSelectState * fstate = makeNode ( FieldSelectState ) ;
fstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalFieldSelect ;
fstate -> arg = ExecInitExpr ( fselect -> arg , parent ) ;
fstate -> argdesc = NULL ;
state = ( ExprState * ) fstate ;
}
break ;
case T_FieldStore : {
FieldStore * fstore = ( FieldStore * ) node ;
FieldStoreState * fstate = makeNode ( FieldStoreState ) ;
fstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalFieldStore ;
fstate -> arg = ExecInitExpr ( fstore -> arg , parent ) ;
fstate -> newvals = ( List * ) ExecInitExpr ( ( Expr * ) fstore -> newvals , parent ) ;
fstate -> argdesc = NULL ;
state = ( ExprState * ) fstate ;
}
break ;
case T_RelabelType : {
RelabelType * relabel = ( RelabelType * ) node ;
GenericExprState * gstate = makeNode ( GenericExprState ) ;
gstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalRelabelType ;
gstate -> arg = ExecInitExpr ( relabel -> arg , parent ) ;
state = ( ExprState * ) gstate ;
}
break ;
case T_CoerceViaIO : {
CoerceViaIO * iocoerce = ( CoerceViaIO * ) node ;
CoerceViaIOState * iostate = makeNode ( CoerceViaIOState ) ;
Oid iofunc ;
bool typisvarlena ;
iostate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalCoerceViaIO ;
iostate -> arg = ExecInitExpr ( iocoerce -> arg , parent ) ;
getTypeInputInfo ( iocoerce -> resulttype , & iofunc , & iostate -> intypioparam ) ;
fmgr_info ( iofunc , & iostate -> infunc ) ;
getTypeOutputInfo ( exprType ( ( Node * ) iocoerce -> arg ) , & iofunc , & typisvarlena ) ;
fmgr_info ( iofunc , & iostate -> outfunc ) ;
state = ( ExprState * ) iostate ;
}
break ;
case T_ArrayCoerceExpr : {
ArrayCoerceExpr * acoerce = ( ArrayCoerceExpr * ) node ;
ArrayCoerceExprState * astate = makeNode ( ArrayCoerceExprState ) ;
astate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalArrayCoerceExpr ;
astate -> arg = ExecInitExpr ( acoerce -> arg , parent ) ;
astate -> resultelemtype = get_element_type ( acoerce -> resulttype ) ;
if ( astate -> resultelemtype == InvalidOid ) ereport ( ERROR , ( errcode ( ERRCODE_INVALID_PARAMETER_VALUE ) , errmsg ( "target type is not an array" ) ) ) ;
Assert ( getBaseType ( astate -> resultelemtype ) == astate -> resultelemtype ) ;
astate -> elemfunc . fn_oid = InvalidOid ;
astate -> amstate = ( ArrayMapState * ) palloc0 ( sizeof ( ArrayMapState ) ) ;
state = ( ExprState * ) astate ;
}
break ;
case T_ConvertRowtypeExpr : {
ConvertRowtypeExpr * convert = ( ConvertRowtypeExpr * ) node ;
ConvertRowtypeExprState * cstate = makeNode ( ConvertRowtypeExprState ) ;
cstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalConvertRowtype ;
cstate -> arg = ExecInitExpr ( convert -> arg , parent ) ;
state = ( ExprState * ) cstate ;
}
break ;
case T_CaseExpr : {
CaseExpr * caseexpr = ( CaseExpr * ) node ;
CaseExprState * cstate = makeNode ( CaseExprState ) ;
List * outlist = NIL ;
ListCell * l ;
cstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalCase ;
cstate -> arg = ExecInitExpr ( caseexpr -> arg , parent ) ;
foreach ( l , caseexpr -> args ) {
CaseWhen * when = ( CaseWhen * ) lfirst ( l ) ;
CaseWhenState * wstate = makeNode ( CaseWhenState ) ;
Assert ( IsA ( when , CaseWhen ) ) ;
wstate -> xprstate . evalfunc = NULL ;
wstate -> xprstate . expr = ( Expr * ) when ;
wstate -> expr = ExecInitExpr ( when -> expr , parent ) ;
wstate -> result = ExecInitExpr ( when -> result , parent ) ;
outlist = lappend ( outlist , wstate ) ;
}
cstate -> args = outlist ;
cstate -> defresult = ExecInitExpr ( caseexpr -> defresult , parent ) ;
state = ( ExprState * ) cstate ;
}
break ;
case T_ArrayExpr : {
ArrayExpr * arrayexpr = ( ArrayExpr * ) node ;
ArrayExprState * astate = makeNode ( ArrayExprState ) ;
List * outlist = NIL ;
ListCell * l ;
astate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalArray ;
foreach ( l , arrayexpr -> elements ) {
Expr * e = ( Expr * ) lfirst ( l ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
astate -> elements = outlist ;
get_typlenbyvalalign ( arrayexpr -> element_typeid , & astate -> elemlength , & astate -> elembyval , & astate -> elemalign ) ;
state = ( ExprState * ) astate ;
}
break ;
case T_RowExpr : {
RowExpr * rowexpr = ( RowExpr * ) node ;
RowExprState * rstate = makeNode ( RowExprState ) ;
Form_pg_attribute * attrs ;
List * outlist = NIL ;
ListCell * l ;
int i ;
rstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalRow ;
if ( rowexpr -> row_typeid == RECORDOID ) {
rstate -> tupdesc = ExecTypeFromExprList ( rowexpr -> args ) ;
}
else {
rstate -> tupdesc = lookup_rowtype_tupdesc_copy ( rowexpr -> row_typeid , - 1 ) ;
}
ExecTypeSetColNames ( rstate -> tupdesc , rowexpr -> colnames ) ;
BlessTupleDesc ( rstate -> tupdesc ) ;
Assert ( list_length ( rowexpr -> args ) <= rstate -> tupdesc -> natts ) ;
attrs = rstate -> tupdesc -> attrs ;
i = 0 ;
foreach ( l , rowexpr -> args ) {
Expr * e = ( Expr * ) lfirst ( l ) ;
ExprState * estate ;
if ( ! attrs [ i ] -> attisdropped ) {
if ( exprType ( ( Node * ) e ) != attrs [ i ] -> atttypid ) ereport ( ERROR , ( errcode ( ERRCODE_DATATYPE_MISMATCH ) , errmsg ( "ROW() column has type %s instead of type %s" , format_type_be ( exprType ( ( Node * ) e ) ) , format_type_be ( attrs [ i ] -> atttypid ) ) ) ) ;
}
else {
e = ( Expr * ) makeNullConst ( INT4OID , - 1 , InvalidOid ) ;
}
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
i ++ ;
}
rstate -> args = outlist ;
state = ( ExprState * ) rstate ;
}
break ;
case T_RowCompareExpr : {
RowCompareExpr * rcexpr = ( RowCompareExpr * ) node ;
RowCompareExprState * rstate = makeNode ( RowCompareExprState ) ;
int nopers = list_length ( rcexpr -> opnos ) ;
List * outlist ;
ListCell * l ;
ListCell * l2 ;
ListCell * l3 ;
int i ;
rstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalRowCompare ;
Assert ( list_length ( rcexpr -> largs ) == nopers ) ;
outlist = NIL ;
foreach ( l , rcexpr -> largs ) {
Expr * e = ( Expr * ) lfirst ( l ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
rstate -> largs = outlist ;
Assert ( list_length ( rcexpr -> rargs ) == nopers ) ;
outlist = NIL ;
foreach ( l , rcexpr -> rargs ) {
Expr * e = ( Expr * ) lfirst ( l ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
rstate -> rargs = outlist ;
Assert ( list_length ( rcexpr -> opfamilies ) == nopers ) ;
rstate -> funcs = ( FmgrInfo * ) palloc ( nopers * sizeof ( FmgrInfo ) ) ;
rstate -> collations = ( Oid * ) palloc ( nopers * sizeof ( Oid ) ) ;
i = 0 ;
forthree ( l , rcexpr -> opnos , l2 , rcexpr -> opfamilies , l3 , rcexpr -> inputcollids ) {
Oid opno = lfirst_oid ( l ) ;
Oid opfamily = lfirst_oid ( l2 ) ;
Oid inputcollid = lfirst_oid ( l3 ) ;
int strategy ;
Oid lefttype ;
Oid righttype ;
Oid proc ;
get_op_opfamily_properties ( opno , opfamily , false , & strategy , & lefttype , & righttype ) ;
proc = get_opfamily_proc ( opfamily , lefttype , righttype , BTORDER_PROC ) ;
fmgr_info ( proc , & ( rstate -> funcs [ i ] ) ) ;
rstate -> collations [ i ] = inputcollid ;
i ++ ;
}
state = ( ExprState * ) rstate ;
}
break ;
case T_CoalesceExpr : {
CoalesceExpr * coalesceexpr = ( CoalesceExpr * ) node ;
CoalesceExprState * cstate = makeNode ( CoalesceExprState ) ;
List * outlist = NIL ;
ListCell * l ;
cstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalCoalesce ;
foreach ( l , coalesceexpr -> args ) {
Expr * e = ( Expr * ) lfirst ( l ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
cstate -> args = outlist ;
state = ( ExprState * ) cstate ;
}
break ;
case T_MinMaxExpr : {
MinMaxExpr * minmaxexpr = ( MinMaxExpr * ) node ;
MinMaxExprState * mstate = makeNode ( MinMaxExprState ) ;
List * outlist = NIL ;
ListCell * l ;
TypeCacheEntry * typentry ;
mstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalMinMax ;
foreach ( l , minmaxexpr -> args ) {
Expr * e = ( Expr * ) lfirst ( l ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
mstate -> args = outlist ;
typentry = lookup_type_cache ( minmaxexpr -> minmaxtype , TYPECACHE_CMP_PROC ) ;
if ( ! OidIsValid ( typentry -> cmp_proc ) ) ereport ( ERROR , ( errcode ( ERRCODE_UNDEFINED_FUNCTION ) , errmsg ( "could not identify a comparison function for type %s" , format_type_be ( minmaxexpr -> minmaxtype ) ) ) ) ;
fmgr_info ( typentry -> cmp_proc , & ( mstate -> cfunc ) ) ;
state = ( ExprState * ) mstate ;
}
break ;
case T_XmlExpr : {
XmlExpr * xexpr = ( XmlExpr * ) node ;
XmlExprState * xstate = makeNode ( XmlExprState ) ;
List * outlist ;
ListCell * arg ;
xstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalXml ;
outlist = NIL ;
foreach ( arg , xexpr -> named_args ) {
Expr * e = ( Expr * ) lfirst ( arg ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
xstate -> named_args = outlist ;
outlist = NIL ;
foreach ( arg , xexpr -> args ) {
Expr * e = ( Expr * ) lfirst ( arg ) ;
ExprState * estate ;
estate = ExecInitExpr ( e , parent ) ;
outlist = lappend ( outlist , estate ) ;
}
xstate -> args = outlist ;
state = ( ExprState * ) xstate ;
}
break ;
case T_NullTest : {
NullTest * ntest = ( NullTest * ) node ;
NullTestState * nstate = makeNode ( NullTestState ) ;
nstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalNullTest ;
nstate -> arg = ExecInitExpr ( ntest -> arg , parent ) ;
nstate -> argdesc = NULL ;
state = ( ExprState * ) nstate ;
}
break ;
case T_BooleanTest : {
BooleanTest * btest = ( BooleanTest * ) node ;
GenericExprState * gstate = makeNode ( GenericExprState ) ;
gstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalBooleanTest ;
gstate -> arg = ExecInitExpr ( btest -> arg , parent ) ;
state = ( ExprState * ) gstate ;
}
break ;
case T_CoerceToDomain : {
CoerceToDomain * ctest = ( CoerceToDomain * ) node ;
CoerceToDomainState * cstate = makeNode ( CoerceToDomainState ) ;
cstate -> xprstate . evalfunc = ( ExprStateEvalFunc ) ExecEvalCoerceToDomain ;
cstate -> arg = ExecInitExpr ( ctest -> arg , parent ) ;
cstate -> constraint_ref = ( DomainConstraintRef * ) palloc ( sizeof ( DomainConstraintRef ) ) ;
InitDomainConstraintRef ( ctest -> resulttype , cstate -> constraint_ref , CurrentMemoryContext ) ;
state = ( ExprState * ) cstate ;
}
break ;
case T_CurrentOfExpr : state = ( ExprState * ) makeNode ( ExprState ) ;
state -> evalfunc = ExecEvalCurrentOfExpr ;
break ;
case T_TargetEntry : {
TargetEntry * tle = ( TargetEntry * ) node ;
GenericExprState * gstate = makeNode ( GenericExprState ) ;
gstate -> xprstate . evalfunc = NULL ;
gstate -> arg = ExecInitExpr ( tle -> expr , parent ) ;
state = ( ExprState * ) gstate ;
}
break ;
case T_List : {
List * outlist = NIL ;
ListCell * l ;
foreach ( l , ( List * ) node ) {
outlist = lappend ( outlist , ExecInitExpr ( ( Expr * ) lfirst ( l ) , parent ) ) ;
}
return ( ExprState * ) outlist ;
}
default : elog ( ERROR , "unrecognized node type: %d" , ( int ) nodeTag ( node ) ) ;
state = NULL ;
break ;
}
state -> expr = node ;
return state ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool e1000e_intrmgr_delay_tx_causes ( E1000ECore * core , uint32_t * causes ) {
static const uint32_t delayable_causes = E1000_ICR_TXQ0 | E1000_ICR_TXQ1 | E1000_ICR_TXQE | E1000_ICR_TXDW ;
if ( msix_enabled ( core -> owner ) ) {
return false ;
}
core -> delayed_causes |= * causes & delayable_causes ;
* causes &= ~ delayable_causes ;
if ( * causes != 0 ) {
return false ;
}
e1000e_intrmgr_rearm_timer ( & core -> tidv ) ;
if ( ! core -> tadv . running && ( core -> mac [ TADV ] != 0 ) ) {
e1000e_intrmgr_rearm_timer ( & core -> tadv ) ;
}
return true ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
gboolean bluetooth_gatt_has_no_parameter ( guint8 opcode ) {
return is_readable_request ( opcode ) || opcode == ATT_OPCODE_WRITE_RESPONSE || opcode == ATT_OPCODE_HANDLE_VALUE_CONFIRMATION ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void sig_chat_protocol_unknown ( const char * protocol ) {
g_return_if_fail ( protocol != NULL ) ;
printformat ( NULL , NULL , MSGLEVEL_CLIENTERROR , TXT_UNKNOWN_CHAT_PROTOCOL , protocol ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int zcountexecstack1 ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
check_type ( * op , t_boolean ) ;
make_int ( op , count_exec_stack ( i_ctx_p , op -> value . boolval ) ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int zend_is_callable_check_class ( const char * name , int name_len , zend_fcall_info_cache * fcc , int * strict_class , char * * error TSRMLS_DC ) {
int ret = 0 ;
zend_class_entry * * pce ;
char * lcname = zend_str_tolower_dup ( name , name_len ) ;
* strict_class = 0 ;
if ( name_len == sizeof ( "self" ) - 1 && ! memcmp ( lcname , "self" , sizeof ( "self" ) - 1 ) ) {
if ( ! EG ( scope ) ) {
if ( error ) * error = estrdup ( "cannot access self:: when no class scope is active" ) ;
}
else {
fcc -> called_scope = EG ( called_scope ) ;
fcc -> calling_scope = EG ( scope ) ;
if ( ! fcc -> object_ptr ) {
fcc -> object_ptr = EG ( This ) ;
}
ret = 1 ;
}
}
else if ( name_len == sizeof ( "parent" ) - 1 && ! memcmp ( lcname , "parent" , sizeof ( "parent" ) - 1 ) ) {
if ( ! EG ( scope ) ) {
if ( error ) * error = estrdup ( "cannot access parent:: when no class scope is active" ) ;
}
else if ( ! EG ( scope ) -> parent ) {
if ( error ) * error = estrdup ( "cannot access parent:: when current class scope has no parent" ) ;
}
else {
fcc -> called_scope = EG ( called_scope ) ;
fcc -> calling_scope = EG ( scope ) -> parent ;
if ( ! fcc -> object_ptr ) {
fcc -> object_ptr = EG ( This ) ;
}
* strict_class = 1 ;
ret = 1 ;
}
}
else if ( name_len == sizeof ( "static" ) - 1 && ! memcmp ( lcname , "static" , sizeof ( "static" ) - 1 ) ) {
if ( ! EG ( called_scope ) ) {
if ( error ) * error = estrdup ( "cannot access static:: when no class scope is active" ) ;
}
else {
fcc -> called_scope = EG ( called_scope ) ;
fcc -> calling_scope = EG ( called_scope ) ;
if ( ! fcc -> object_ptr ) {
fcc -> object_ptr = EG ( This ) ;
}
* strict_class = 1 ;
ret = 1 ;
}
}
else if ( zend_lookup_class_ex ( name , name_len , NULL , 1 , & pce TSRMLS_CC ) == SUCCESS ) {
zend_class_entry * scope = EG ( active_op_array ) ? EG ( active_op_array ) -> scope : NULL ;
fcc -> calling_scope = * pce ;
if ( scope && ! fcc -> object_ptr && EG ( This ) && instanceof_function ( Z_OBJCE_P ( EG ( This ) ) , scope TSRMLS_CC ) && instanceof_function ( scope , fcc -> calling_scope TSRMLS_CC ) ) {
fcc -> object_ptr = EG ( This ) ;
fcc -> called_scope = Z_OBJCE_P ( fcc -> object_ptr ) ;
}
else {
fcc -> called_scope = fcc -> object_ptr ? Z_OBJCE_P ( fcc -> object_ptr ) : fcc -> calling_scope ;
}
* strict_class = 1 ;
ret = 1 ;
}
else {
if ( error ) zend_spprintf ( error , 0 , "class '%.*s' not found" , name_len , name ) ;
}
efree ( lcname ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static CURLcode AddFormData ( struct FormData * * formp , enum formtype type , const void * line , size_t length , curl_off_t * size ) {
struct FormData * newform = malloc ( sizeof ( struct FormData ) ) ;
if ( ! newform ) return CURLE_OUT_OF_MEMORY ;
newform -> next = NULL ;
if ( type <= FORM_CONTENT ) {
if ( ! length ) length = strlen ( ( char * ) line ) ;
newform -> line = malloc ( length + 1 ) ;
if ( ! newform -> line ) {
free ( newform ) ;
return CURLE_OUT_OF_MEMORY ;
}
memcpy ( newform -> line , line , length ) ;
newform -> length = length ;
newform -> line [ length ] = 0 ;
}
else newform -> line = ( char * ) line ;
newform -> type = type ;
if ( * formp ) {
( * formp ) -> next = newform ;
* formp = newform ;
}
else * formp = newform ;
if ( size ) {
if ( type != FORM_FILE ) * size += length ;
else {
if ( ! strequal ( "-" , newform -> line ) ) {
struct_stat file ;
if ( ! stat ( newform -> line , & file ) && ! S_ISDIR ( file . st_mode ) ) * size += filesize ( newform -> line , file ) ;
else return CURLE_BAD_FUNCTION_ARGUMENT ;
}
}
}
return CURLE_OK ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void fz_drop_icclink ( fz_context * ctx , fz_icclink * link ) {
fz_drop_storable ( ctx , & link -> storable ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void fz_cached_color_convert ( fz_context * ctx , fz_color_converter * cc_ , float * ds , const float * ss ) {
fz_cached_color_converter * cc = cc_ -> opaque ;
void * val = fz_hash_find ( ctx , cc -> hash , ss ) ;
int n = cc -> base . ds -> n * sizeof ( float ) ;
fz_color_converter * base_cc = & cc -> base ;
if ( val ) {
memcpy ( ds , val , n ) ;
return ;
}
base_cc -> convert ( ctx , base_cc , ds , ss ) ;
val = fz_malloc ( ctx , n ) ;
memcpy ( val , ds , n ) ;
fz_try ( ctx ) {
fz_hash_insert ( ctx , cc -> hash , ss , val ) ;
}
fz_catch ( ctx ) {
fz_free ( ctx , val ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ide_dbdma_start ( IDEDMA * dma , IDEState * s , BlockCompletionFunc * cb ) {
MACIOIDEState * m = container_of ( dma , MACIOIDEState , dma ) ;
MACIO_DPRINTF ( "\n" ) ;
m -> dma_active = true ;
DBDMA_kick ( m -> dbdma ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void http_badreq_errorcb ( struct bufferevent * bev , short what , void * arg ) {
event_debug ( ( "%s: called (what=%04x, arg=%p)" , __func__ , what , arg ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void activate_parameters_install_free ( ActivateParametersInstall * parameters_install ) {
if ( parameters_install -> slot ) {
g_object_remove_weak_pointer ( G_OBJECT ( parameters_install -> slot ) , ( gpointer * ) & parameters_install -> slot ) ;
}
if ( parameters_install -> parent_window ) {
g_object_remove_weak_pointer ( G_OBJECT ( parameters_install -> parent_window ) , ( gpointer * ) & parameters_install -> parent_window ) ;
}
if ( parameters_install -> proxy != NULL ) {
g_object_unref ( parameters_install -> proxy ) ;
}
nautilus_file_unref ( parameters_install -> file ) ;
nautilus_file_list_free ( parameters_install -> files ) ;
g_free ( parameters_install -> activation_directory ) ;
g_free ( parameters_install -> uri ) ;
g_free ( parameters_install ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
apr_status_t modsecurity_process_phase ( modsec_rec * msr , unsigned int phase ) {
if ( ( msr -> was_intercepted ) && ( phase != PHASE_LOGGING ) ) {
if ( msr -> txcfg -> debuglog_level >= 4 ) {
msr_log ( msr , 4 , "Skipping phase %d as request was already intercepted." , phase ) ;
}
return 0 ;
}
if ( msr -> phase >= phase ) {
if ( msr -> txcfg -> debuglog_level >= 4 ) {
msr_log ( msr , 4 , "Skipping phase %d because it was previously run (at %d now)." , phase , msr -> phase ) ;
}
return 0 ;
}
msr -> phase = phase ;
if ( msr -> txcfg -> cache_trans == MODSEC_CACHE_ENABLED ) {
if ( msr -> tcache ) {
apr_hash_index_t * hi ;
void * dummy ;
apr_table_t * tab ;
const void * key ;
apr_ssize_t klen ;
# ifdef CACHE_DEBUG apr_pool_t * mp = msr -> msc_rule_mptmp ;
const apr_array_header_t * ctarr ;
const apr_table_entry_t * ctelts ;
msre_cache_rec * rec ;
int cn = 0 ;
int ri ;
# else apr_pool_t * mp = msr -> mp ;
# endif for ( hi = apr_hash_first ( mp , msr -> tcache ) ;
hi ;
hi = apr_hash_next ( hi ) ) {
apr_hash_this ( hi , & key , & klen , & dummy ) ;
tab = ( apr_table_t * ) dummy ;
if ( tab == NULL ) continue ;
# ifdef CACHE_DEBUG ctarr = apr_table_elts ( tab ) ;
ctelts = ( const apr_table_entry_t * ) ctarr -> elts ;
for ( ri = 0 ;
ri < ctarr -> nelts ;
ri ++ ) {
cn ++ ;
rec = ( msre_cache_rec * ) ctelts [ ri ] . val ;
if ( rec -> changed ) {
if ( msr -> txcfg -> debuglog_level >= 9 ) {
msr_log ( msr , 9 , "CACHE: %5d) hits=%d key=%pp %x;
%s=\"%s\" (%pp - %pp)" , cn , rec -> hits , key , rec -> num , rec -> path , log_escape_nq_ex ( mp , rec -> val , rec -> val_len ) , rec -> val , rec -> val + rec -> val_len ) ;
}
}
else {
if ( msr -> txcfg -> debuglog_level >= 9 ) {
msr_log ( msr , 9 , "CACHE: %5d) hits=%d key=%pp %x;
%s=<no change>" , cn , rec -> hits , key , rec -> num , rec -> path ) ;
}
}
}
# endif apr_table_clear ( tab ) ;
apr_hash_set ( msr -> tcache , key , klen , NULL ) ;
}
if ( msr -> txcfg -> debuglog_level >= 9 ) {
msr_log ( msr , 9 , "Cleared transformation cache for phase %d" , msr -> phase ) ;
}
}
msr -> tcache_items = 0 ;
msr -> tcache = apr_hash_make ( msr -> mp ) ;
if ( msr -> tcache == NULL ) return - 1 ;
}
switch ( phase ) {
case 1 : return modsecurity_process_phase_request_headers ( msr ) ;
case 2 : return modsecurity_process_phase_request_body ( msr ) ;
case 3 : return modsecurity_process_phase_response_headers ( msr ) ;
case 4 : return modsecurity_process_phase_response_body ( msr ) ;
case 5 : return modsecurity_process_phase_logging ( msr ) ;
default : msr_log ( msr , 1 , "Invalid processing phase: %d" , msr -> phase ) ;
break ;
}
return - 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_VendorIdentification ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_VendorIdentification , VendorIdentification_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_pic ( AVSContext * h ) {
int skip_count = - 1 ;
enum cavs_mb mb_type ;
av_frame_unref ( h -> cur . f ) ;
skip_bits ( & h -> gb , 16 ) ;
if ( h -> stc == PIC_PB_START_CODE ) {
h -> cur . f -> pict_type = get_bits ( & h -> gb , 2 ) + AV_PICTURE_TYPE_I ;
if ( h -> cur . f -> pict_type > AV_PICTURE_TYPE_B ) {
av_log ( h -> avctx , AV_LOG_ERROR , "illegal picture type\n" ) ;
return - 1 ;
}
if ( ! h -> DPB [ 0 ] . f -> data [ 0 ] || ( ! h -> DPB [ 1 ] . f -> data [ 0 ] && h -> cur . f -> pict_type == AV_PICTURE_TYPE_B ) ) return - 1 ;
}
else {
h -> cur . f -> pict_type = AV_PICTURE_TYPE_I ;
if ( get_bits1 ( & h -> gb ) ) skip_bits ( & h -> gb , 24 ) ;
if ( h -> low_delay || ! ( show_bits ( & h -> gb , 9 ) & 1 ) ) h -> stream_revision = 1 ;
else if ( show_bits ( & h -> gb , 11 ) & 3 ) h -> stream_revision = 1 ;
if ( h -> stream_revision > 0 ) skip_bits ( & h -> gb , 1 ) ;
}
ff_get_buffer ( h -> avctx , h -> cur . f , h -> cur . f -> pict_type == AV_PICTURE_TYPE_B ? 0 : AV_GET_BUFFER_FLAG_REF ) ;
if ( ! h -> edge_emu_buffer ) {
int alloc_size = FFALIGN ( FFABS ( h -> cur . f -> linesize [ 0 ] ) + 32 , 32 ) ;
h -> edge_emu_buffer = av_mallocz ( alloc_size * 2 * 24 ) ;
if ( ! h -> edge_emu_buffer ) return AVERROR ( ENOMEM ) ;
}
ff_cavs_init_pic ( h ) ;
h -> cur . poc = get_bits ( & h -> gb , 8 ) * 2 ;
if ( h -> cur . f -> pict_type != AV_PICTURE_TYPE_B ) {
h -> dist [ 0 ] = ( h -> cur . poc - h -> DPB [ 0 ] . poc + 512 ) % 512 ;
}
else {
h -> dist [ 0 ] = ( h -> DPB [ 0 ] . poc - h -> cur . poc + 512 ) % 512 ;
}
h -> dist [ 1 ] = ( h -> cur . poc - h -> DPB [ 1 ] . poc + 512 ) % 512 ;
h -> scale_den [ 0 ] = h -> dist [ 0 ] ? 512 / h -> dist [ 0 ] : 0 ;
h -> scale_den [ 1 ] = h -> dist [ 1 ] ? 512 / h -> dist [ 1 ] : 0 ;
if ( h -> cur . f -> pict_type == AV_PICTURE_TYPE_B ) {
h -> sym_factor = h -> dist [ 0 ] * h -> scale_den [ 1 ] ;
}
else {
h -> direct_den [ 0 ] = h -> dist [ 0 ] ? 16384 / h -> dist [ 0 ] : 0 ;
h -> direct_den [ 1 ] = h -> dist [ 1 ] ? 16384 / h -> dist [ 1 ] : 0 ;
}
if ( h -> low_delay ) get_ue_golomb ( & h -> gb ) ;
h -> progressive = get_bits1 ( & h -> gb ) ;
h -> pic_structure = 1 ;
if ( ! h -> progressive ) h -> pic_structure = get_bits1 ( & h -> gb ) ;
if ( ! h -> pic_structure && h -> stc == PIC_PB_START_CODE ) skip_bits1 ( & h -> gb ) ;
skip_bits1 ( & h -> gb ) ;
skip_bits1 ( & h -> gb ) ;
h -> qp_fixed = get_bits1 ( & h -> gb ) ;
h -> qp = get_bits ( & h -> gb , 6 ) ;
if ( h -> cur . f -> pict_type == AV_PICTURE_TYPE_I ) {
if ( ! h -> progressive && ! h -> pic_structure ) skip_bits1 ( & h -> gb ) ;
skip_bits ( & h -> gb , 4 ) ;
}
else {
if ( ! ( h -> cur . f -> pict_type == AV_PICTURE_TYPE_B && h -> pic_structure == 1 ) ) h -> ref_flag = get_bits1 ( & h -> gb ) ;
skip_bits ( & h -> gb , 4 ) ;
h -> skip_mode_flag = get_bits1 ( & h -> gb ) ;
}
h -> loop_filter_disable = get_bits1 ( & h -> gb ) ;
if ( ! h -> loop_filter_disable && get_bits1 ( & h -> gb ) ) {
h -> alpha_offset = get_se_golomb ( & h -> gb ) ;
h -> beta_offset = get_se_golomb ( & h -> gb ) ;
}
else {
h -> alpha_offset = h -> beta_offset = 0 ;
}
if ( h -> cur . f -> pict_type == AV_PICTURE_TYPE_I ) {
do {
check_for_slice ( h ) ;
decode_mb_i ( h , 0 ) ;
}
while ( ff_cavs_next_mb ( h ) ) ;
}
else if ( h -> cur . f -> pict_type == AV_PICTURE_TYPE_P ) {
do {
if ( check_for_slice ( h ) ) skip_count = - 1 ;
if ( h -> skip_mode_flag && ( skip_count < 0 ) ) skip_count = get_ue_golomb ( & h -> gb ) ;
if ( h -> skip_mode_flag && skip_count -- ) {
decode_mb_p ( h , P_SKIP ) ;
}
else {
mb_type = get_ue_golomb ( & h -> gb ) + P_SKIP + h -> skip_mode_flag ;
if ( mb_type > P_8X8 ) decode_mb_i ( h , mb_type - P_8X8 - 1 ) ;
else decode_mb_p ( h , mb_type ) ;
}
}
while ( ff_cavs_next_mb ( h ) ) ;
}
else {
do {
if ( check_for_slice ( h ) ) skip_count = - 1 ;
if ( h -> skip_mode_flag && ( skip_count < 0 ) ) skip_count = get_ue_golomb ( & h -> gb ) ;
if ( h -> skip_mode_flag && skip_count -- ) {
decode_mb_b ( h , B_SKIP ) ;
}
else {
mb_type = get_ue_golomb ( & h -> gb ) + B_SKIP + h -> skip_mode_flag ;
if ( mb_type > B_8X8 ) decode_mb_i ( h , mb_type - B_8X8 - 1 ) ;
else decode_mb_b ( h , mb_type ) ;
}
}
while ( ff_cavs_next_mb ( h ) ) ;
}
if ( h -> cur . f -> pict_type != AV_PICTURE_TYPE_B ) {
av_frame_unref ( h -> DPB [ 1 ] . f ) ;
FFSWAP ( AVSFrame , h -> cur , h -> DPB [ 1 ] ) ;
FFSWAP ( AVSFrame , h -> DPB [ 0 ] , h -> DPB [ 1 ] ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void PREP_io_800_writeb ( void * opaque , uint32_t addr , uint32_t val ) {
PPC_IO_DPRINTF ( "0x%08x => 0x%08x\n" , addr - PPC_IO_BASE , val ) ;
switch ( addr ) {
case 0x0092 : if ( val & 0x80 ) {
printf ( "Soft reset asked... Stop emulation\n" ) ;
abort ( ) ;
}
if ( val & 0x40 ) {
printf ( "Little Endian mode isn't supported (yet ?)\n" ) ;
abort ( ) ;
}
break ;
case 0x0808 : break ;
case 0x0810 : NVRAM_lock ^= 0x01 ;
break ;
case 0x0812 : NVRAM_lock ^= 0x02 ;
break ;
case 0x0814 : break ;
case 0x081C : syscontrol = val ;
break ;
case 0x0850 : if ( val & 0x80 ) {
printf ( "No support for non-continuous I/O map mode\n" ) ;
abort ( ) ;
}
break ;
default : break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void xps_draw_one_radial_gradient ( xps_document * doc , const fz_matrix * ctm , struct stop * stops , int count , int extend , float x0 , float y0 , float r0 , float x1 , float y1 , float r1 ) {
fz_shade * shade ;
shade = fz_malloc_struct ( doc -> ctx , fz_shade ) ;
FZ_INIT_STORABLE ( shade , 1 , fz_free_shade_imp ) ;
shade -> colorspace = fz_device_rgb ( doc -> ctx ) ;
shade -> bbox = fz_infinite_rect ;
shade -> matrix = fz_identity ;
shade -> use_background = 0 ;
shade -> use_function = 1 ;
shade -> type = FZ_RADIAL ;
shade -> u . l_or_r . extend [ 0 ] = extend ;
shade -> u . l_or_r . extend [ 1 ] = extend ;
xps_sample_gradient_stops ( shade , stops , count ) ;
shade -> u . l_or_r . coords [ 0 ] [ 0 ] = x0 ;
shade -> u . l_or_r . coords [ 0 ] [ 1 ] = y0 ;
shade -> u . l_or_r . coords [ 0 ] [ 2 ] = r0 ;
shade -> u . l_or_r . coords [ 1 ] [ 0 ] = x1 ;
shade -> u . l_or_r . coords [ 1 ] [ 1 ] = y1 ;
shade -> u . l_or_r . coords [ 1 ] [ 2 ] = r1 ;
fz_fill_shade ( doc -> dev , shade , ctm , 1 ) ;
fz_drop_shade ( doc -> ctx , shade ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void lsf2lsp_for_mode12k2 ( AMRContext * p , double lsp [ LP_FILTER_ORDER ] , const float lsf_no_r [ LP_FILTER_ORDER ] , const int16_t * lsf_quantizer [ 5 ] , const int quantizer_offset , const int sign , const int update ) {
int16_t lsf_r [ LP_FILTER_ORDER ] ;
float lsf_q [ LP_FILTER_ORDER ] ;
int i ;
for ( i = 0 ;
i < LP_FILTER_ORDER >> 1 ;
i ++ ) memcpy ( & lsf_r [ i << 1 ] , & lsf_quantizer [ i ] [ quantizer_offset ] , 2 * sizeof ( * lsf_r ) ) ;
if ( sign ) {
lsf_r [ 4 ] *= - 1 ;
lsf_r [ 5 ] *= - 1 ;
}
if ( update ) memcpy ( p -> prev_lsf_r , lsf_r , LP_FILTER_ORDER * sizeof ( * lsf_r ) ) ;
for ( i = 0 ;
i < LP_FILTER_ORDER ;
i ++ ) lsf_q [ i ] = lsf_r [ i ] * ( LSF_R_FAC / 8000.0 ) + lsf_no_r [ i ] * ( 1.0 / 8000.0 ) ;
ff_set_min_dist_lsf ( lsf_q , MIN_LSF_SPACING , LP_FILTER_ORDER ) ;
if ( update ) interpolate_lsf ( p -> lsf_q , lsf_q ) ;
ff_acelp_lsf2lspd ( lsp , lsf_q , LP_FILTER_ORDER ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int tls1_mac ( SSL * ssl , SSL3_RECORD * rec , unsigned char * md , int send ) {
unsigned char * seq ;
EVP_MD_CTX * hash ;
size_t md_size ;
int i ;
EVP_MD_CTX * hmac = NULL , * mac_ctx ;
unsigned char header [ 13 ] ;
int stream_mac = ( send ? ( ssl -> mac_flags & SSL_MAC_FLAG_WRITE_MAC_STREAM ) : ( ssl -> mac_flags & SSL_MAC_FLAG_READ_MAC_STREAM ) ) ;
int t ;
if ( send ) {
seq = RECORD_LAYER_get_write_sequence ( & ssl -> rlayer ) ;
hash = ssl -> write_hash ;
}
else {
seq = RECORD_LAYER_get_read_sequence ( & ssl -> rlayer ) ;
hash = ssl -> read_hash ;
}
t = EVP_MD_CTX_size ( hash ) ;
OPENSSL_assert ( t >= 0 ) ;
md_size = t ;
if ( stream_mac ) {
mac_ctx = hash ;
}
else {
hmac = EVP_MD_CTX_new ( ) ;
if ( hmac == NULL || ! EVP_MD_CTX_copy ( hmac , hash ) ) return - 1 ;
mac_ctx = hmac ;
}
if ( SSL_IS_DTLS ( ssl ) ) {
unsigned char dtlsseq [ 8 ] , * p = dtlsseq ;
s2n ( send ? DTLS_RECORD_LAYER_get_w_epoch ( & ssl -> rlayer ) : DTLS_RECORD_LAYER_get_r_epoch ( & ssl -> rlayer ) , p ) ;
memcpy ( p , & seq [ 2 ] , 6 ) ;
memcpy ( header , dtlsseq , 8 ) ;
}
else memcpy ( header , seq , 8 ) ;
header [ 8 ] = rec -> type ;
header [ 9 ] = ( unsigned char ) ( ssl -> version >> 8 ) ;
header [ 10 ] = ( unsigned char ) ( ssl -> version ) ;
header [ 11 ] = ( rec -> length ) >> 8 ;
header [ 12 ] = ( rec -> length ) & 0xff ;
if ( ! send && ! SSL_USE_ETM ( ssl ) && EVP_CIPHER_CTX_mode ( ssl -> enc_read_ctx ) == EVP_CIPH_CBC_MODE && ssl3_cbc_record_digest_supported ( mac_ctx ) ) {
if ( ssl3_cbc_digest_record ( mac_ctx , md , & md_size , header , rec -> input , rec -> length + md_size , rec -> orig_len , ssl -> s3 -> read_mac_secret , ssl -> s3 -> read_mac_secret_size , 0 ) <= 0 ) {
EVP_MD_CTX_free ( hmac ) ;
return - 1 ;
}
}
else {
if ( EVP_DigestSignUpdate ( mac_ctx , header , sizeof ( header ) ) <= 0 || EVP_DigestSignUpdate ( mac_ctx , rec -> input , rec -> length ) <= 0 || EVP_DigestSignFinal ( mac_ctx , md , & md_size ) <= 0 ) {
EVP_MD_CTX_free ( hmac ) ;
return - 1 ;
}
if ( ! send && ! SSL_USE_ETM ( ssl ) && FIPS_mode ( ) ) if ( ! tls_fips_digest_extra ( ssl -> enc_read_ctx , mac_ctx , rec -> input , rec -> length , rec -> orig_len ) ) {
EVP_MD_CTX_free ( hmac ) ;
return - 1 ;
}
}
EVP_MD_CTX_free ( hmac ) ;
# ifdef SSL_DEBUG fprintf ( stderr , "seq=" ) ;
{
int z ;
for ( z = 0 ;
z < 8 ;
z ++ ) fprintf ( stderr , "%02X " , seq [ z ] ) ;
fprintf ( stderr , "\n" ) ;
}
fprintf ( stderr , "rec=" ) ;
{
unsigned int z ;
for ( z = 0 ;
z < rec -> length ;
z ++ ) fprintf ( stderr , "%02X " , rec -> data [ z ] ) ;
fprintf ( stderr , "\n" ) ;
}
# endif if ( ! SSL_IS_DTLS ( ssl ) ) {
for ( i = 7 ;
i >= 0 ;
i -- ) {
++ seq [ i ] ;
if ( seq [ i ] != 0 ) break ;
}
}
# ifdef SSL_DEBUG {
unsigned int z ;
for ( z = 0 ;
z < md_size ;
z ++ ) fprintf ( stderr , "%02X " , md [ z ] ) ;
fprintf ( stderr , "\n" ) ;
}
# endif return ( md_size ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
GSList * mainwindows_get_sorted ( int reverse ) {
GSList * tmp , * list ;
list = NULL ;
for ( tmp = mainwindows ;
tmp != NULL ;
tmp = tmp -> next ) {
list = g_slist_insert_sorted ( list , tmp -> data , ( GCompareFunc ) ( reverse ? mainwindows_compare_reverse : mainwindows_compare ) ) ;
}
return list ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint dump_events_for_db ( char * db ) {
char query_buff [ QUERY_LENGTH ] ;
char db_name_buff [ NAME_LEN * 2 + 3 ] , name_buff [ NAME_LEN * 2 + 3 ] ;
char * event_name ;
char delimiter [ QUERY_LENGTH ] ;
FILE * sql_file = md_result_file ;
MYSQL_RES * event_res , * event_list_res ;
MYSQL_ROW row , event_list_row ;
char db_cl_name [ MY_CS_NAME_SIZE ] ;
int db_cl_altered = FALSE ;
DBUG_ENTER ( "dump_events_for_db" ) ;
DBUG_PRINT ( "enter" , ( "db: '%s'" , db ) ) ;
mysql_real_escape_string ( mysql , db_name_buff , db , ( ulong ) strlen ( db ) ) ;
print_comment ( sql_file , 0 , "\n--\n-- Dumping events for database '%s'\n--\n" , db ) ;
if ( lock_tables ) mysql_query ( mysql , "LOCK TABLES mysql.event READ" ) ;
if ( mysql_query_with_error_report ( mysql , & event_list_res , "show events" ) ) DBUG_RETURN ( 0 ) ;
strcpy ( delimiter , ";
" ) ;
if ( mysql_num_rows ( event_list_res ) > 0 ) {
if ( opt_xml ) fputs ( "\t<events>\n" , sql_file ) ;
else {
fprintf ( sql_file , "/*!50106 SET @save_time_zone= @@TIME_ZONE */ ;
\n" ) ;
if ( fetch_db_collation ( db_name_buff , db_cl_name , sizeof ( db_cl_name ) ) ) DBUG_RETURN ( 1 ) ;
}
if ( switch_character_set_results ( mysql , "binary" ) ) DBUG_RETURN ( 1 ) ;
while ( ( event_list_row = mysql_fetch_row ( event_list_res ) ) != NULL ) {
event_name = quote_name ( event_list_row [ 1 ] , name_buff , 0 ) ;
DBUG_PRINT ( "info" , ( "retrieving CREATE EVENT for %s" , name_buff ) ) ;
my_snprintf ( query_buff , sizeof ( query_buff ) , "SHOW CREATE EVENT %s" , event_name ) ;
if ( mysql_query_with_error_report ( mysql , & event_res , query_buff ) ) DBUG_RETURN ( 1 ) ;
while ( ( row = mysql_fetch_row ( event_res ) ) != NULL ) {
if ( opt_xml ) {
print_xml_row ( sql_file , "event" , event_res , & row , "Create Event" ) ;
continue ;
}
if ( strlen ( row [ 3 ] ) != 0 ) {
char * query_str ;
if ( opt_drop ) fprintf ( sql_file , "/*!50106 DROP EVENT IF EXISTS %s */%s\n" , event_name , delimiter ) ;
if ( create_delimiter ( row [ 3 ] , delimiter , sizeof ( delimiter ) ) == NULL ) {
fprintf ( stderr , "%s: Warning: Can't create delimiter for event '%s'\n" , my_progname_short , event_name ) ;
DBUG_RETURN ( 1 ) ;
}
fprintf ( sql_file , "DELIMITER %s\n" , delimiter ) ;
if ( mysql_num_fields ( event_res ) >= 7 ) {
if ( switch_db_collation ( sql_file , db_name_buff , delimiter , db_cl_name , row [ 6 ] , & db_cl_altered ) ) {
DBUG_RETURN ( 1 ) ;
}
switch_cs_variables ( sql_file , delimiter , row [ 4 ] , row [ 4 ] , row [ 5 ] ) ;
}
else {
fprintf ( sql_file , "--\n" "-- WARNING: old server version. " "The following dump may be incomplete.\n" "--\n" ) ;
}
switch_sql_mode ( sql_file , delimiter , row [ 1 ] ) ;
switch_time_zone ( sql_file , delimiter , row [ 2 ] ) ;
query_str = cover_definer_clause ( row [ 3 ] , strlen ( row [ 3 ] ) , C_STRING_WITH_LEN ( "50117" ) , C_STRING_WITH_LEN ( "50106" ) , C_STRING_WITH_LEN ( " EVENT" ) ) ;
fprintf ( sql_file , "/*!50106 %s */ %s\n" , ( const char * ) ( query_str != NULL ? query_str : row [ 3 ] ) , ( const char * ) delimiter ) ;
my_free ( query_str ) ;
restore_time_zone ( sql_file , delimiter ) ;
restore_sql_mode ( sql_file , delimiter ) ;
if ( mysql_num_fields ( event_res ) >= 7 ) {
restore_cs_variables ( sql_file , delimiter ) ;
if ( db_cl_altered ) {
if ( restore_db_collation ( sql_file , db_name_buff , delimiter , db_cl_name ) ) DBUG_RETURN ( 1 ) ;
}
}
}
}
mysql_free_result ( event_res ) ;
}
if ( opt_xml ) {
fputs ( "\t</events>\n" , sql_file ) ;
check_io ( sql_file ) ;
}
else {
fprintf ( sql_file , "DELIMITER ;
\n" ) ;
fprintf ( sql_file , "/*!50106 SET TIME_ZONE= @save_time_zone */ ;
\n" ) ;
}
if ( switch_character_set_results ( mysql , default_charset ) ) DBUG_RETURN ( 1 ) ;
}
mysql_free_result ( event_list_res ) ;
if ( lock_tables ) ( void ) mysql_query_with_error_report ( mysql , 0 , "UNLOCK TABLES" ) ;
DBUG_RETURN ( 0 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int EVP_CIPHER_CTX_rand_key ( EVP_CIPHER_CTX * ctx , unsigned char * key ) {
if ( ctx -> cipher -> flags & EVP_CIPH_RAND_KEY ) return EVP_CIPHER_CTX_ctrl ( ctx , EVP_CTRL_RAND_KEY , 0 , key ) ;
if ( RAND_bytes ( key , ctx -> key_len ) <= 0 ) return 0 ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_INTEGER_1_128 ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 1U , 128U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_set_colorspace ( fz_context * ctx , pdf_run_processor * pr , int what , fz_colorspace * colorspace ) {
pdf_gstate * gstate = pr -> gstate + pr -> gtop ;
pdf_material * mat ;
int n = fz_colorspace_n ( ctx , colorspace ) ;
gstate = pdf_flush_text ( ctx , pr ) ;
mat = what == PDF_FILL ? & gstate -> fill : & gstate -> stroke ;
fz_drop_colorspace ( ctx , mat -> colorspace ) ;
mat -> kind = PDF_MAT_COLOR ;
mat -> colorspace = fz_keep_colorspace ( ctx , colorspace ) ;
mat -> v [ 0 ] = 0 ;
mat -> v [ 1 ] = 0 ;
mat -> v [ 2 ] = 0 ;
mat -> v [ 3 ] = 1 ;
if ( pdf_is_tint_colorspace ( ctx , colorspace ) ) {
int i ;
for ( i = 0 ;
i < n ;
i ++ ) mat -> v [ i ] = 1.0f ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void PNGAPI png_set_invalid ( png_structp png_ptr , png_infop info_ptr , int mask ) {
if ( png_ptr && info_ptr ) info_ptr -> valid &= ~ mask ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static cmsBool ReadOneWChar ( cmsIOHANDLER * io , _cmsDICelem * e , cmsUInt32Number i , wchar_t * * wcstr ) {
cmsUInt32Number nChars ;
if ( e -> Offsets [ i ] == 0 ) {
* wcstr = NULL ;
return TRUE ;
}
if ( ! io -> Seek ( io , e -> Offsets [ i ] ) ) return FALSE ;
nChars = e -> Sizes [ i ] / sizeof ( cmsUInt16Number ) ;
* wcstr = ( wchar_t * ) _cmsMallocZero ( e -> ContextID , ( nChars + 1 ) * sizeof ( wchar_t ) ) ;
if ( * wcstr == NULL ) return FALSE ;
if ( ! _cmsReadWCharArray ( io , nChars , * wcstr ) ) {
_cmsFree ( e -> ContextID , * wcstr ) ;
return FALSE ;
}
( * wcstr ) [ nChars ] = 0 ;
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cycle_packfile ( void ) {
end_packfile ( ) ;
start_packfile ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
RegProcedure get_opcode ( Oid opno ) {
HeapTuple tp ;
tp = SearchSysCache1 ( OPEROID , ObjectIdGetDatum ( opno ) ) ;
if ( HeapTupleIsValid ( tp ) ) {
Form_pg_operator optup = ( Form_pg_operator ) GETSTRUCT ( tp ) ;
RegProcedure result ;
result = optup -> oprcode ;
ReleaseSysCache ( tp ) ;
return result ;
}
else return ( RegProcedure ) InvalidOid ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int gic_get_current_cpu ( GICState * s ) {
if ( s -> num_cpu > 1 ) {
return current_cpu -> cpu_index ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void config_peers ( config_tree * ptree ) {
sockaddr_u peeraddr ;
struct addrinfo hints ;
peer_node * curr_peer ;
peer_resolved_ctx * ctx ;
u_char hmode ;
for ( ;
cmdline_server_count > 0 ;
cmdline_server_count -- , cmdline_servers ++ ) {
ZERO_SOCK ( & peeraddr ) ;
if ( is_ip_address ( * cmdline_servers , AF_UNSPEC , & peeraddr ) ) {
SET_PORT ( & peeraddr , NTP_PORT ) ;
if ( is_sane_resolved_address ( & peeraddr , T_Server ) ) peer_config ( & peeraddr , NULL , NULL , MODE_CLIENT , NTP_VERSION , 0 , 0 , FLAG_IBURST , 0 , 0 , NULL ) ;
}
else {
# ifdef WORKER ctx = emalloc_zero ( sizeof ( * ctx ) ) ;
ctx -> family = AF_UNSPEC ;
ctx -> host_mode = T_Server ;
ctx -> hmode = MODE_CLIENT ;
ctx -> version = NTP_VERSION ;
ctx -> flags = FLAG_IBURST ;
memset ( & hints , 0 , sizeof ( hints ) ) ;
hints . ai_family = ( u_short ) ctx -> family ;
hints . ai_socktype = SOCK_DGRAM ;
hints . ai_protocol = IPPROTO_UDP ;
getaddrinfo_sometime ( * cmdline_servers , "ntp" , & hints , INITIAL_DNS_RETRY , & peer_name_resolved , ( void * ) ctx ) ;
# else msyslog ( LOG_ERR , "hostname %s can not be used, please use IP address instead.\n" , curr_peer -> addr -> address ) ;
# endif }
}
curr_peer = HEAD_PFIFO ( ptree -> peers ) ;
for ( ;
curr_peer != NULL ;
curr_peer = curr_peer -> link ) {
ZERO_SOCK ( & peeraddr ) ;
hmode = get_correct_host_mode ( curr_peer -> host_mode ) ;
NTP_INSIST ( hmode != 0 ) ;
if ( T_Pool == curr_peer -> host_mode ) {
AF ( & peeraddr ) = curr_peer -> addr -> type ;
peer_config ( & peeraddr , curr_peer -> addr -> address , NULL , hmode , curr_peer -> peerversion , curr_peer -> minpoll , curr_peer -> maxpoll , peerflag_bits ( curr_peer ) , curr_peer -> ttl , curr_peer -> peerkey , curr_peer -> group ) ;
}
else if ( is_ip_address ( curr_peer -> addr -> address , curr_peer -> addr -> type , & peeraddr ) ) {
SET_PORT ( & peeraddr , NTP_PORT ) ;
if ( is_sane_resolved_address ( & peeraddr , curr_peer -> host_mode ) ) peer_config ( & peeraddr , NULL , NULL , hmode , curr_peer -> peerversion , curr_peer -> minpoll , curr_peer -> maxpoll , peerflag_bits ( curr_peer ) , curr_peer -> ttl , curr_peer -> peerkey , curr_peer -> group ) ;
}
else {
# ifdef WORKER ctx = emalloc_zero ( sizeof ( * ctx ) ) ;
ctx -> family = curr_peer -> addr -> type ;
ctx -> host_mode = curr_peer -> host_mode ;
ctx -> hmode = hmode ;
ctx -> version = curr_peer -> peerversion ;
ctx -> minpoll = curr_peer -> minpoll ;
ctx -> maxpoll = curr_peer -> maxpoll ;
ctx -> flags = peerflag_bits ( curr_peer ) ;
ctx -> ttl = curr_peer -> ttl ;
ctx -> keyid = curr_peer -> peerkey ;
ctx -> group = curr_peer -> group ;
memset ( & hints , 0 , sizeof ( hints ) ) ;
hints . ai_family = ctx -> family ;
hints . ai_socktype = SOCK_DGRAM ;
hints . ai_protocol = IPPROTO_UDP ;
getaddrinfo_sometime ( curr_peer -> addr -> address , "ntp" , & hints , INITIAL_DNS_RETRY , & peer_name_resolved , ctx ) ;
# else msyslog ( LOG_ERR , "hostname %s can not be used, please use IP address instead.\n" , curr_peer -> addr -> address ) ;
# endif }
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pfkey_remove ( struct sock * sk ) {
mutex_lock ( & pfkey_mutex ) ;
sk_del_node_init_rcu ( sk ) ;
mutex_unlock ( & pfkey_mutex ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Int decUnitAddSub ( const Unit * a , Int alength , const Unit * b , Int blength , Int bshift , Unit * c , Int m ) {
const Unit * alsu = a ;
Unit * clsu = c ;
Unit * minC ;
Unit * maxC ;
eInt carry = 0 ;
Int add ;
# if DECDPUN <= 4 Int est ;
# endif # if DECTRACE if ( alength < 1 || blength < 1 ) printf ( "decUnitAddSub: alen blen m %ld %ld [%ld]\n" , alength , blength , m ) ;
# endif maxC = c + alength ;
minC = c + blength ;
if ( bshift != 0 ) {
minC += bshift ;
if ( a == c && bshift <= alength ) {
c += bshift ;
a += bshift ;
}
else for ( ;
c < clsu + bshift ;
a ++ , c ++ ) {
if ( a < alsu + alength ) * c = * a ;
else * c = 0 ;
}
}
if ( minC > maxC ) {
Unit * hold = minC ;
minC = maxC ;
maxC = hold ;
}
for ( ;
c < minC ;
c ++ ) {
carry += * a ;
a ++ ;
carry += ( ( eInt ) * b ) * m ;
b ++ ;
if ( ( ueInt ) carry <= DECDPUNMAX ) {
* c = ( Unit ) carry ;
carry = 0 ;
continue ;
}
# if DECDPUN == 4 if ( carry >= 0 ) {
est = ( ( ( ueInt ) carry >> 11 ) * 53687 ) >> 18 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
est = ( ( ( ueInt ) carry >> 11 ) * 53687 ) >> 18 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est - ( DECDPUNMAX + 1 ) ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
# elif DECDPUN == 3 if ( carry >= 0 ) {
est = ( ( ( ueInt ) carry >> 3 ) * 16777 ) >> 21 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
est = ( ( ( ueInt ) carry >> 3 ) * 16777 ) >> 21 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est - ( DECDPUNMAX + 1 ) ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
# elif DECDPUN <= 2 if ( carry >= 0 ) {
est = QUOT10 ( carry , DECDPUN ) ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
est = QUOT10 ( carry , DECDPUN ) ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est - ( DECDPUNMAX + 1 ) ;
# else if ( ( ueInt ) carry < ( DECDPUNMAX + 1 ) * 2 ) {
* c = ( Unit ) ( carry - ( DECDPUNMAX + 1 ) ) ;
carry = 1 ;
continue ;
}
if ( carry >= 0 ) {
* c = ( Unit ) ( carry % ( DECDPUNMAX + 1 ) ) ;
carry = carry / ( DECDPUNMAX + 1 ) ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
* c = ( Unit ) ( carry % ( DECDPUNMAX + 1 ) ) ;
carry = carry / ( DECDPUNMAX + 1 ) - ( DECDPUNMAX + 1 ) ;
# endif }
if ( c < maxC ) for ( ;
c < maxC ;
c ++ ) {
if ( a < alsu + alength ) {
carry += * a ;
a ++ ;
}
else {
carry += ( ( eInt ) * b ) * m ;
b ++ ;
}
if ( ( ueInt ) carry <= DECDPUNMAX ) {
* c = ( Unit ) carry ;
carry = 0 ;
continue ;
}
# if DECDPUN == 4 if ( carry >= 0 ) {
est = ( ( ( ueInt ) carry >> 11 ) * 53687 ) >> 18 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
est = ( ( ( ueInt ) carry >> 11 ) * 53687 ) >> 18 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est - ( DECDPUNMAX + 1 ) ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
# elif DECDPUN == 3 if ( carry >= 0 ) {
est = ( ( ( ueInt ) carry >> 3 ) * 16777 ) >> 21 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
est = ( ( ( ueInt ) carry >> 3 ) * 16777 ) >> 21 ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est - ( DECDPUNMAX + 1 ) ;
if ( * c < DECDPUNMAX + 1 ) continue ;
carry ++ ;
* c -= DECDPUNMAX + 1 ;
# elif DECDPUN <= 2 if ( carry >= 0 ) {
est = QUOT10 ( carry , DECDPUN ) ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
est = QUOT10 ( carry , DECDPUN ) ;
* c = ( Unit ) ( carry - est * ( DECDPUNMAX + 1 ) ) ;
carry = est - ( DECDPUNMAX + 1 ) ;
# else if ( ( ueInt ) carry < ( DECDPUNMAX + 1 ) * 2 ) {
* c = ( Unit ) ( carry - ( DECDPUNMAX + 1 ) ) ;
carry = 1 ;
continue ;
}
if ( carry >= 0 ) {
* c = ( Unit ) ( carry % ( DECDPUNMAX + 1 ) ) ;
carry = carry / ( DECDPUNMAX + 1 ) ;
continue ;
}
carry = carry + ( eInt ) ( DECDPUNMAX + 1 ) * ( DECDPUNMAX + 1 ) ;
* c = ( Unit ) ( carry % ( DECDPUNMAX + 1 ) ) ;
carry = carry / ( DECDPUNMAX + 1 ) - ( DECDPUNMAX + 1 ) ;
# endif }
if ( carry == 0 ) return c - clsu ;
if ( carry > 0 ) {
* c = ( Unit ) carry ;
c ++ ;
return c - clsu ;
}
add = 1 ;
for ( c = clsu ;
c < maxC ;
c ++ ) {
add = DECDPUNMAX + add - * c ;
if ( add <= DECDPUNMAX ) {
* c = ( Unit ) add ;
add = 0 ;
}
else {
* c = 0 ;
add = 1 ;
}
}
# if DECTRACE printf ( "UAS borrow: add %ld, carry %ld\n" , add , carry ) ;
# endif if ( ( add - carry - 1 ) != 0 ) {
* c = ( Unit ) ( add - carry - 1 ) ;
c ++ ;
}
return clsu - c ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_idct4x4_16_add_c ( const tran_low_t * input , uint8_t * dest , int stride ) {
tran_low_t out [ 4 * 4 ] ;
tran_low_t * outptr = out ;
int i , j ;
tran_low_t temp_in [ 4 ] , temp_out [ 4 ] ;
for ( i = 0 ;
i < 4 ;
++ i ) {
idct4 ( input , outptr ) ;
input += 4 ;
outptr += 4 ;
}
for ( i = 0 ;
i < 4 ;
++ i ) {
for ( j = 0 ;
j < 4 ;
++ j ) temp_in [ j ] = out [ j * 4 + i ] ;
idct4 ( temp_in , temp_out ) ;
for ( j = 0 ;
j < 4 ;
++ j ) dest [ j * stride + i ] = clip_pixel ( ROUND_POWER_OF_TWO ( temp_out [ j ] , 4 ) + dest [ j * stride + i ] ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_TerminalNumber ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 0U , 192U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static struct remote_lock * lock_remote ( const char * path , long timeout ) {
struct active_request_slot * slot ;
struct slot_results results ;
struct buffer out_buffer = {
STRBUF_INIT , 0 }
;
struct strbuf in_buffer = STRBUF_INIT ;
char * url ;
char * ep ;
char timeout_header [ 25 ] ;
struct remote_lock * lock = NULL ;
struct curl_slist * dav_headers = NULL ;
struct xml_ctx ctx ;
char * escaped ;
url = xstrfmt ( "%s%s" , repo -> url , path ) ;
ep = strchr ( url + strlen ( repo -> url ) + 1 , '/' ) ;
while ( ep ) {
char saved_character = ep [ 1 ] ;
ep [ 1 ] = '\0' ;
slot = get_active_slot ( ) ;
slot -> results = & results ;
curl_setup_http_get ( slot -> curl , url , DAV_MKCOL ) ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . curl_result != CURLE_OK && results . http_code != 405 ) {
fprintf ( stderr , "Unable to create branch path %s\n" , url ) ;
free ( url ) ;
return NULL ;
}
}
else {
fprintf ( stderr , "Unable to start MKCOL request\n" ) ;
free ( url ) ;
return NULL ;
}
ep [ 1 ] = saved_character ;
ep = strchr ( ep + 1 , '/' ) ;
}
escaped = xml_entities ( ident_default_email ( ) ) ;
strbuf_addf ( & out_buffer . buf , LOCK_REQUEST , escaped ) ;
free ( escaped ) ;
xsnprintf ( timeout_header , sizeof ( timeout_header ) , "Timeout: Second-%ld" , timeout ) ;
dav_headers = curl_slist_append ( dav_headers , timeout_header ) ;
dav_headers = curl_slist_append ( dav_headers , "Content-Type: text/xml" ) ;
slot = get_active_slot ( ) ;
slot -> results = & results ;
curl_setup_http ( slot -> curl , url , DAV_LOCK , & out_buffer , fwrite_buffer ) ;
curl_easy_setopt ( slot -> curl , CURLOPT_HTTPHEADER , dav_headers ) ;
curl_easy_setopt ( slot -> curl , CURLOPT_FILE , & in_buffer ) ;
lock = xcalloc ( 1 , sizeof ( * lock ) ) ;
lock -> timeout = - 1 ;
if ( start_active_slot ( slot ) ) {
run_active_slot ( slot ) ;
if ( results . curl_result == CURLE_OK ) {
XML_Parser parser = XML_ParserCreate ( NULL ) ;
enum XML_Status result ;
ctx . name = xcalloc ( 10 , 1 ) ;
ctx . len = 0 ;
ctx . cdata = NULL ;
ctx . userFunc = handle_new_lock_ctx ;
ctx . userData = lock ;
XML_SetUserData ( parser , & ctx ) ;
XML_SetElementHandler ( parser , xml_start_tag , xml_end_tag ) ;
XML_SetCharacterDataHandler ( parser , xml_cdata ) ;
result = XML_Parse ( parser , in_buffer . buf , in_buffer . len , 1 ) ;
free ( ctx . name ) ;
if ( result != XML_STATUS_OK ) {
fprintf ( stderr , "XML error: %s\n" , XML_ErrorString ( XML_GetErrorCode ( parser ) ) ) ;
lock -> timeout = - 1 ;
}
XML_ParserFree ( parser ) ;
}
}
else {
fprintf ( stderr , "Unable to start LOCK request\n" ) ;
}
curl_slist_free_all ( dav_headers ) ;
strbuf_release ( & out_buffer . buf ) ;
strbuf_release ( & in_buffer ) ;
if ( lock -> token == NULL || lock -> timeout <= 0 ) {
free ( lock -> token ) ;
free ( lock -> owner ) ;
free ( url ) ;
free ( lock ) ;
lock = NULL ;
}
else {
lock -> url = url ;
lock -> start_time = time ( NULL ) ;
lock -> next = repo -> locks ;
repo -> locks = lock ;
}
return lock ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void dummy_error_processor ( THD * thd , void * data ) {
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ImmersiveModeControllerAshTest , TabAndBrowserFullscreen ) {
AddTab ( browser ( ) , GURL ( "about:blank" ) ) ;
ash : : ShelfLayoutManager * shelf = ash : : Shell : : GetPrimaryRootWindowController ( ) -> GetShelfLayoutManager ( ) ;
ASSERT_EQ ( ash : : SHELF_VISIBLE , shelf -> visibility_state ( ) ) ;
ToggleFullscreen ( ) ;
ASSERT_TRUE ( controller ( ) -> IsEnabled ( ) ) ;
EXPECT_EQ ( ash : : SHELF_AUTO_HIDE , shelf -> visibility_state ( ) ) ;
EXPECT_FALSE ( controller ( ) -> ShouldHideTabIndicators ( ) ) ;
SetTabFullscreen ( true ) ;
ASSERT_TRUE ( controller ( ) -> IsEnabled ( ) ) ;
EXPECT_EQ ( ash : : SHELF_HIDDEN , shelf -> visibility_state ( ) ) ;
EXPECT_TRUE ( controller ( ) -> ShouldHideTabIndicators ( ) ) ;
SetTabFullscreen ( false ) ;
ASSERT_TRUE ( controller ( ) -> IsEnabled ( ) ) ;
EXPECT_EQ ( ash : : SHELF_AUTO_HIDE , shelf -> visibility_state ( ) ) ;
EXPECT_FALSE ( controller ( ) -> ShouldHideTabIndicators ( ) ) ;
SetTabFullscreen ( true ) ;
ToggleFullscreen ( ) ;
ASSERT_FALSE ( controller ( ) -> IsEnabled ( ) ) ;
EXPECT_EQ ( ash : : SHELF_VISIBLE , shelf -> visibility_state ( ) ) ;
EXPECT_TRUE ( controller ( ) -> ShouldHideTabIndicators ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void config_request_output ( const char * key , const char * value , enum config_key_type type ATTR_UNUSED , void * context ) {
struct ostream * output = context ;
const char * p ;
o_stream_nsend_str ( output , key ) ;
o_stream_nsend_str ( output , "=" ) ;
while ( ( p = strchr ( value , '\n' ) ) != NULL ) {
o_stream_nsend ( output , value , p - value ) ;
o_stream_nsend ( output , SETTING_STREAM_LF_CHAR , 1 ) ;
value = p + 1 ;
}
o_stream_nsend_str ( output , value ) ;
o_stream_nsend_str ( output , "\n" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
Jbig2PatternDict * jbig2_hd_new ( Jbig2Ctx * ctx , const Jbig2PatternDictParams * params , Jbig2Image * image ) {
Jbig2PatternDict * new ;
const int N = params -> GRAYMAX + 1 ;
const int HPW = params -> HDPW ;
const int HPH = params -> HDPH ;
int i ;
new = jbig2_new ( ctx , Jbig2PatternDict , 1 ) ;
if ( new != NULL ) {
new -> patterns = jbig2_new ( ctx , Jbig2Image * , N ) ;
if ( new -> patterns == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , - 1 , "failed to allocate pattern in collective bitmap dictionary" ) ;
jbig2_free ( ctx -> allocator , new ) ;
return NULL ;
}
new -> n_patterns = N ;
new -> HPW = HPW ;
new -> HPH = HPH ;
for ( i = 0 ;
i < N ;
i ++ ) {
new -> patterns [ i ] = jbig2_image_new ( ctx , HPW , HPH ) ;
if ( new -> patterns [ i ] == NULL ) {
int j ;
jbig2_error ( ctx , JBIG2_SEVERITY_WARNING , - 1 , "failed to allocate pattern element image" ) ;
for ( j = 0 ;
j < i ;
j ++ ) jbig2_free ( ctx -> allocator , new -> patterns [ j ] ) ;
jbig2_free ( ctx -> allocator , new ) ;
return NULL ;
}
jbig2_image_compose ( ctx , new -> patterns [ i ] , image , - i * HPW , 0 , JBIG2_COMPOSE_REPLACE ) ;
}
}
else {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , - 1 , "failed to allocate collective bitmap dictionary" ) ;
}
return new ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _slurm_rpc_dump_jobs ( slurm_msg_t * msg ) {
DEF_TIMERS ;
char * dump ;
int dump_size ;
slurm_msg_t response_msg ;
job_info_request_msg_t * job_info_request_msg = ( job_info_request_msg_t * ) msg -> data ;
slurmctld_lock_t job_read_lock = {
READ_LOCK , READ_LOCK , NO_LOCK , READ_LOCK , READ_LOCK }
;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
START_TIMER ;
debug3 ( "Processing RPC: REQUEST_JOB_INFO from uid=%d" , uid ) ;
lock_slurmctld ( job_read_lock ) ;
if ( ( job_info_request_msg -> last_update - 1 ) >= last_job_update ) {
unlock_slurmctld ( job_read_lock ) ;
debug3 ( "_slurm_rpc_dump_jobs, no change" ) ;
slurm_send_rc_msg ( msg , SLURM_NO_CHANGE_IN_DATA ) ;
}
else {
if ( job_info_request_msg -> job_ids ) {
pack_spec_jobs ( & dump , & dump_size , job_info_request_msg -> job_ids , job_info_request_msg -> show_flags , uid , NO_VAL , msg -> protocol_version ) ;
}
else {
pack_all_jobs ( & dump , & dump_size , job_info_request_msg -> show_flags , uid , NO_VAL , msg -> protocol_version ) ;
}
unlock_slurmctld ( job_read_lock ) ;
END_TIMER2 ( "_slurm_rpc_dump_jobs" ) ;
# if 0 info ( "_slurm_rpc_dump_jobs, size=%d %s" , dump_size , TIME_STR ) ;
# endif slurm_msg_t_init ( & response_msg ) ;
response_msg . flags = msg -> flags ;
response_msg . protocol_version = msg -> protocol_version ;
response_msg . address = msg -> address ;
response_msg . conn = msg -> conn ;
response_msg . msg_type = RESPONSE_JOB_INFO ;
response_msg . data = dump ;
response_msg . data_size = dump_size ;
slurm_send_node_msg ( msg -> conn_fd , & response_msg ) ;
xfree ( dump ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_lpf_vertical_16_sse2 ( unsigned char * s , int p , const unsigned char * blimit , const unsigned char * limit , const unsigned char * thresh ) {
DECLARE_ALIGNED_ARRAY ( 8 , unsigned char , t_dst , 8 * 16 ) ;
unsigned char * src [ 2 ] ;
unsigned char * dst [ 2 ] ;
src [ 0 ] = s - 8 ;
src [ 1 ] = s ;
dst [ 0 ] = t_dst ;
dst [ 1 ] = t_dst + 8 * 8 ;
transpose ( src , p , dst , 8 , 2 ) ;
mb_lpf_horizontal_edge_w_sse2_8 ( t_dst + 8 * 8 , 8 , blimit , limit , thresh ) ;
src [ 0 ] = t_dst ;
src [ 1 ] = t_dst + 8 * 8 ;
dst [ 0 ] = s - 8 ;
dst [ 1 ] = s ;
transpose ( src , 8 , dst , p , 2 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( HttpsEngagementPageLoadMetricsBrowserTest , ClosedWhileHidden_Https ) {
StartHttpsServer ( false ) ;
base : : TimeDelta upper_bound = NavigateInForegroundAndCloseInBackgroundWithTiming ( https_test_server_ -> GetURL ( "/simple.html" ) ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpEngagementHistogram , 0 ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpsEngagementHistogram , 1 ) ;
int32_t bucket_min = histogram_tester_ . GetAllSamples ( internal : : kHttpsEngagementHistogram ) [ 0 ] . min ;
EXPECT_GE ( upper_bound . InMilliseconds ( ) , bucket_min ) ;
EXPECT_LT ( 0 , bucket_min ) ;
FakeUserMetricsUpload ( ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHttpsEngagementSessionPercentage , 1 ) ;
int32_t ratio_bucket = histogram_tester_ . GetAllSamples ( internal : : kHttpsEngagementSessionPercentage ) [ 0 ] . min ;
EXPECT_EQ ( 100 , ratio_bucket ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint8_t vble_read_reverse_unary ( GetBitContext * gb ) {
uint8_t val = show_bits ( gb , 8 ) ;
if ( val ) {
val = 7 - av_log2_16bit ( ff_reverse [ val ] ) ;
skip_bits ( gb , val + 1 ) ;
return val ;
}
else {
skip_bits ( gb , 8 ) ;
if ( get_bits1 ( gb ) ) return 8 ;
}
return UINT8_MAX ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cooked ( struct parse * pcmd , FILE * fp ) {
rawmode = 0 ;
( void ) fprintf ( fp , "Output set to cooked\n" ) ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int bethsoftvid_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
BethsoftvidContext * vid = avctx -> priv_data ;
char block_type ;
uint8_t * dst ;
uint8_t * frame_end ;
int remaining = avctx -> width ;
int wrap_to_next_line ;
int code , ret ;
int yoffset ;
if ( ( ret = ff_reget_buffer ( avctx , & vid -> frame ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "reget_buffer() failed\n" ) ;
return ret ;
}
wrap_to_next_line = vid -> frame . linesize [ 0 ] - avctx -> width ;
if ( avpkt -> side_data_elems > 0 && avpkt -> side_data [ 0 ] . type == AV_PKT_DATA_PALETTE ) {
bytestream2_init ( & vid -> g , avpkt -> side_data [ 0 ] . data , avpkt -> side_data [ 0 ] . size ) ;
if ( ( ret = set_palette ( vid ) ) < 0 ) return ret ;
}
bytestream2_init ( & vid -> g , avpkt -> data , avpkt -> size ) ;
dst = vid -> frame . data [ 0 ] ;
frame_end = vid -> frame . data [ 0 ] + vid -> frame . linesize [ 0 ] * avctx -> height ;
switch ( block_type = bytestream2_get_byte ( & vid -> g ) ) {
case PALETTE_BLOCK : {
* got_frame = 0 ;
if ( ( ret = set_palette ( vid ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "error reading palette\n" ) ;
return ret ;
}
return bytestream2_tell ( & vid -> g ) ;
}
case VIDEO_YOFF_P_FRAME : yoffset = bytestream2_get_le16 ( & vid -> g ) ;
if ( yoffset >= avctx -> height ) return AVERROR_INVALIDDATA ;
dst += vid -> frame . linesize [ 0 ] * yoffset ;
}
while ( ( code = bytestream2_get_byte ( & vid -> g ) ) ) {
int length = code & 0x7f ;
while ( length > remaining ) {
if ( code < 0x80 ) bytestream2_get_buffer ( & vid -> g , dst , remaining ) ;
else if ( block_type == VIDEO_I_FRAME ) memset ( dst , bytestream2_peek_byte ( & vid -> g ) , remaining ) ;
length -= remaining ;
dst += remaining + wrap_to_next_line ;
remaining = avctx -> width ;
if ( dst == frame_end ) goto end ;
}
if ( code < 0x80 ) bytestream2_get_buffer ( & vid -> g , dst , length ) ;
else if ( block_type == VIDEO_I_FRAME ) memset ( dst , bytestream2_get_byte ( & vid -> g ) , length ) ;
remaining -= length ;
dst += length ;
}
end : if ( ( ret = av_frame_ref ( data , & vid -> frame ) ) < 0 ) return ret ;
* got_frame = 1 ;
return avpkt -> size ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static TSReturnCode URLPartSet ( TSMBuffer bufp , TSMLoc obj , const char * value , int length , URLPartSetF url_f ) {
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_url_handle ( obj ) == TS_SUCCESS ) ;
if ( ! isWriteable ( bufp ) ) {
return TS_ERROR ;
}
URL u ;
u . m_heap = ( ( HdrHeapSDKHandle * ) bufp ) -> m_heap ;
u . m_url_impl = ( URLImpl * ) obj ;
if ( ! value ) {
length = 0 ;
}
else if ( length < 0 ) {
length = strlen ( value ) ;
}
( u . * url_f ) ( value , length ) ;
return TS_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void Type_Measurement_Free ( struct _cms_typehandler_struct * self , void * Ptr ) {
_cmsFree ( self -> ContextID , Ptr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void auth_server_connection_remove_requests ( struct auth_server_connection * conn , const char * disconnect_reason ) {
static const char * const temp_failure_args [ ] = {
"temp" , NULL }
;
struct hash_iterate_context * iter ;
void * key ;
struct auth_client_request * request ;
time_t created , oldest = 0 ;
unsigned int request_count = 0 ;
if ( hash_table_count ( conn -> requests ) == 0 ) return ;
iter = hash_table_iterate_init ( conn -> requests ) ;
while ( hash_table_iterate ( iter , conn -> requests , & key , & request ) ) {
if ( ! auth_client_request_is_aborted ( request ) ) {
request_count ++ ;
created = auth_client_request_get_create_time ( request ) ;
if ( oldest > created || oldest == 0 ) oldest = created ;
}
auth_client_request_server_input ( request , AUTH_REQUEST_STATUS_INTERNAL_FAIL , temp_failure_args ) ;
}
hash_table_iterate_deinit ( & iter ) ;
hash_table_clear ( conn -> requests , FALSE ) ;
if ( request_count > 0 ) {
i_warning ( "Auth connection closed with %u pending requests " "(max %u secs, pid=%s, %s)" , request_count , ( unsigned int ) ( ioloop_time - oldest ) , my_pid , disconnect_reason ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_update_spatial_layer_framerate ( VP9_COMP * const cpi , double framerate ) {
const VP9EncoderConfig * const oxcf = & cpi -> oxcf ;
LAYER_CONTEXT * const lc = get_layer_context ( cpi ) ;
RATE_CONTROL * const lrc = & lc -> rc ;
lc -> framerate = framerate ;
lrc -> avg_frame_bandwidth = ( int ) ( lc -> target_bandwidth / lc -> framerate ) ;
lrc -> min_frame_bandwidth = ( int ) ( lrc -> avg_frame_bandwidth * oxcf -> two_pass_vbrmin_section / 100 ) ;
lrc -> max_frame_bandwidth = ( int ) ( ( ( int64_t ) lrc -> avg_frame_bandwidth * oxcf -> two_pass_vbrmax_section ) / 100 ) ;
vp9_rc_set_gf_max_interval ( cpi , lrc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void exsltSaxonExpressionFunction ( xmlXPathParserContextPtr ctxt , int nargs ) {
xmlChar * arg ;
xmlXPathCompExprPtr ret ;
xmlHashTablePtr hash ;
xsltTransformContextPtr tctxt = xsltXPathGetTransformContext ( ctxt ) ;
if ( nargs != 1 ) {
xmlXPathSetArityError ( ctxt ) ;
return ;
}
arg = xmlXPathPopString ( ctxt ) ;
if ( xmlXPathCheckError ( ctxt ) || ( arg == NULL ) ) {
xmlXPathSetTypeError ( ctxt ) ;
return ;
}
hash = ( xmlHashTablePtr ) xsltGetExtData ( tctxt , ctxt -> context -> functionURI ) ;
ret = xmlHashLookup ( hash , arg ) ;
if ( ret == NULL ) {
ret = xmlXPathCompile ( arg ) ;
if ( ret == NULL ) {
xmlFree ( arg ) ;
xsltGenericError ( xsltGenericErrorContext , "{
%s}
:%s: argument is not an XPath expression\n" , ctxt -> context -> functionURI , ctxt -> context -> function ) ;
return ;
}
xmlHashAddEntry ( hash , arg , ( void * ) ret ) ;
}
xmlFree ( arg ) ;
xmlXPathReturnExternal ( ctxt , ret ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorJSONExpirePassword ( qemuMonitorPtr mon , const char * protocol , const char * expire_time ) {
int ret ;
virJSONValuePtr cmd = qemuMonitorJSONMakeCommand ( "expire_password" , "s:protocol" , protocol , "s:time" , expire_time , NULL ) ;
virJSONValuePtr reply = NULL ;
if ( ! cmd ) return - 1 ;
ret = qemuMonitorJSONCommand ( mon , cmd , & reply ) ;
if ( ret == 0 ) {
if ( qemuMonitorJSONHasError ( reply , "CommandNotFound" ) ) {
ret = - 2 ;
goto cleanup ;
}
ret = qemuMonitorJSONCheckError ( cmd , reply ) ;
}
cleanup : virJSONValueFree ( cmd ) ;
virJSONValueFree ( reply ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int _process_persist_conn ( void * arg , persist_msg_t * persist_msg , Buf * out_buffer , uint32_t * uid ) {
slurm_msg_t msg ;
slurm_persist_conn_t * persist_conn = arg ;
if ( * uid == NO_VAL ) * uid = g_slurm_auth_get_uid ( persist_conn -> auth_cred , slurmctld_config . auth_info ) ;
* out_buffer = NULL ;
slurm_msg_t_init ( & msg ) ;
msg . auth_cred = persist_conn -> auth_cred ;
msg . conn = persist_conn ;
msg . conn_fd = persist_conn -> fd ;
msg . msg_type = persist_msg -> msg_type ;
msg . data = persist_msg -> data ;
slurmctld_req ( & msg , NULL ) ;
return SLURM_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void clear_log ( int need_lock ) {
int i ;
if ( need_lock ) pthread_mutex_lock ( & log_mutex ) ;
for ( i = 0 ;
i < log_buffer_size ;
i ++ ) {
av_freep ( & log_buffer [ i ] . context_name ) ;
av_freep ( & log_buffer [ i ] . parent_name ) ;
av_freep ( & log_buffer [ i ] . log_message ) ;
}
log_buffer_size = 0 ;
if ( need_lock ) pthread_mutex_unlock ( & log_mutex ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ClientHintsBrowserTest , ClientHintsLifetimeNotPersistedJavaScriptBlocked ) {
ContentSettingsForOneType host_settings ;
ui_test_utils : : NavigateToURL ( browser ( ) , without_accept_ch_without_lifetime_url ( ) ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> SetContentSettingDefaultScope ( accept_ch_with_lifetime_url ( ) , GURL ( ) , CONTENT_SETTINGS_TYPE_JAVASCRIPT , std : : string ( ) , CONTENT_SETTING_BLOCK ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , accept_ch_with_lifetime_url ( ) ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> GetSettingsForOneType ( CONTENT_SETTINGS_TYPE_CLIENT_HINTS , std : : string ( ) , & host_settings ) ;
EXPECT_EQ ( 0u , host_settings . size ( ) ) ;
VerifyContentSettingsNotNotified ( ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> SetContentSettingDefaultScope ( accept_ch_with_lifetime_url ( ) , GURL ( ) , CONTENT_SETTINGS_TYPE_JAVASCRIPT , std : : string ( ) , CONTENT_SETTING_ALLOW ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , accept_ch_with_lifetime_url ( ) ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> GetSettingsForOneType ( CONTENT_SETTINGS_TYPE_CLIENT_HINTS , std : : string ( ) , & host_settings ) ;
EXPECT_EQ ( 1u , host_settings . size ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cpu_request_exit ( void * opaque , int irq , int level ) {
CPUMIPSState * env = cpu_single_env ;
if ( env && level ) {
cpu_exit ( CPU ( mips_env_get_cpu ( env ) ) ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ff_h263_encode_gob_header ( MpegEncContext * s , int mb_line ) {
put_bits ( & s -> pb , 17 , 1 ) ;
if ( s -> h263_slice_structured ) {
put_bits ( & s -> pb , 1 , 1 ) ;
ff_h263_encode_mba ( s ) ;
if ( s -> mb_num > 1583 ) put_bits ( & s -> pb , 1 , 1 ) ;
put_bits ( & s -> pb , 5 , s -> qscale ) ;
put_bits ( & s -> pb , 1 , 1 ) ;
put_bits ( & s -> pb , 2 , s -> pict_type == AV_PICTURE_TYPE_I ) ;
}
else {
int gob_number = mb_line / s -> gob_index ;
put_bits ( & s -> pb , 5 , gob_number ) ;
put_bits ( & s -> pb , 2 , s -> pict_type == AV_PICTURE_TYPE_I ) ;
put_bits ( & s -> pb , 5 , s -> qscale ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( RecursiveDirectoryIterator , hasChildren ) {
zend_bool allow_links = 0 ;
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "|b" , & allow_links ) == FAILURE ) {
return ;
}
if ( spl_filesystem_is_invalid_or_dot ( intern -> u . dir . entry . d_name ) ) {
RETURN_FALSE ;
}
else {
spl_filesystem_object_get_file_name ( intern TSRMLS_CC ) ;
if ( ! allow_links && ! ( intern -> flags & SPL_FILE_DIR_FOLLOW_SYMLINKS ) ) {
php_stat ( intern -> file_name , intern -> file_name_len , FS_IS_LINK , return_value TSRMLS_CC ) ;
if ( zend_is_true ( return_value ) ) {
RETURN_FALSE ;
}
}
php_stat ( intern -> file_name , intern -> file_name_len , FS_IS_DIR , return_value TSRMLS_CC ) ;
}
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.