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 int dissect_h245_INTEGER_0_1073741823 ( 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 , 1073741823U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void set_good_speed_feature ( VP9_COMP * cpi , VP9_COMMON * cm , SPEED_FEATURES * sf , int speed ) {
const int boosted = frame_is_boosted ( cpi ) ;
sf -> adaptive_rd_thresh = 1 ;
sf -> allow_skip_recode = 1 ;
if ( speed >= 1 ) {
sf -> use_square_partition_only = ! frame_is_intra_only ( cm ) ;
sf -> less_rectangular_check = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> disable_split_mask = cm -> show_frame ? DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT ;
else sf -> disable_split_mask = DISABLE_COMPOUND_SPLIT ;
sf -> use_rd_breakout = 1 ;
sf -> adaptive_motion_search = 1 ;
sf -> mv . auto_mv_step_size = 1 ;
sf -> adaptive_rd_thresh = 2 ;
sf -> mv . subpel_iters_per_step = 1 ;
sf -> mode_skip_start = 10 ;
sf -> adaptive_pred_interp_filter = 1 ;
sf -> recode_loop = ALLOW_RECODE_KFARFGF ;
sf -> intra_y_mode_mask [ TX_32X32 ] = INTRA_DC_H_V ;
sf -> intra_uv_mode_mask [ TX_32X32 ] = INTRA_DC_H_V ;
sf -> intra_y_mode_mask [ TX_16X16 ] = INTRA_DC_H_V ;
sf -> intra_uv_mode_mask [ TX_16X16 ] = INTRA_DC_H_V ;
sf -> tx_size_search_breakout = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 23 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 21 ) ;
sf -> partition_search_breakout_rate_thr = 500 ;
}
if ( speed >= 2 ) {
sf -> tx_size_search_method = frame_is_boosted ( cpi ) ? USE_FULL_RD : USE_LARGESTALL ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) {
sf -> disable_split_mask = cm -> show_frame ? DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT ;
sf -> adaptive_pred_interp_filter = 0 ;
}
else {
sf -> disable_split_mask = LAST_AND_INTRA_SPLIT_ONLY ;
}
sf -> reference_masking = 1 ;
sf -> mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH | FLAG_SKIP_INTRA_BESTINTER | FLAG_SKIP_COMP_BESTINTRA | FLAG_SKIP_INTRA_LOWVAR ;
sf -> disable_filter_search_var_thresh = 100 ;
sf -> comp_inter_joint_search_thresh = BLOCK_SIZES ;
sf -> auto_min_max_partition_size = CONSTRAIN_NEIGHBORING_MIN_MAX ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 24 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 22 ) ;
sf -> partition_search_breakout_rate_thr = 700 ;
}
if ( speed >= 3 ) {
sf -> tx_size_search_method = frame_is_intra_only ( cm ) ? USE_FULL_RD : USE_LARGESTALL ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) {
sf -> disable_split_mask = DISABLE_ALL_SPLIT ;
sf -> schedule_mode_search = cm -> base_qindex < 220 ? 1 : 0 ;
}
else {
sf -> max_intra_bsize = BLOCK_32X32 ;
sf -> disable_split_mask = DISABLE_ALL_INTER_SPLIT ;
sf -> schedule_mode_search = cm -> base_qindex < 175 ? 1 : 0 ;
}
sf -> adaptive_pred_interp_filter = 0 ;
sf -> adaptive_mode_search = 1 ;
sf -> cb_partition_search = ! boosted ;
sf -> cb_pred_filter_search = 1 ;
sf -> alt_ref_search_fp = 1 ;
sf -> motion_field_mode_search = ! boosted ;
sf -> recode_loop = ALLOW_RECODE_KFMAXBW ;
sf -> adaptive_rd_thresh = 3 ;
sf -> mode_skip_start = 6 ;
sf -> intra_y_mode_mask [ TX_32X32 ] = INTRA_DC ;
sf -> intra_uv_mode_mask [ TX_32X32 ] = INTRA_DC ;
sf -> adaptive_interp_filter_search = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 25 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 23 ) ;
sf -> partition_search_breakout_rate_thr = 1000 ;
}
if ( speed >= 4 ) {
sf -> use_square_partition_only = 1 ;
sf -> tx_size_search_method = USE_LARGESTALL ;
sf -> disable_split_mask = DISABLE_ALL_SPLIT ;
sf -> mv . search_method = BIGDIA ;
sf -> mv . subpel_search_method = SUBPEL_TREE_PRUNED ;
sf -> adaptive_rd_thresh = 4 ;
sf -> mode_search_skip_flags |= FLAG_EARLY_TERMINATE ;
sf -> disable_filter_search_var_thresh = 200 ;
sf -> use_lp32x32fdct = 1 ;
sf -> use_fast_coef_updates = ONE_LOOP_REDUCED ;
sf -> use_fast_coef_costing = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 26 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 24 ) ;
sf -> partition_search_breakout_rate_thr = 1500 ;
}
if ( speed >= 5 ) {
int i ;
sf -> partition_search_type = FIXED_PARTITION ;
sf -> optimize_coefficients = 0 ;
sf -> mv . search_method = HEX ;
sf -> disable_filter_search_var_thresh = 500 ;
for ( i = 0 ;
i < TX_SIZES ;
++ i ) {
sf -> intra_y_mode_mask [ i ] = INTRA_DC ;
sf -> intra_uv_mode_mask [ i ] = INTRA_DC ;
}
cpi -> allow_encode_breakout = ENCODE_BREAKOUT_ENABLED ;
}
if ( speed >= 6 ) {
sf -> mv . reduce_first_step_size = 1 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void message ( BIO * out , char * m ) {
fprintf ( stderr , "test %s\n" , m ) ;
BIO_puts ( out , "print \"test " ) ;
BIO_puts ( out , m ) ;
BIO_puts ( out , "\\n\"\n" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( NativeBackendLibsecretTest , PSLUpdatingStrictUpdateLogin ) {
CheckPSLUpdate ( UPDATE_BY_UPDATELOGIN ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void rate_block ( int plane , int block , BLOCK_SIZE plane_bsize , TX_SIZE tx_size , struct rdcost_block_args * args ) {
int x_idx , y_idx ;
txfrm_block_to_raster_xy ( plane_bsize , tx_size , block , & x_idx , & y_idx ) ;
args -> rate = cost_coeffs ( args -> x , plane , block , args -> t_above + x_idx , args -> t_left + y_idx , tx_size , args -> so -> scan , args -> so -> neighbors , args -> use_fast_coef_costing ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * cgfs_init ( const char * name ) {
struct cgfs_data * d ;
d = malloc ( sizeof ( * d ) ) ;
if ( ! d ) return NULL ;
memset ( d , 0 , sizeof ( * d ) ) ;
d -> name = strdup ( name ) ;
if ( ! d -> name ) goto err1 ;
d -> cgroup_pattern = lxc_global_config_value ( "lxc.cgroup.pattern" ) ;
d -> meta = lxc_cgroup_load_meta ( ) ;
if ( ! d -> meta ) {
ERROR ( "cgroupfs failed to detect cgroup metadata" ) ;
goto err2 ;
}
return d ;
err2 : free ( d -> name ) ;
err1 : free ( d ) ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int rebuild_existing_bitmaps ( struct packing_data * mapping , khash_sha1 * reused_bitmaps , int show_progress ) {
uint32_t i , num_objects ;
uint32_t * reposition ;
struct bitmap * rebuild ;
struct stored_bitmap * stored ;
struct progress * progress = NULL ;
khiter_t hash_pos ;
int hash_ret ;
if ( prepare_bitmap_git ( ) < 0 ) return - 1 ;
num_objects = bitmap_git . pack -> num_objects ;
reposition = xcalloc ( num_objects , sizeof ( uint32_t ) ) ;
for ( i = 0 ;
i < num_objects ;
++ i ) {
const unsigned char * sha1 ;
struct revindex_entry * entry ;
struct object_entry * oe ;
entry = & bitmap_git . pack -> revindex [ i ] ;
sha1 = nth_packed_object_sha1 ( bitmap_git . pack , entry -> nr ) ;
oe = packlist_find ( mapping , sha1 , NULL ) ;
if ( oe ) reposition [ i ] = oe -> in_pack_pos + 1 ;
}
rebuild = bitmap_new ( ) ;
i = 0 ;
if ( show_progress ) progress = start_progress ( "Reusing bitmaps" , 0 ) ;
kh_foreach_value ( bitmap_git . bitmaps , stored , {
if ( stored -> flags & BITMAP_FLAG_REUSE ) {
if ( ! rebuild_bitmap ( reposition , lookup_stored_bitmap ( stored ) , rebuild ) ) {
hash_pos = kh_put_sha1 ( reused_bitmaps , stored -> sha1 , & hash_ret ) ;
kh_value ( reused_bitmaps , hash_pos ) = bitmap_to_ewah ( rebuild ) ;
}
bitmap_reset ( rebuild ) ;
display_progress ( progress , ++ i ) ;
}
}
) ;
stop_progress ( & progress ) ;
free ( reposition ) ;
bitmap_free ( rebuild ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSMBufferDestroy ( TSMBuffer bufp ) {
if ( ! isWriteable ( bufp ) ) {
return TS_ERROR ;
}
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
HdrHeapSDKHandle * sdk_heap = ( HdrHeapSDKHandle * ) bufp ;
sdk_heap -> m_heap -> destroy ( ) ;
delete sdk_heap ;
return TS_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int test_stdout_behavior ( xd3_stream * stream , int ignore ) {
int ret ;
char buf [ TESTBUFSIZE ] ;
test_setup ( ) ;
snprintf_func ( buf , TESTBUFSIZE , "cp /devull %s" , TEST_TARGET_FILE ) ;
if ( ( ret = do_cmd ( stream , buf ) ) ) {
return ret ;
}
snprintf_func ( buf , TESTBUFSIZE , "%s -e %s %s" , program_name , TEST_TARGET_FILE , TEST_DELTA_FILE ) ;
if ( ( ret = do_cmd ( stream , buf ) ) ) {
return ret ;
}
snprintf_func ( buf , TESTBUFSIZE , "%s -e -c %s > %s" , program_name , TEST_TARGET_FILE , TEST_DELTA_FILE ) ;
if ( ( ret = do_cmd ( stream , buf ) ) ) {
return ret ;
}
snprintf_func ( buf , TESTBUFSIZE , "%s -q -d %s " , program_name , TEST_DELTA_FILE ) ;
if ( ( ret = do_fail ( stream , buf ) ) ) {
return ret ;
}
snprintf_func ( buf , TESTBUFSIZE , "%s -d -c %s > /devull" , program_name , TEST_DELTA_FILE ) ;
if ( ( ret = do_cmd ( stream , buf ) ) ) {
return ret ;
}
test_cleanup ( ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char ) typedef void * OPENSSL_BLOCK ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_BLOCK , void )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void fail ( const char * format , ... ) {
va_list arg_ptr ;
fflush ( stdout ) ;
fprintf ( stderr , "%s: " , PGM ) ;
if ( wherestr ) fprintf ( stderr , "%s: " , wherestr ) ;
va_start ( arg_ptr , format ) ;
vfprintf ( stderr , format , arg_ptr ) ;
va_end ( arg_ptr ) ;
error_count ++ ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static byte * i_alloc_string_immovable ( gs_memory_t * mem , uint nbytes , client_name_t cname ) {
gs_ref_memory_t * const imem = ( gs_ref_memory_t * ) mem ;
byte * str ;
uint asize ;
clump_t * cp ;
nbytes += HDR_ID_OFFSET ;
# ifdef MEMENTO if ( Memento_failThisEvent ( ) ) return NULL ;
# endif asize = string_clump_space ( nbytes ) + sizeof ( clump_head_t ) ;
cp = alloc_acquire_clump ( imem , ( ulong ) asize , true , "large string clump" ) ;
if ( cp == 0 ) return 0 ;
cp -> c_alone = true ;
str = cp -> ctop = cp -> climit - nbytes ;
if_debug4m ( 'a' , mem , "[a%d|+>L]%s(%u) = 0x%lx\n" , alloc_trace_space ( imem ) , client_name_string ( cname ) , nbytes , ( ulong ) str ) ;
gs_alloc_fill ( str , gs_alloc_fill_alloc , nbytes ) ;
str += HDR_ID_OFFSET ;
ASSIGN_HDR_ID ( str ) ;
return str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_q931_tpkt_pdu ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data _U_ ) {
dissect_q931_pdu ( tvb , pinfo , tree , TRUE ) ;
return tvb_captured_length ( tvb ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_mswsp_smb2 ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data ) {
smb2_info_t * si = ( smb2_info_t * ) data ;
gboolean in ;
char * fid_name = NULL ;
guint32 open_frame = 0 , close_frame = 0 ;
if ( ! si ) {
return 0 ;
}
if ( si -> saved ) {
dcerpc_fetch_polhnd_data ( & si -> saved -> policy_hnd , & fid_name , NULL , & open_frame , & close_frame , pinfo -> num ) ;
}
if ( ! fid_name || strcmp ( fid_name , "File: MsFteWds" ) != 0 ) {
return 0 ;
}
in = ! ( si -> flags & SMB2_FLAGS_RESPONSE ) ;
p_add_proto_data ( wmem_file_scope ( ) , pinfo , proto_mswsp , 0 , ( void * ) & SMB2 ) ;
return dissect_mswsp ( tvb , pinfo , tree , in , data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_shm_shmat ( struct shmid_kernel * shp , char __user * shmaddr , int shmflg ) {
u32 perms ;
if ( shmflg & SHM_RDONLY ) perms = SHM__READ ;
else perms = SHM__READ | SHM__WRITE ;
return ipc_has_perm ( & shp -> shm_perm , perms ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void evhttp_write_buffer ( struct evhttp_connection * evcon , void ( * cb ) ( struct evhttp_connection * , void * ) , void * arg ) {
event_debug ( ( "%s: preparing to write buffer\n" , __func__ ) ) ;
evcon -> cb = cb ;
evcon -> cb_arg = arg ;
if ( event_pending ( & evcon -> ev , EV_WRITE | EV_TIMEOUT , NULL ) ) event_del ( & evcon -> ev ) ;
event_set ( & evcon -> ev , evcon -> fd , EV_WRITE , evhttp_write , evcon ) ;
EVHTTP_BASE_SET ( evcon , & evcon -> ev ) ;
evhttp_add_event ( & evcon -> ev , evcon -> timeout , HTTP_WRITE_TIMEOUT ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static qcelp_packet_rate determine_bitrate ( AVCodecContext * avctx , const int buf_size , const uint8_t * * buf ) {
qcelp_packet_rate bitrate ;
if ( ( bitrate = buf_size2bitrate ( buf_size ) ) >= 0 ) {
if ( bitrate > * * buf ) {
QCELPContext * q = avctx -> priv_data ;
if ( ! q -> warned_buf_mismatch_bitrate ) {
av_log ( avctx , AV_LOG_WARNING , "Claimed bitrate and buffer size mismatch.\n" ) ;
q -> warned_buf_mismatch_bitrate = 1 ;
}
bitrate = * * buf ;
}
else if ( bitrate < * * buf ) {
av_log ( avctx , AV_LOG_ERROR , "Buffer is too small for the claimed bitrate.\n" ) ;
return I_F_Q ;
}
( * buf ) ++ ;
}
else if ( ( bitrate = buf_size2bitrate ( buf_size + 1 ) ) >= 0 ) {
av_log ( avctx , AV_LOG_WARNING , "Bitrate byte is missing, guessing the bitrate from packet size.\n" ) ;
}
else return I_F_Q ;
if ( bitrate == SILENCE ) {
av_log_ask_for_sample ( avctx , "'Blank frame handling is experimental." ) ;
}
return bitrate ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int pfkey_sockaddr_size ( sa_family_t family ) {
return PFKEY_ALIGN8 ( pfkey_sockaddr_len ( family ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void flat_print_str ( WriterContext * wctx , const char * key , const char * value ) {
FlatContext * flat = wctx -> priv ;
AVBPrint buf ;
printf ( "%s" , wctx -> section_pbuf [ wctx -> level ] . str ) ;
av_bprint_init ( & buf , 1 , AV_BPRINT_SIZE_UNLIMITED ) ;
printf ( "%s=" , flat_escape_key_str ( & buf , key , flat -> sep ) ) ;
av_bprint_clear ( & buf ) ;
printf ( "\"%s\"\n" , flat_escape_value_str ( & buf , value ) ) ;
av_bprint_finalize ( & buf , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int mpeg4_decode_profile_level ( MpegEncContext * s , GetBitContext * gb ) {
int profile_and_level_indication ;
profile_and_level_indication = get_bits ( gb , 8 ) ;
s -> avctx -> profile = ( profile_and_level_indication & 0xf0 ) >> 4 ;
s -> avctx -> level = ( profile_and_level_indication & 0x0f ) ;
if ( s -> avctx -> profile == 0 && s -> avctx -> level == 8 ) {
s -> avctx -> level = 0 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int at1_unpack_dequant ( GetBitContext * gb , AT1SUCtx * su , float spec [ AT1_SU_SAMPLES ] ) {
int bits_used , band_num , bfu_num , i ;
uint8_t idwls [ AT1_MAX_BFU ] ;
uint8_t idsfs [ AT1_MAX_BFU ] ;
su -> num_bfus = bfu_amount_tab1 [ get_bits ( gb , 3 ) ] ;
bits_used = su -> num_bfus * 10 + 32 + bfu_amount_tab2 [ get_bits ( gb , 2 ) ] + ( bfu_amount_tab3 [ get_bits ( gb , 3 ) ] << 1 ) ;
for ( i = 0 ;
i < su -> num_bfus ;
i ++ ) idwls [ i ] = get_bits ( gb , 4 ) ;
for ( i = 0 ;
i < su -> num_bfus ;
i ++ ) idsfs [ i ] = get_bits ( gb , 6 ) ;
for ( i = su -> num_bfus ;
i < AT1_MAX_BFU ;
i ++ ) idwls [ i ] = idsfs [ i ] = 0 ;
for ( band_num = 0 ;
band_num < AT1_QMF_BANDS ;
band_num ++ ) {
for ( bfu_num = bfu_bands_t [ band_num ] ;
bfu_num < bfu_bands_t [ band_num + 1 ] ;
bfu_num ++ ) {
int pos ;
int num_specs = specs_per_bfu [ bfu_num ] ;
int word_len = ! ! idwls [ bfu_num ] + idwls [ bfu_num ] ;
float scale_factor = ff_atrac_sf_table [ idsfs [ bfu_num ] ] ;
bits_used += word_len * num_specs ;
if ( bits_used > AT1_SU_MAX_BITS ) return AVERROR_INVALIDDATA ;
pos = su -> log2_block_count [ band_num ] ? bfu_start_short [ bfu_num ] : bfu_start_long [ bfu_num ] ;
if ( word_len ) {
float max_quant = 1.0 / ( float ) ( ( 1 << ( word_len - 1 ) ) - 1 ) ;
for ( i = 0 ;
i < num_specs ;
i ++ ) {
spec [ pos + i ] = get_sbits ( gb , word_len ) * scale_factor * max_quant ;
}
}
else {
memset ( & spec [ pos ] , 0 , num_specs * sizeof ( float ) ) ;
}
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
xmlChar * xsltAttrTemplateValueProcessNode ( xsltTransformContextPtr ctxt , const xmlChar * str , xmlNodePtr inst ) {
xmlChar * ret = NULL ;
const xmlChar * cur ;
xmlChar * expr , * val ;
xmlNsPtr * nsList = NULL ;
int nsNr = 0 ;
if ( str == NULL ) return ( NULL ) ;
if ( * str == 0 ) return ( xmlStrndup ( ( xmlChar * ) "" , 0 ) ) ;
cur = str ;
while ( * cur != 0 ) {
if ( * cur == '{
' ) {
if ( * ( cur + 1 ) == '{
' ) {
cur ++ ;
ret = xmlStrncat ( ret , str , cur - str ) ;
cur ++ ;
str = cur ;
continue ;
}
ret = xmlStrncat ( ret , str , cur - str ) ;
str = cur ;
cur ++ ;
while ( ( * cur != 0 ) && ( * cur != '}
' ) ) {
if ( ( * cur == '\'' ) || ( * cur == '"' ) ) {
char delim = * ( cur ++ ) ;
while ( ( * cur != 0 ) && ( * cur != delim ) ) cur ++ ;
if ( * cur != 0 ) cur ++ ;
}
else cur ++ ;
}
if ( * cur == 0 ) {
xsltTransformError ( ctxt , NULL , inst , "xsltAttrTemplateValueProcessNode: unmatched '{
'\n" ) ;
ret = xmlStrncat ( ret , str , cur - str ) ;
return ( ret ) ;
}
str ++ ;
expr = xmlStrndup ( str , cur - str ) ;
if ( expr == NULL ) return ( ret ) ;
else if ( * expr == '{
' ) {
ret = xmlStrcat ( ret , expr ) ;
xmlFree ( expr ) ;
}
else {
xmlXPathCompExprPtr comp ;
if ( ( nsList == NULL ) && ( inst != NULL ) ) {
int i = 0 ;
nsList = xmlGetNsList ( inst -> doc , inst ) ;
if ( nsList != NULL ) {
while ( nsList [ i ] != NULL ) i ++ ;
nsNr = i ;
}
}
comp = xmlXPathCompile ( expr ) ;
val = xsltEvalXPathStringNs ( ctxt , comp , nsNr , nsList ) ;
xmlXPathFreeCompExpr ( comp ) ;
xmlFree ( expr ) ;
if ( val != NULL ) {
ret = xmlStrcat ( ret , val ) ;
xmlFree ( val ) ;
}
}
cur ++ ;
str = cur ;
}
else if ( * cur == '}
' ) {
cur ++ ;
if ( * cur == '}
' ) {
ret = xmlStrncat ( ret , str , cur - str ) ;
cur ++ ;
str = cur ;
continue ;
}
else {
xsltTransformError ( ctxt , NULL , inst , "xsltAttrTemplateValueProcessNode: unmatched '}
'\n" ) ;
}
}
else cur ++ ;
}
if ( cur != str ) {
ret = xmlStrncat ( ret , str , cur - str ) ;
}
if ( nsList != NULL ) xmlFree ( nsList ) ;
return ( ret ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int nsv_read_chunk ( AVFormatContext * s , int fill_header ) {
NSVContext * nsv = s -> priv_data ;
AVIOContext * pb = s -> pb ;
AVStream * st [ 2 ] = {
NULL , NULL }
;
NSVStream * nst ;
AVPacket * pkt ;
int i , err = 0 ;
uint8_t auxcount ;
uint32_t vsize ;
uint16_t asize ;
uint16_t auxsize ;
int ret ;
if ( nsv -> ahead [ 0 ] . data || nsv -> ahead [ 1 ] . data ) return 0 ;
null_chunk_retry : if ( avio_feof ( pb ) ) return - 1 ;
for ( i = 0 ;
i < NSV_MAX_RESYNC_TRIES && nsv -> state < NSV_FOUND_NSVS && ! err ;
i ++ ) err = nsv_resync ( s ) ;
if ( err < 0 ) return err ;
if ( nsv -> state == NSV_FOUND_NSVS ) err = nsv_parse_NSVs_header ( s ) ;
if ( err < 0 ) return err ;
if ( nsv -> state != NSV_HAS_READ_NSVS && nsv -> state != NSV_FOUND_BEEF ) return - 1 ;
auxcount = avio_r8 ( pb ) ;
vsize = avio_rl16 ( pb ) ;
asize = avio_rl16 ( pb ) ;
vsize = ( vsize << 4 ) | ( auxcount >> 4 ) ;
auxcount &= 0x0f ;
av_log ( s , AV_LOG_TRACE , "NSV CHUNK %d aux, %" PRIu32 " bytes video, %d bytes audio\n" , auxcount , vsize , asize ) ;
for ( i = 0 ;
i < auxcount ;
i ++ ) {
uint32_t av_unused auxtag ;
auxsize = avio_rl16 ( pb ) ;
auxtag = avio_rl32 ( pb ) ;
avio_skip ( pb , auxsize ) ;
vsize -= auxsize + sizeof ( uint16_t ) + sizeof ( uint32_t ) ;
}
if ( avio_feof ( pb ) ) return - 1 ;
if ( ! vsize && ! asize ) {
nsv -> state = NSV_UNSYNC ;
goto null_chunk_retry ;
}
if ( s -> nb_streams > 0 ) st [ s -> streams [ 0 ] -> id ] = s -> streams [ 0 ] ;
if ( s -> nb_streams > 1 ) st [ s -> streams [ 1 ] -> id ] = s -> streams [ 1 ] ;
if ( vsize && st [ NSV_ST_VIDEO ] ) {
nst = st [ NSV_ST_VIDEO ] -> priv_data ;
pkt = & nsv -> ahead [ NSV_ST_VIDEO ] ;
if ( ( ret = av_get_packet ( pb , pkt , vsize ) ) < 0 ) return ret ;
pkt -> stream_index = st [ NSV_ST_VIDEO ] -> index ;
pkt -> dts = nst -> frame_offset ;
pkt -> flags |= nsv -> state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0 ;
for ( i = 0 ;
i < FFMIN ( 8 , vsize ) ;
i ++ ) av_log ( s , AV_LOG_TRACE , "NSV video: [%d] = %02x\n" , i , pkt -> data [ i ] ) ;
}
if ( st [ NSV_ST_VIDEO ] ) ( ( NSVStream * ) st [ NSV_ST_VIDEO ] -> priv_data ) -> frame_offset ++ ;
if ( asize && st [ NSV_ST_AUDIO ] ) {
nst = st [ NSV_ST_AUDIO ] -> priv_data ;
pkt = & nsv -> ahead [ NSV_ST_AUDIO ] ;
if ( asize && st [ NSV_ST_AUDIO ] -> codecpar -> codec_tag == MKTAG ( 'P' , 'C' , 'M' , ' ' ) ) {
uint8_t bps ;
uint8_t channels ;
uint16_t samplerate ;
bps = avio_r8 ( pb ) ;
channels = avio_r8 ( pb ) ;
samplerate = avio_rl16 ( pb ) ;
if ( ! channels || ! samplerate ) return AVERROR_INVALIDDATA ;
asize -= 4 ;
av_log ( s , AV_LOG_TRACE , "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n" , bps , channels , samplerate ) ;
if ( fill_header ) {
st [ NSV_ST_AUDIO ] -> need_parsing = AVSTREAM_PARSE_NONE ;
if ( bps != 16 ) {
av_log ( s , AV_LOG_TRACE , "NSV AUDIO bit/sample != 16 (%d)!!!\n" , bps ) ;
}
bps /= channels ;
if ( bps == 8 ) st [ NSV_ST_AUDIO ] -> codecpar -> codec_id = AV_CODEC_ID_PCM_U8 ;
samplerate /= 4 ;
channels = 1 ;
st [ NSV_ST_AUDIO ] -> codecpar -> channels = channels ;
st [ NSV_ST_AUDIO ] -> codecpar -> sample_rate = samplerate ;
av_log ( s , AV_LOG_TRACE , "NSV RAWAUDIO: bps %d, nchan %d, srate %d\n" , bps , channels , samplerate ) ;
}
}
if ( ( ret = av_get_packet ( pb , pkt , asize ) ) < 0 ) return ret ;
pkt -> stream_index = st [ NSV_ST_AUDIO ] -> index ;
pkt -> flags |= nsv -> state == NSV_HAS_READ_NSVS ? AV_PKT_FLAG_KEY : 0 ;
if ( nsv -> state == NSV_HAS_READ_NSVS && st [ NSV_ST_VIDEO ] ) {
pkt -> dts = ( ( ( NSVStream * ) st [ NSV_ST_VIDEO ] -> priv_data ) -> frame_offset - 1 ) ;
pkt -> dts *= ( int64_t ) 1000 * nsv -> framerate . den ;
pkt -> dts += ( int64_t ) nsv -> avsync * nsv -> framerate . num ;
av_log ( s , AV_LOG_TRACE , "NSV AUDIO: sync:%d, dts:%" PRId64 , nsv -> avsync , pkt -> dts ) ;
}
nst -> frame_offset ++ ;
}
nsv -> state = NSV_UNSYNC ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_ber_T_octet_aligned ( gboolean implicit_tag _U_ , tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
if ( actx -> external . u . ber . ber_callback ) {
offset = actx -> external . u . ber . ber_callback ( FALSE , tvb , offset , actx , tree , hf_index ) ;
}
else if ( actx -> external . direct_ref_present && dissector_get_string_handle ( ber_oid_dissector_table , actx -> external . direct_reference ) ) {
offset = call_ber_oid_callback ( actx -> external . direct_reference , tvb , offset , actx -> pinfo , tree , NULL ) ;
}
else {
offset = dissect_ber_octet_string ( implicit_tag , actx , tree , tvb , offset , hf_index , & actx -> external . octet_aligned ) ;
}
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ShortcutsProviderTest , SimpleSingleMatch ) {
base : : string16 text ( ASCIIToUTF16 ( "go" ) ) ;
std : : string expected_url ( "http://www.google.com/" ) ;
ExpectedURLs expected_urls ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , true ) ) ;
RunShortcutsProviderTest ( provider_ , text , false , expected_urls , expected_url , ASCIIToUTF16 ( "ogle.com" ) ) ;
expected_urls . clear ( ) ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , false ) ) ;
RunShortcutsProviderTest ( provider_ , text , true , expected_urls , expected_url , ASCIIToUTF16 ( "ogle.com" ) ) ;
text = ASCIIToUTF16 ( "abcdef.com" ) ;
expected_url = "http://abcdef.com/" ;
expected_urls . clear ( ) ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , true ) ) ;
RunShortcutsProviderTest ( provider_ , text , false , expected_urls , expected_url , base : : string16 ( ) ) ;
RunShortcutsProviderTest ( provider_ , text , true , expected_urls , expected_url , base : : string16 ( ) ) ;
text = ASCIIToUTF16 ( "que" ) ;
expected_url = "https://www.google.com/search?q=query" ;
expected_urls . clear ( ) ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , true ) ) ;
RunShortcutsProviderTest ( provider_ , text , false , expected_urls , expected_url , ASCIIToUTF16 ( "ry" ) ) ;
expected_urls . clear ( ) ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , false ) ) ;
RunShortcutsProviderTest ( provider_ , text , true , expected_urls , expected_url , ASCIIToUTF16 ( "ry" ) ) ;
text = ASCIIToUTF16 ( "query" ) ;
expected_urls . clear ( ) ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , true ) ) ;
RunShortcutsProviderTest ( provider_ , text , false , expected_urls , expected_url , base : : string16 ( ) ) ;
RunShortcutsProviderTest ( provider_ , text , true , expected_urls , expected_url , base : : string16 ( ) ) ;
text = ASCIIToUTF16 ( "word" ) ;
expected_url = "https://www.google.com/search?q=www.word" ;
expected_urls . clear ( ) ;
expected_urls . push_back ( ExpectedURLAndAllowedToBeDefault ( expected_url , false ) ) ;
RunShortcutsProviderTest ( provider_ , text , false , expected_urls , expected_url , base : : string16 ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_rsl_ie_smscb_inf ( tvbuff_t * tvb , packet_info * pinfo _U_ , proto_tree * tree , int offset , gboolean is_mandatory ) {
proto_item * ti ;
proto_tree * ie_tree ;
tvbuff_t * next_tvb ;
guint length ;
guint8 ie_id ;
if ( is_mandatory == FALSE ) {
ie_id = tvb_get_guint8 ( tvb , offset ) ;
if ( ie_id != RSL_IE_SMSCB_INF ) return offset ;
}
ie_tree = proto_tree_add_subtree ( tree , tvb , offset , 0 , ett_ie_smscb_inf , & ti , "SMSCB Information IE " ) ;
proto_tree_add_item ( ie_tree , hf_rsl_ie_id , tvb , offset , 1 , ENC_BIG_ENDIAN ) ;
offset ++ ;
length = tvb_get_guint8 ( tvb , offset ) ;
proto_item_set_len ( ti , length + 2 ) ;
proto_tree_add_item ( ie_tree , hf_rsl_ie_length , tvb , offset , 1 , ENC_BIG_ENDIAN ) ;
offset ++ ;
next_tvb = tvb_new_subset_length ( tvb , offset , length ) ;
call_dissector ( gsm_cbch_handle , next_tvb , pinfo , top_tree ) ;
offset = offset + length ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int get_dns_name_type_class ( tvbuff_t * tvb , int offset , int dns_data_offset , const guchar * * name_ret , int * name_len_ret , int * type_ret , int * class_ret ) {
int len ;
int name_len ;
int type ;
int dns_class ;
int start_offset = offset ;
name_len = get_dns_name ( tvb , offset , 0 , dns_data_offset , name_ret ) ;
offset += name_len ;
type = tvb_get_ntohs ( tvb , offset ) ;
offset += 2 ;
dns_class = tvb_get_ntohs ( tvb , offset ) ;
offset += 2 ;
* type_ret = type ;
* class_ret = dns_class ;
* name_len_ret = name_len ;
len = offset - start_offset ;
return len ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int parse_CRowSeekAtRatio ( tvbuff_t * tvb , int offset , proto_tree * parent_tree , const char * fmt , ... ) {
proto_tree * tree ;
proto_item * item ;
va_list ap ;
const char * txt ;
va_start ( ap , fmt ) ;
txt = wmem_strdup_vprintf ( wmem_packet_scope ( ) , fmt , ap ) ;
va_end ( ap ) ;
tree = proto_tree_add_subtree ( parent_tree , tvb , offset , 0 , ett_CRowsSeekAtRatio , & item , txt ) ;
proto_tree_add_item ( tree , hf_mswsp_crowseekatratio_ulnumerator , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( tree , hf_mswsp_crowseekatratio_uldenominator , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( tree , hf_mswsp_crowseekatratio_hregion , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_item_set_end ( item , tvb , offset ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int do_show_slave_status ( MYSQL * mysql_con ) {
MYSQL_RES * slave = 0 ;
const char * comment_prefix = ( opt_slave_data == MYSQL_OPT_SLAVE_DATA_COMMENTED_SQL ) ? "-- " : "" ;
if ( mysql_query_with_error_report ( mysql_con , & slave , "SHOW SLAVE STATUS" ) ) {
if ( ! ignore_errors ) {
fprintf ( stderr , "%s: Error: Slave not set up\n" , my_progname_short ) ;
}
mysql_free_result ( slave ) ;
return 1 ;
}
else {
MYSQL_ROW row = mysql_fetch_row ( slave ) ;
if ( row && row [ 9 ] && row [ 21 ] ) {
if ( opt_comments ) fprintf ( md_result_file , "\n--\n-- Position to start replication or point-in-time " "recovery from (the master of this slave)\n--\n\n" ) ;
fprintf ( md_result_file , "%sCHANGE MASTER TO " , comment_prefix ) ;
if ( opt_include_master_host_port ) {
if ( row [ 1 ] ) fprintf ( md_result_file , "MASTER_HOST='%s', " , row [ 1 ] ) ;
if ( row [ 3 ] ) fprintf ( md_result_file , "MASTER_PORT=%s, " , row [ 3 ] ) ;
}
fprintf ( md_result_file , "MASTER_LOG_FILE='%s', MASTER_LOG_POS=%s;
\n" , row [ 9 ] , row [ 21 ] ) ;
check_io ( md_result_file ) ;
}
mysql_free_result ( slave ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void ohci_set_interrupt ( OHCIState * ohci , uint32_t intr ) {
ohci -> intr_status |= intr ;
ohci_intr_update ( ohci ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int pfkey_recvmsg ( struct kiocb * kiocb , struct socket * sock , struct msghdr * msg , size_t len , int flags ) {
struct sock * sk = sock -> sk ;
struct pfkey_sock * pfk = pfkey_sk ( sk ) ;
struct sk_buff * skb ;
int copied , err ;
err = - EINVAL ;
if ( flags & ~ ( MSG_PEEK | MSG_DONTWAIT | MSG_TRUNC | MSG_CMSG_COMPAT ) ) goto out ;
msg -> msg_namelen = 0 ;
skb = skb_recv_datagram ( sk , flags , flags & MSG_DONTWAIT , & err ) ;
if ( skb == NULL ) goto out ;
copied = skb -> len ;
if ( copied > len ) {
msg -> msg_flags |= MSG_TRUNC ;
copied = len ;
}
skb_reset_transport_header ( skb ) ;
err = skb_copy_datagram_iovec ( skb , 0 , msg -> msg_iov , copied ) ;
if ( err ) goto out_free ;
sock_recv_ts_and_drops ( msg , sk , skb ) ;
err = ( flags & MSG_TRUNC ) ? skb -> len : copied ;
if ( pfk -> dump . dump != NULL && * atomic_read ( & sk -> sk_rmem_alloc ) <= sk -> sk_rcvbuf ) pfkey_do_dump ( pfk ) ;
out_free : skb_free_datagram ( sk , skb ) ;
out : return err ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void apply_loop_filter ( Vp3DecodeContext * s , int plane , int ystart , int yend ) {
int x , y ;
int * bounding_values = s -> bounding_values_array + 127 ;
int width = s -> fragment_width [ ! ! plane ] ;
int height = s -> fragment_height [ ! ! plane ] ;
int fragment = s -> fragment_start [ plane ] + ystart * width ;
int stride = s -> current_frame . f -> linesize [ plane ] ;
uint8_t * plane_data = s -> current_frame . f -> data [ plane ] ;
if ( ! s -> flipped_image ) stride = - stride ;
plane_data += s -> data_offset [ plane ] + 8 * ystart * stride ;
for ( y = ystart ;
y < yend ;
y ++ ) {
for ( x = 0 ;
x < width ;
x ++ ) {
if ( s -> all_fragments [ fragment ] . coding_method != MODE_COPY ) {
if ( x > 0 ) {
s -> vp3dsp . h_loop_filter ( plane_data + 8 * x , stride , bounding_values ) ;
}
if ( y > 0 ) {
s -> vp3dsp . v_loop_filter ( plane_data + 8 * x , stride , bounding_values ) ;
}
if ( ( x < width - 1 ) && ( s -> all_fragments [ fragment + 1 ] . coding_method == MODE_COPY ) ) {
s -> vp3dsp . h_loop_filter ( plane_data + 8 * x + 8 , stride , bounding_values ) ;
}
if ( ( y < height - 1 ) && ( s -> all_fragments [ fragment + width ] . coding_method == MODE_COPY ) ) {
s -> vp3dsp . v_loop_filter ( plane_data + 8 * x + 8 * stride , stride , bounding_values ) ;
}
}
fragment ++ ;
}
plane_data += 8 * stride ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( UnloadTest , BrowserListDoubleCloseBeforeUnloadCancel ) {
NavigateToDataURL ( BEFORE_UNLOAD_HTML , "beforeunload" ) ;
UnloadResults unload_results ;
BrowserList : : CloseAllBrowsersWithProfile ( browser ( ) -> profile ( ) , base : : Bind ( & UnloadResults : : AddSuccess , base : : Unretained ( & unload_results ) ) , base : : Bind ( & UnloadResults : : AddAbort , base : : Unretained ( & unload_results ) ) , false ) ;
BrowserList : : CloseAllBrowsersWithProfile ( browser ( ) -> profile ( ) , base : : Bind ( & UnloadResults : : AddSuccess , base : : Unretained ( & unload_results ) ) , base : : Bind ( & UnloadResults : : AddAbort , base : : Unretained ( & unload_results ) ) , false ) ;
base : : string16 expected_title = base : : ASCIIToUTF16 ( "cancelled" ) ;
content : : TitleWatcher title_watcher ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , expected_title ) ;
ClickModalDialogButton ( false ) ;
ASSERT_EQ ( expected_title , title_watcher . WaitAndGetTitle ( ) ) ;
EXPECT_EQ ( 0 , unload_results . get_successes ( ) ) ;
EXPECT_EQ ( 1 , unload_results . get_aborts ( ) ) ;
content : : WindowedNotificationObserver window_observer ( chrome : : NOTIFICATION_BROWSER_CLOSED , content : : NotificationService : : AllSources ( ) ) ;
chrome : : CloseWindow ( browser ( ) ) ;
ClickModalDialogButton ( true ) ;
window_observer . Wait ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void keytype ( struct parse * pcmd , FILE * fp ) {
const char * digest_name ;
size_t digest_len ;
int key_type ;
if ( ! pcmd -> nargs ) {
fprintf ( fp , "keytype is %s with %lu octet digests\n" , keytype_name ( info_auth_keytype ) , ( u_long ) info_auth_hashlen ) ;
return ;
}
digest_name = pcmd -> argval [ 0 ] . string ;
digest_len = 0 ;
key_type = keytype_from_text ( digest_name , & digest_len ) ;
if ( ! key_type ) {
fprintf ( fp , "keytype is not valid. " # ifdef OPENSSL "Type \"help keytype\" for the available digest types.\n" ) ;
# else "Only \"md5\" is available.\n" ) ;
# endif return ;
}
info_auth_keytype = key_type ;
info_auth_hashlen = digest_len ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_ber_restricted_string ( gboolean implicit_tag , gint32 type , asn1_ctx_t * actx , proto_tree * tree , tvbuff_t * tvb , int offset , gint hf_id , tvbuff_t * * out_tvb ) {
return dissect_ber_constrained_restricted_string ( implicit_tag , type , actx , tree , tvb , offset , NO_BOUND , NO_BOUND , hf_id , out_tvb ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int is_mv_diff_gt_3 ( int16_t ( * motion_val ) [ 2 ] , int step ) {
int d ;
d = motion_val [ 0 ] [ 0 ] - motion_val [ - step ] [ 0 ] ;
if ( d < - 3 || d > 3 ) return 1 ;
d = motion_val [ 0 ] [ 1 ] - motion_val [ - step ] [ 1 ] ;
if ( d < - 3 || d > 3 ) return 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_lpf_horizontal_4_dual_sse2 ( unsigned char * s , int p , const unsigned char * _blimit0 , const unsigned char * _limit0 , const unsigned char * _thresh0 , const unsigned char * _blimit1 , const unsigned char * _limit1 , const unsigned char * _thresh1 ) {
const __m128i blimit = _mm_unpacklo_epi64 ( _mm_load_si128 ( ( const __m128i * ) _blimit0 ) , _mm_load_si128 ( ( const __m128i * ) _blimit1 ) ) ;
const __m128i limit = _mm_unpacklo_epi64 ( _mm_load_si128 ( ( const __m128i * ) _limit0 ) , _mm_load_si128 ( ( const __m128i * ) _limit1 ) ) ;
const __m128i thresh = _mm_unpacklo_epi64 ( _mm_load_si128 ( ( const __m128i * ) _thresh0 ) , _mm_load_si128 ( ( const __m128i * ) _thresh1 ) ) ;
const __m128i zero = _mm_set1_epi16 ( 0 ) ;
__m128i p3 , p2 , p1 , p0 , q0 , q1 , q2 , q3 ;
__m128i mask , hev , flat ;
p3 = _mm_loadu_si128 ( ( __m128i * ) ( s - 4 * p ) ) ;
p2 = _mm_loadu_si128 ( ( __m128i * ) ( s - 3 * p ) ) ;
p1 = _mm_loadu_si128 ( ( __m128i * ) ( s - 2 * p ) ) ;
p0 = _mm_loadu_si128 ( ( __m128i * ) ( s - 1 * p ) ) ;
q0 = _mm_loadu_si128 ( ( __m128i * ) ( s - 0 * p ) ) ;
q1 = _mm_loadu_si128 ( ( __m128i * ) ( s + 1 * p ) ) ;
q2 = _mm_loadu_si128 ( ( __m128i * ) ( s + 2 * p ) ) ;
q3 = _mm_loadu_si128 ( ( __m128i * ) ( s + 3 * p ) ) ;
{
const __m128i abs_p1p0 = _mm_or_si128 ( _mm_subs_epu8 ( p1 , p0 ) , _mm_subs_epu8 ( p0 , p1 ) ) ;
const __m128i abs_q1q0 = _mm_or_si128 ( _mm_subs_epu8 ( q1 , q0 ) , _mm_subs_epu8 ( q0 , q1 ) ) ;
const __m128i fe = _mm_set1_epi8 ( 0xfe ) ;
const __m128i ff = _mm_cmpeq_epi8 ( abs_p1p0 , abs_p1p0 ) ;
__m128i abs_p0q0 = _mm_or_si128 ( _mm_subs_epu8 ( p0 , q0 ) , _mm_subs_epu8 ( q0 , p0 ) ) ;
__m128i abs_p1q1 = _mm_or_si128 ( _mm_subs_epu8 ( p1 , q1 ) , _mm_subs_epu8 ( q1 , p1 ) ) ;
__m128i work ;
flat = _mm_max_epu8 ( abs_p1p0 , abs_q1q0 ) ;
hev = _mm_subs_epu8 ( flat , thresh ) ;
hev = _mm_xor_si128 ( _mm_cmpeq_epi8 ( hev , zero ) , ff ) ;
abs_p0q0 = _mm_adds_epu8 ( abs_p0q0 , abs_p0q0 ) ;
abs_p1q1 = _mm_srli_epi16 ( _mm_and_si128 ( abs_p1q1 , fe ) , 1 ) ;
mask = _mm_subs_epu8 ( _mm_adds_epu8 ( abs_p0q0 , abs_p1q1 ) , blimit ) ;
mask = _mm_xor_si128 ( _mm_cmpeq_epi8 ( mask , zero ) , ff ) ;
mask = _mm_max_epu8 ( flat , mask ) ;
work = _mm_max_epu8 ( _mm_or_si128 ( _mm_subs_epu8 ( p2 , p1 ) , _mm_subs_epu8 ( p1 , p2 ) ) , _mm_or_si128 ( _mm_subs_epu8 ( p3 , p2 ) , _mm_subs_epu8 ( p2 , p3 ) ) ) ;
mask = _mm_max_epu8 ( work , mask ) ;
work = _mm_max_epu8 ( _mm_or_si128 ( _mm_subs_epu8 ( q2 , q1 ) , _mm_subs_epu8 ( q1 , q2 ) ) , _mm_or_si128 ( _mm_subs_epu8 ( q3 , q2 ) , _mm_subs_epu8 ( q2 , q3 ) ) ) ;
mask = _mm_max_epu8 ( work , mask ) ;
mask = _mm_subs_epu8 ( mask , limit ) ;
mask = _mm_cmpeq_epi8 ( mask , zero ) ;
}
{
const __m128i t4 = _mm_set1_epi8 ( 4 ) ;
const __m128i t3 = _mm_set1_epi8 ( 3 ) ;
const __m128i t80 = _mm_set1_epi8 ( 0x80 ) ;
const __m128i te0 = _mm_set1_epi8 ( 0xe0 ) ;
const __m128i t1f = _mm_set1_epi8 ( 0x1f ) ;
const __m128i t1 = _mm_set1_epi8 ( 0x1 ) ;
const __m128i t7f = _mm_set1_epi8 ( 0x7f ) ;
const __m128i ps1 = _mm_xor_si128 ( _mm_loadu_si128 ( ( __m128i * ) ( s - 2 * p ) ) , t80 ) ;
const __m128i ps0 = _mm_xor_si128 ( _mm_loadu_si128 ( ( __m128i * ) ( s - 1 * p ) ) , t80 ) ;
const __m128i qs0 = _mm_xor_si128 ( _mm_loadu_si128 ( ( __m128i * ) ( s + 0 * p ) ) , t80 ) ;
const __m128i qs1 = _mm_xor_si128 ( _mm_loadu_si128 ( ( __m128i * ) ( s + 1 * p ) ) , t80 ) ;
__m128i filt ;
__m128i work_a ;
__m128i filter1 , filter2 ;
filt = _mm_and_si128 ( _mm_subs_epi8 ( ps1 , qs1 ) , hev ) ;
work_a = _mm_subs_epi8 ( qs0 , ps0 ) ;
filt = _mm_adds_epi8 ( filt , work_a ) ;
filt = _mm_adds_epi8 ( filt , work_a ) ;
filt = _mm_adds_epi8 ( filt , work_a ) ;
filt = _mm_and_si128 ( filt , mask ) ;
filter1 = _mm_adds_epi8 ( filt , t4 ) ;
filter2 = _mm_adds_epi8 ( filt , t3 ) ;
work_a = _mm_cmpgt_epi8 ( zero , filter1 ) ;
filter1 = _mm_srli_epi16 ( filter1 , 3 ) ;
work_a = _mm_and_si128 ( work_a , te0 ) ;
filter1 = _mm_and_si128 ( filter1 , t1f ) ;
filter1 = _mm_or_si128 ( filter1 , work_a ) ;
work_a = _mm_cmpgt_epi8 ( zero , filter2 ) ;
filter2 = _mm_srli_epi16 ( filter2 , 3 ) ;
work_a = _mm_and_si128 ( work_a , te0 ) ;
filter2 = _mm_and_si128 ( filter2 , t1f ) ;
filter2 = _mm_or_si128 ( filter2 , work_a ) ;
filt = _mm_adds_epi8 ( filter1 , t1 ) ;
work_a = _mm_cmpgt_epi8 ( zero , filt ) ;
filt = _mm_srli_epi16 ( filt , 1 ) ;
work_a = _mm_and_si128 ( work_a , t80 ) ;
filt = _mm_and_si128 ( filt , t7f ) ;
filt = _mm_or_si128 ( filt , work_a ) ;
filt = _mm_andnot_si128 ( hev , filt ) ;
q0 = _mm_xor_si128 ( _mm_subs_epi8 ( qs0 , filter1 ) , t80 ) ;
q1 = _mm_xor_si128 ( _mm_subs_epi8 ( qs1 , filt ) , t80 ) ;
p0 = _mm_xor_si128 ( _mm_adds_epi8 ( ps0 , filter2 ) , t80 ) ;
p1 = _mm_xor_si128 ( _mm_adds_epi8 ( ps1 , filt ) , t80 ) ;
_mm_storeu_si128 ( ( __m128i * ) ( s - 2 * p ) , p1 ) ;
_mm_storeu_si128 ( ( __m128i * ) ( s - 1 * p ) , p0 ) ;
_mm_storeu_si128 ( ( __m128i * ) ( s + 0 * p ) , q0 ) ;
_mm_storeu_si128 ( ( __m128i * ) ( s + 1 * p ) , q1 ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int archive_mstring_get_utf8 ( struct archive * a , struct archive_mstring * aes , const char * * p ) {
struct archive_string_conv * sc ;
int r ;
if ( aes -> aes_set & AES_SET_UTF8 ) {
* p = aes -> aes_utf8 . s ;
return ( 0 ) ;
}
* p = NULL ;
if ( aes -> aes_set & AES_SET_MBS ) {
sc = archive_string_conversion_to_charset ( a , "UTF-8" , 1 ) ;
if ( sc == NULL ) return ( - 1 ) ;
r = archive_strncpy_l ( & ( aes -> aes_utf8 ) , aes -> aes_mbs . s , aes -> aes_mbs . length , sc ) ;
if ( a == NULL ) free_sconv_object ( sc ) ;
if ( r == 0 ) {
aes -> aes_set |= AES_SET_UTF8 ;
* p = aes -> aes_utf8 . s ;
return ( 0 ) ;
}
else return ( - 1 ) ;
}
return ( 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dtls1_retransmit_message ( SSL * s , unsigned short seq , int * found ) {
int ret ;
pitem * item ;
hm_fragment * frag ;
unsigned long header_length ;
unsigned char seq64be [ 8 ] ;
struct dtls1_retransmit_state saved_state ;
memset ( seq64be , 0 , sizeof ( seq64be ) ) ;
seq64be [ 6 ] = ( unsigned char ) ( seq >> 8 ) ;
seq64be [ 7 ] = ( unsigned char ) seq ;
item = pqueue_find ( s -> d1 -> sent_messages , seq64be ) ;
if ( item == NULL ) {
SSLerr ( SSL_F_DTLS1_RETRANSMIT_MESSAGE , ERR_R_INTERNAL_ERROR ) ;
* found = 0 ;
return 0 ;
}
* found = 1 ;
frag = ( hm_fragment * ) item -> data ;
if ( frag -> msg_header . is_ccs ) header_length = DTLS1_CCS_HEADER_LENGTH ;
else header_length = DTLS1_HM_HEADER_LENGTH ;
memcpy ( s -> init_buf -> data , frag -> fragment , frag -> msg_header . msg_len + header_length ) ;
s -> init_num = frag -> msg_header . msg_len + header_length ;
dtls1_set_message_header_int ( s , frag -> msg_header . type , frag -> msg_header . msg_len , frag -> msg_header . seq , 0 , frag -> msg_header . frag_len ) ;
saved_state . enc_write_ctx = s -> enc_write_ctx ;
saved_state . write_hash = s -> write_hash ;
saved_state . compress = s -> compress ;
saved_state . session = s -> session ;
saved_state . epoch = DTLS_RECORD_LAYER_get_w_epoch ( & s -> rlayer ) ;
s -> d1 -> retransmitting = 1 ;
s -> enc_write_ctx = frag -> msg_header . saved_retransmit_state . enc_write_ctx ;
s -> write_hash = frag -> msg_header . saved_retransmit_state . write_hash ;
s -> compress = frag -> msg_header . saved_retransmit_state . compress ;
s -> session = frag -> msg_header . saved_retransmit_state . session ;
DTLS_RECORD_LAYER_set_saved_w_epoch ( & s -> rlayer , frag -> msg_header . saved_retransmit_state . epoch ) ;
ret = dtls1_do_write ( s , frag -> msg_header . is_ccs ? SSL3_RT_CHANGE_CIPHER_SPEC : SSL3_RT_HANDSHAKE ) ;
s -> enc_write_ctx = saved_state . enc_write_ctx ;
s -> write_hash = saved_state . write_hash ;
s -> compress = saved_state . compress ;
s -> session = saved_state . session ;
DTLS_RECORD_LAYER_set_saved_w_epoch ( & s -> rlayer , saved_state . epoch ) ;
s -> d1 -> retransmitting = 0 ;
( void ) BIO_flush ( s -> wbio ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Datum ExecEvalMinMax ( MinMaxExprState * minmaxExpr , ExprContext * econtext , bool * isNull , ExprDoneCond * isDone ) {
Datum result = ( Datum ) 0 ;
MinMaxExpr * minmax = ( MinMaxExpr * ) minmaxExpr -> xprstate . expr ;
Oid collation = minmax -> inputcollid ;
MinMaxOp op = minmax -> op ;
FunctionCallInfoData locfcinfo ;
ListCell * arg ;
if ( isDone ) * isDone = ExprSingleResult ;
* isNull = true ;
InitFunctionCallInfoData ( locfcinfo , & minmaxExpr -> cfunc , 2 , collation , NULL , NULL ) ;
locfcinfo . argnull [ 0 ] = false ;
locfcinfo . argnull [ 1 ] = false ;
foreach ( arg , minmaxExpr -> args ) {
ExprState * e = ( ExprState * ) lfirst ( arg ) ;
Datum value ;
bool valueIsNull ;
int32 cmpresult ;
value = ExecEvalExpr ( e , econtext , & valueIsNull , NULL ) ;
if ( valueIsNull ) continue ;
if ( * isNull ) {
result = value ;
* isNull = false ;
}
else {
locfcinfo . arg [ 0 ] = result ;
locfcinfo . arg [ 1 ] = value ;
locfcinfo . isnull = false ;
cmpresult = DatumGetInt32 ( FunctionCallInvoke ( & locfcinfo ) ) ;
if ( locfcinfo . isnull ) continue ;
if ( cmpresult > 0 && op == IS_LEAST ) result = value ;
else if ( cmpresult < 0 && op == IS_GREATEST ) result = value ;
}
}
return result ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
struct zip_cdir * _zip_cdir_new ( int nentry , struct zip_error * error ) {
struct zip_cdir * cd ;
if ( ( cd = ( struct zip_cdir * ) malloc ( sizeof ( * cd ) ) ) == NULL ) {
_zip_error_set ( error , ZIP_ER_MEMORY , 0 ) ;
return NULL ;
}
if ( nentry > ( ( size_t ) - 1 ) / sizeof ( * ( cd -> entry ) ) || ( cd -> entry = ( struct zip_dirent * ) malloc ( sizeof ( * ( cd -> entry ) ) * ( size_t ) nentry ) ) == NULL ) {
_zip_error_set ( error , ZIP_ER_MEMORY , 0 ) ;
free ( cd ) ;
return NULL ;
}
cd -> nentry = nentry ;
cd -> size = cd -> offset = 0 ;
cd -> comment = NULL ;
cd -> comment_len = 0 ;
return cd ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ImportCMYKOQuantum ( const Image * image , QuantumInfo * quantum_info , const MagickSizeType number_pixels , const unsigned char * magick_restrict p , Quantum * magick_restrict q , ExceptionInfo * exception ) {
QuantumAny range ;
register ssize_t x ;
unsigned int pixel ;
if ( image -> colorspace != CMYKColorspace ) {
( void ) ThrowMagickException ( exception , GetMagickModule ( ) , ImageError , "ColorSeparatedImageRequired" , "`%s'" , image -> filename ) ;
return ;
}
switch ( quantum_info -> depth ) {
case 8 : {
unsigned char pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushCharPixel ( p , & pixel ) ;
SetPixelRed ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p = PushCharPixel ( p , & pixel ) ;
SetPixelGreen ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p = PushCharPixel ( p , & pixel ) ;
SetPixelBlue ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p = PushCharPixel ( p , & pixel ) ;
SetPixelBlack ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p = PushCharPixel ( p , & pixel ) ;
SetPixelOpacity ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 16 : {
unsigned short pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGreen ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlue ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlack ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelOpacity ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGreen ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlue ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlack ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelOpacity ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 32 : {
unsigned int pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
float pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelBlack ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelOpacity ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGreen ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlue ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlack ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelOpacity ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 64 : {
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
double pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelBlack ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelOpacity ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
default : {
range = GetQuantumRange ( quantum_info -> depth ) ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelBlack ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelOpacity ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int xmlThrDefGetWarningsDefaultValue ( int v ) {
int ret ;
xmlMutexLock ( xmlThrDefMutex ) ;
ret = xmlGetWarningsDefaultValueThrDef ;
xmlGetWarningsDefaultValueThrDef = v ;
xmlMutexUnlock ( xmlThrDefMutex ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Datum ExecEvalScalarArrayOp ( ScalarArrayOpExprState * sstate , ExprContext * econtext , bool * isNull , ExprDoneCond * isDone ) {
ScalarArrayOpExpr * opexpr = ( ScalarArrayOpExpr * ) sstate -> fxprstate . xprstate . expr ;
bool useOr = opexpr -> useOr ;
ArrayType * arr ;
int nitems ;
Datum result ;
bool resultnull ;
FunctionCallInfo fcinfo ;
ExprDoneCond argDone ;
int i ;
int16 typlen ;
bool typbyval ;
char typalign ;
char * s ;
bits8 * bitmap ;
int bitmask ;
* isNull = false ;
if ( isDone ) * isDone = ExprSingleResult ;
if ( sstate -> fxprstate . func . fn_oid == InvalidOid ) {
init_fcache ( opexpr -> opfuncid , opexpr -> inputcollid , & sstate -> fxprstate , econtext -> ecxt_per_query_memory , true ) ;
Assert ( ! sstate -> fxprstate . func . fn_retset ) ;
}
fcinfo = & sstate -> fxprstate . fcinfo_data ;
argDone = ExecEvalFuncArgs ( fcinfo , sstate -> fxprstate . args , econtext ) ;
if ( argDone != ExprSingleResult ) ereport ( ERROR , ( errcode ( ERRCODE_DATATYPE_MISMATCH ) , errmsg ( "op ANY/ALL (array) does not support set arguments" ) ) ) ;
Assert ( fcinfo -> nargs == 2 ) ;
if ( fcinfo -> argnull [ 1 ] ) {
* isNull = true ;
return ( Datum ) 0 ;
}
arr = DatumGetArrayTypeP ( fcinfo -> arg [ 1 ] ) ;
nitems = ArrayGetNItems ( ARR_NDIM ( arr ) , ARR_DIMS ( arr ) ) ;
if ( nitems <= 0 ) return BoolGetDatum ( ! useOr ) ;
if ( fcinfo -> argnull [ 0 ] && sstate -> fxprstate . func . fn_strict ) {
* isNull = true ;
return ( Datum ) 0 ;
}
if ( sstate -> element_type != ARR_ELEMTYPE ( arr ) ) {
get_typlenbyvalalign ( ARR_ELEMTYPE ( arr ) , & sstate -> typlen , & sstate -> typbyval , & sstate -> typalign ) ;
sstate -> element_type = ARR_ELEMTYPE ( arr ) ;
}
typlen = sstate -> typlen ;
typbyval = sstate -> typbyval ;
typalign = sstate -> typalign ;
result = BoolGetDatum ( ! useOr ) ;
resultnull = false ;
s = ( char * ) ARR_DATA_PTR ( arr ) ;
bitmap = ARR_NULLBITMAP ( arr ) ;
bitmask = 1 ;
for ( i = 0 ;
i < nitems ;
i ++ ) {
Datum elt ;
Datum thisresult ;
if ( bitmap && ( * bitmap & bitmask ) == 0 ) {
fcinfo -> arg [ 1 ] = ( Datum ) 0 ;
fcinfo -> argnull [ 1 ] = true ;
}
else {
elt = fetch_att ( s , typbyval , typlen ) ;
s = att_addlength_pointer ( s , typlen , s ) ;
s = ( char * ) att_align_nominal ( s , typalign ) ;
fcinfo -> arg [ 1 ] = elt ;
fcinfo -> argnull [ 1 ] = false ;
}
if ( fcinfo -> argnull [ 1 ] && sstate -> fxprstate . func . fn_strict ) {
fcinfo -> isnull = true ;
thisresult = ( Datum ) 0 ;
}
else {
fcinfo -> isnull = false ;
thisresult = FunctionCallInvoke ( fcinfo ) ;
}
if ( fcinfo -> isnull ) resultnull = true ;
else if ( useOr ) {
if ( DatumGetBool ( thisresult ) ) {
result = BoolGetDatum ( true ) ;
resultnull = false ;
break ;
}
}
else {
if ( ! DatumGetBool ( thisresult ) ) {
result = BoolGetDatum ( false ) ;
resultnull = false ;
break ;
}
}
if ( bitmap ) {
bitmask <<= 1 ;
if ( bitmask == 0x100 ) {
bitmap ++ ;
bitmask = 1 ;
}
}
}
* isNull = resultnull ;
return result ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ps2_queue ( PS2State * s , int b ) {
PS2Queue * q = & s -> queue ;
if ( q -> count >= PS2_QUEUE_SIZE - 1 ) return ;
q -> data [ q -> wptr ] = b ;
if ( ++ q -> wptr == PS2_QUEUE_SIZE ) q -> wptr = 0 ;
q -> count ++ ;
s -> update_irq ( s -> update_arg , 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void rds_inc_addref ( struct rds_incoming * inc ) {
rdsdebug ( "addref inc %p ref %d\n" , inc , atomic_read ( & inc -> i_refcount ) ) ;
atomic_inc ( & inc -> i_refcount ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_INTEGER_1_32 ( 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 , 32U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
proto_item * proto_tree_add_ether_format ( proto_tree * tree , int hfindex , tvbuff_t * tvb , gint start , gint length , const guint8 * value , const char * format , ... ) {
proto_item * pi ;
va_list ap ;
pi = proto_tree_add_ether ( tree , hfindex , tvb , start , length , value ) ;
if ( pi != tree ) {
TRY_TO_FAKE_THIS_REPR ( pi ) ;
va_start ( ap , format ) ;
proto_tree_set_representation ( pi , format , ap ) ;
va_end ( ap ) ;
}
return pi ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
block_t * decoder_NewAudioBuffer ( decoder_t * dec , int samples ) {
if ( decoder_UpdateAudioFormat ( dec ) ) return NULL ;
size_t length = samples * dec -> fmt_out . audio . i_bytes_per_frame / dec -> fmt_out . audio . i_frame_length ;
block_t * block = block_Alloc ( length ) ;
if ( likely ( block != NULL ) ) {
block -> i_nb_samples = samples ;
block -> i_pts = block -> i_length = 0 ;
}
return block ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ts_lua_http_timeout_set ( lua_State * L ) {
int conf ;
int value ;
ts_lua_http_ctx * http_ctx ;
GET_HTTP_CONTEXT ( http_ctx , L ) ;
conf = luaL_checkinteger ( L , 1 ) ;
value = luaL_checkinteger ( L , 2 ) ;
switch ( conf ) {
case TS_LUA_TIMEOUT_ACTIVE : TSDebug ( TS_LUA_DEBUG_TAG , "setting active timeout" ) ;
TSHttpTxnActiveTimeoutSet ( http_ctx -> txnp , value ) ;
break ;
case TS_LUA_TIMEOUT_CONNECT : TSDebug ( TS_LUA_DEBUG_TAG , "setting connect timeout" ) ;
TSHttpTxnConnectTimeoutSet ( http_ctx -> txnp , value ) ;
break ;
case TS_LUA_TIMEOUT_DNS : TSDebug ( TS_LUA_DEBUG_TAG , "setting dns timeout" ) ;
TSHttpTxnDNSTimeoutSet ( http_ctx -> txnp , value ) ;
break ;
case TS_LUA_TIMEOUT_NO_ACTIVITY : TSDebug ( TS_LUA_DEBUG_TAG , "setting no activity timeout" ) ;
TSHttpTxnNoActivityTimeoutSet ( http_ctx -> txnp , value ) ;
break ;
default : TSError ( "[ts_lua] Unsupported timeout config option for lua plugin" ) ;
break ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorTextGetBlockStatsInfo ( qemuMonitorPtr mon , const char * dev_name , long long * rd_req , long long * rd_bytes , long long * rd_total_times , long long * wr_req , long long * wr_bytes , long long * wr_total_times , long long * flush_req , long long * flush_total_times , long long * errs ) {
char * info = NULL ;
int ret = - 1 ;
char * dummy ;
const char * p , * eol ;
int devnamelen = strlen ( dev_name ) ;
if ( qemuMonitorHMPCommand ( mon , "info blockstats" , & info ) < 0 ) {
qemuReportError ( VIR_ERR_OPERATION_FAILED , "%s" , _ ( "'info blockstats' command failed" ) ) ;
goto cleanup ;
}
if ( strstr ( info , "\ninfo " ) ) {
qemuReportError ( VIR_ERR_OPERATION_INVALID , "%s" , _ ( "'info blockstats' not supported by this qemu" ) ) ;
goto cleanup ;
}
* rd_req = * rd_bytes = - 1 ;
* wr_req = * wr_bytes = * errs = - 1 ;
if ( rd_total_times ) * rd_total_times = - 1 ;
if ( wr_total_times ) * wr_total_times = - 1 ;
if ( flush_req ) * flush_req = - 1 ;
if ( flush_total_times ) * flush_total_times = - 1 ;
p = info ;
while ( * p ) {
if ( STRPREFIX ( p , QEMU_DRIVE_HOST_PREFIX ) ) p += strlen ( QEMU_DRIVE_HOST_PREFIX ) ;
if ( STREQLEN ( p , dev_name , devnamelen ) && p [ devnamelen ] == ':' && p [ devnamelen + 1 ] == ' ' ) {
eol = strchr ( p , '\n' ) ;
if ( ! eol ) eol = p + strlen ( p ) ;
p += devnamelen + 2 ;
while ( * p ) {
if ( STRPREFIX ( p , "rd_bytes=" ) ) {
p += strlen ( "rd_bytes=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , rd_bytes ) == - 1 ) VIR_DEBUG ( "error reading rd_bytes: %s" , p ) ;
}
else if ( STRPREFIX ( p , "wr_bytes=" ) ) {
p += strlen ( "wr_bytes=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , wr_bytes ) == - 1 ) VIR_DEBUG ( "error reading wr_bytes: %s" , p ) ;
}
else if ( STRPREFIX ( p , "rd_operations=" ) ) {
p += strlen ( "rd_operations=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , rd_req ) == - 1 ) VIR_DEBUG ( "error reading rd_req: %s" , p ) ;
}
else if ( STRPREFIX ( p , "wr_operations=" ) ) {
p += strlen ( "wr_operations=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , wr_req ) == - 1 ) VIR_DEBUG ( "error reading wr_req: %s" , p ) ;
}
else if ( rd_total_times && STRPREFIX ( p , "rd_total_times_ns=" ) ) {
p += strlen ( "rd_total_times_ns=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , rd_total_times ) == - 1 ) VIR_DEBUG ( "error reading rd_total_times: %s" , p ) ;
}
else if ( wr_total_times && STRPREFIX ( p , "wr_total_times_ns=" ) ) {
p += strlen ( "wr_total_times_ns=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , wr_total_times ) == - 1 ) VIR_DEBUG ( "error reading wr_total_times: %s" , p ) ;
}
else if ( flush_req && STRPREFIX ( p , "flush_operations=" ) ) {
p += strlen ( "flush_operations=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , flush_req ) == - 1 ) VIR_DEBUG ( "error reading flush_req: %s" , p ) ;
}
else if ( flush_total_times && STRPREFIX ( p , "flush_total_times_ns=" ) ) {
p += strlen ( "flush_total_times_ns=" ) ;
if ( virStrToLong_ll ( p , & dummy , 10 , flush_total_times ) == - 1 ) VIR_DEBUG ( "error reading flush_total_times: %s" , p ) ;
}
else {
VIR_DEBUG ( "unknown block stat near %s" , p ) ;
}
p = strchr ( p , ' ' ) ;
if ( ! p || p >= eol ) break ;
p ++ ;
}
ret = 0 ;
goto cleanup ;
}
p = strchr ( p , '\n' ) ;
if ( ! p ) break ;
p ++ ;
}
qemuReportError ( VIR_ERR_INVALID_ARG , _ ( "no stats found for device %s" ) , dev_name ) ;
cleanup : VIR_FREE ( info ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void erase_screen ( AVCodecContext * avctx ) {
AnsiContext * s = avctx -> priv_data ;
int i ;
for ( i = 0 ;
i < avctx -> height ;
i ++ ) memset ( s -> frame -> data [ 0 ] + i * s -> frame -> linesize [ 0 ] , DEFAULT_BG_COLOR , avctx -> width ) ;
s -> x = s -> y = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void row_prop_delete ( zval * object , zval * offset , const zend_literal * key TSRMLS_DC ) {
php_error_docref ( NULL TSRMLS_CC , E_WARNING , "Cannot delete properties from a PDORow" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ff_mpeg4_decode_video_packet_header ( MpegEncContext * s ) {
int mb_num_bits = av_log2 ( s -> mb_num - 1 ) + 1 ;
int header_extension = 0 , mb_num , len ;
if ( get_bits_count ( & s -> gb ) > s -> gb . size_in_bits - 20 ) return - 1 ;
for ( len = 0 ;
len < 32 ;
len ++ ) {
if ( get_bits1 ( & s -> gb ) ) break ;
}
if ( len != ff_mpeg4_get_video_packet_prefix_length ( s ) ) {
av_log ( s -> avctx , AV_LOG_ERROR , "marker does not match f_code\n" ) ;
return - 1 ;
}
if ( s -> shape != RECT_SHAPE ) {
header_extension = get_bits1 ( & s -> gb ) ;
}
mb_num = get_bits ( & s -> gb , mb_num_bits ) ;
if ( mb_num >= s -> mb_num ) {
av_log ( s -> avctx , AV_LOG_ERROR , "illegal mb_num in video packet (%d %d) \n" , mb_num , s -> mb_num ) ;
return - 1 ;
}
if ( s -> pict_type == AV_PICTURE_TYPE_B ) {
int mb_x = 0 , mb_y = 0 ;
while ( s -> next_picture . mbskip_table [ s -> mb_index2xy [ mb_num ] ] ) {
if ( ! mb_x ) ff_thread_await_progress ( & s -> next_picture_ptr -> tf , mb_y ++ , 0 ) ;
mb_num ++ ;
if ( ++ mb_x == s -> mb_width ) mb_x = 0 ;
}
if ( mb_num >= s -> mb_num ) return - 1 ;
}
s -> mb_x = mb_num % s -> mb_width ;
s -> mb_y = mb_num / s -> mb_width ;
if ( s -> shape != BIN_ONLY_SHAPE ) {
int qscale = get_bits ( & s -> gb , s -> quant_precision ) ;
if ( qscale ) s -> chroma_qscale = s -> qscale = qscale ;
}
if ( s -> shape == RECT_SHAPE ) {
header_extension = get_bits1 ( & s -> gb ) ;
}
if ( header_extension ) {
int time_incr = 0 ;
while ( get_bits1 ( & s -> gb ) != 0 ) time_incr ++ ;
check_marker ( & s -> gb , "before time_increment in video packed header" ) ;
skip_bits ( & s -> gb , s -> time_increment_bits ) ;
check_marker ( & s -> gb , "before vop_coding_type in video packed header" ) ;
skip_bits ( & s -> gb , 2 ) ;
if ( s -> shape != BIN_ONLY_SHAPE ) {
skip_bits ( & s -> gb , 3 ) ;
if ( s -> pict_type == AV_PICTURE_TYPE_S && s -> vol_sprite_usage == GMC_SPRITE ) {
mpeg4_decode_sprite_trajectory ( s , & s -> gb ) ;
av_log ( s -> avctx , AV_LOG_ERROR , "untested\n" ) ;
}
if ( s -> pict_type != AV_PICTURE_TYPE_I ) {
int f_code = get_bits ( & s -> gb , 3 ) ;
if ( f_code == 0 ) {
av_log ( s -> avctx , AV_LOG_ERROR , "Error, video packet header damaged (f_code=0)\n" ) ;
}
}
if ( s -> pict_type == AV_PICTURE_TYPE_B ) {
int b_code = get_bits ( & s -> gb , 3 ) ;
if ( b_code == 0 ) {
av_log ( s -> avctx , AV_LOG_ERROR , "Error, video packet header damaged (b_code=0)\n" ) ;
}
}
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static zend_object_value spl_filesystem_object_clone ( zval * zobject TSRMLS_DC ) {
zend_object_value new_obj_val ;
zend_object * old_object ;
zend_object * new_object ;
zend_object_handle handle = Z_OBJ_HANDLE_P ( zobject ) ;
spl_filesystem_object * intern ;
spl_filesystem_object * source ;
int index , skip_dots ;
old_object = zend_objects_get_address ( zobject TSRMLS_CC ) ;
source = ( spl_filesystem_object * ) old_object ;
new_obj_val = spl_filesystem_object_new_ex ( old_object -> ce , & intern TSRMLS_CC ) ;
new_object = & intern -> std ;
intern -> flags = source -> flags ;
switch ( source -> type ) {
case SPL_FS_INFO : intern -> _path_len = source -> _path_len ;
intern -> _path = estrndup ( source -> _path , source -> _path_len ) ;
intern -> file_name_len = source -> file_name_len ;
intern -> file_name = estrndup ( source -> file_name , intern -> file_name_len ) ;
break ;
case SPL_FS_DIR : spl_filesystem_dir_open ( intern , source -> _path TSRMLS_CC ) ;
skip_dots = SPL_HAS_FLAG ( source -> flags , SPL_FILE_DIR_SKIPDOTS ) ;
for ( index = 0 ;
index < source -> u . dir . index ;
++ index ) {
do {
spl_filesystem_dir_read ( intern TSRMLS_CC ) ;
}
while ( skip_dots && spl_filesystem_is_dot ( intern -> u . dir . entry . d_name ) ) ;
}
intern -> u . dir . index = index ;
break ;
case SPL_FS_FILE : php_error_docref ( NULL TSRMLS_CC , E_ERROR , "An object of class %s cannot be cloned" , old_object -> ce -> name ) ;
break ;
}
intern -> file_class = source -> file_class ;
intern -> info_class = source -> info_class ;
intern -> oth = source -> oth ;
intern -> oth_handler = source -> oth_handler ;
zend_objects_clone_members ( new_object , new_obj_val , old_object , handle TSRMLS_CC ) ;
if ( intern -> oth_handler && intern -> oth_handler -> clone ) {
intern -> oth_handler -> clone ( source , intern TSRMLS_CC ) ;
}
return new_obj_val ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static TranslationBlock * tb_find_slow ( CPUArchState * env , target_ulong pc , target_ulong cs_base , uint64_t flags ) {
TranslationBlock * tb , * * ptb1 ;
unsigned int h ;
tb_page_addr_t phys_pc , phys_page1 ;
target_ulong virt_page2 ;
tcg_ctx . tb_ctx . tb_invalidated_flag = 0 ;
phys_pc = get_page_addr_code ( env , pc ) ;
phys_page1 = phys_pc & TARGET_PAGE_MASK ;
h = tb_phys_hash_func ( phys_pc ) ;
ptb1 = & tcg_ctx . tb_ctx . tb_phys_hash [ h ] ;
for ( ;
;
) {
tb = * ptb1 ;
if ( ! tb ) goto not_found ;
if ( tb -> pc == pc && tb -> page_addr [ 0 ] == phys_page1 && tb -> cs_base == cs_base && tb -> flags == flags ) {
if ( tb -> page_addr [ 1 ] != - 1 ) {
tb_page_addr_t phys_page2 ;
virt_page2 = ( pc & TARGET_PAGE_MASK ) + TARGET_PAGE_SIZE ;
phys_page2 = get_page_addr_code ( env , virt_page2 ) ;
if ( tb -> page_addr [ 1 ] == phys_page2 ) goto found ;
}
else {
goto found ;
}
}
ptb1 = & tb -> phys_hash_next ;
}
not_found : tb = tb_gen_code ( env , pc , cs_base , flags , 0 ) ;
found : if ( likely ( * ptb1 ) ) {
* ptb1 = tb -> phys_hash_next ;
tb -> phys_hash_next = tcg_ctx . tb_ctx . tb_phys_hash [ h ] ;
tcg_ctx . tb_ctx . tb_phys_hash [ h ] = tb ;
}
env -> tb_jmp_cache [ tb_jmp_cache_hash_func ( pc ) ] = tb ;
return tb ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int pefromupx ( const char * src , uint32_t ssize , char * dst , uint32_t * dsize , uint32_t ep , uint32_t upx0 , uint32_t upx1 , uint32_t * magic , uint32_t dend ) {
char * imports , * sections = NULL , * pehdr = NULL , * newbuf ;
unsigned int sectcnt = 0 , upd = 1 ;
uint32_t realstuffsz = 0 , valign = 0 ;
uint32_t foffset = 0xd0 + 0xf8 ;
if ( ( dst == NULL ) || ( src == NULL ) ) return 0 ;
while ( ( valign = magic [ sectcnt ++ ] ) ) {
if ( ep - upx1 + valign <= ssize - 5 && src [ ep - upx1 + valign - 2 ] == '\x8d' && src [ ep - upx1 + valign - 1 ] == '\xbe' ) break ;
}
if ( ! valign && ep - upx1 + 0x80 < ssize - 8 ) {
const char * pt = & src [ ep - upx1 + 0x80 ] ;
cli_dbgmsg ( "UPX: bad magic - scanning for imports\n" ) ;
while ( ( pt = cli_memstr ( pt , ssize - ( pt - src ) - 8 , "\x8d\xbe" , 2 ) ) ) {
if ( pt [ 6 ] == '\x8b' && pt [ 7 ] == '\x07' ) {
valign = pt - src + 2 - ep + upx1 ;
break ;
}
pt ++ ;
}
}
if ( valign && CLI_ISCONTAINED ( src , ssize , src + ep - upx1 + valign , 4 ) ) {
imports = dst + cli_readint32 ( src + ep - upx1 + valign ) ;
realstuffsz = imports - dst ;
if ( realstuffsz >= * dsize ) {
cli_dbgmsg ( "UPX: wrong realstuff size\n" ) ;
}
else {
pehdr = imports ;
while ( CLI_ISCONTAINED ( dst , * dsize , pehdr , 8 ) && cli_readint32 ( pehdr ) ) {
pehdr += 8 ;
while ( CLI_ISCONTAINED ( dst , * dsize , pehdr , 2 ) && * pehdr ) {
pehdr ++ ;
while ( CLI_ISCONTAINED ( dst , * dsize , pehdr , 2 ) && * pehdr ) pehdr ++ ;
pehdr ++ ;
}
pehdr ++ ;
}
pehdr += 4 ;
if ( ! ( sections = checkpe ( dst , * dsize , pehdr , & valign , & sectcnt ) ) ) pehdr = NULL ;
}
}
if ( ! pehdr && dend > 0xf8 + 0x28 ) {
cli_dbgmsg ( "UPX: no luck - scanning for PE\n" ) ;
pehdr = & dst [ dend - 0xf8 - 0x28 ] ;
while ( pehdr > dst ) {
if ( ( sections = checkpe ( dst , * dsize , pehdr , & valign , & sectcnt ) ) ) break ;
pehdr -- ;
}
if ( ! ( realstuffsz = pehdr - dst ) ) pehdr = NULL ;
}
if ( ! pehdr ) {
uint32_t rebsz = PESALIGN ( dend , 0x1000 ) ;
cli_dbgmsg ( "UPX: no luck - brutally crafing a reasonable PE\n" ) ;
if ( ! ( newbuf = ( char * ) cli_calloc ( rebsz + 0x200 , sizeof ( char ) ) ) ) {
cli_dbgmsg ( "UPX: malloc failed - giving up rebuild\n" ) ;
return 0 ;
}
memcpy ( newbuf , HEADERS , 0xd0 ) ;
memcpy ( newbuf + 0xd0 , FAKEPE , 0x120 ) ;
memcpy ( newbuf + 0x200 , dst , dend ) ;
memcpy ( dst , newbuf , dend + 0x200 ) ;
free ( newbuf ) ;
cli_writeint32 ( dst + 0xd0 + 0x50 , rebsz + 0x1000 ) ;
cli_writeint32 ( dst + 0xd0 + 0x100 , rebsz ) ;
cli_writeint32 ( dst + 0xd0 + 0x108 , rebsz ) ;
* dsize = rebsz + 0x200 ;
cli_dbgmsg ( "UPX: PE structure added to uncompressed data\n" ) ;
return 1 ;
}
if ( ! sections ) sectcnt = 0 ;
foffset = PESALIGN ( foffset + 0x28 * sectcnt , valign ) ;
for ( upd = 0 ;
upd < sectcnt ;
upd ++ ) {
uint32_t vsize = PESALIGN ( ( uint32_t ) cli_readint32 ( sections + 8 ) , valign ) ;
uint32_t urva = PEALIGN ( ( uint32_t ) cli_readint32 ( sections + 12 ) , valign ) ;
if ( ! CLI_ISCONTAINED ( upx0 , realstuffsz , urva , vsize ) ) {
cli_dbgmsg ( "UPX: Sect %d out of bounds - giving up rebuild\n" , upd ) ;
return 0 ;
}
cli_writeint32 ( sections + 8 , vsize ) ;
cli_writeint32 ( sections + 12 , urva ) ;
cli_writeint32 ( sections + 16 , vsize ) ;
cli_writeint32 ( sections + 20 , foffset ) ;
if ( foffset + vsize < foffset ) {
return 0 ;
}
foffset += vsize ;
sections += 0x28 ;
}
cli_writeint32 ( pehdr + 8 , 0x4d414c43 ) ;
cli_writeint32 ( pehdr + 0x3c , valign ) ;
if ( ! ( newbuf = ( char * ) cli_calloc ( foffset , sizeof ( char ) ) ) ) {
cli_dbgmsg ( "UPX: malloc failed - giving up rebuild\n" ) ;
return 0 ;
}
memcpy ( newbuf , HEADERS , 0xd0 ) ;
memcpy ( newbuf + 0xd0 , pehdr , 0xf8 + 0x28 * sectcnt ) ;
sections = pehdr + 0xf8 ;
for ( upd = 0 ;
upd < sectcnt ;
upd ++ ) {
uint32_t offset1 , offset2 , offset3 ;
offset1 = ( uint32_t ) cli_readint32 ( sections + 20 ) ;
offset2 = ( uint32_t ) cli_readint32 ( sections + 16 ) ;
if ( offset1 > foffset || offset2 > foffset || offset1 + offset2 > foffset ) {
free ( newbuf ) ;
return 1 ;
}
offset3 = ( uint32_t ) cli_readint32 ( sections + 12 ) ;
if ( offset3 - upx0 > * dsize ) {
free ( newbuf ) ;
return 1 ;
}
memcpy ( newbuf + offset1 , dst + offset3 - upx0 , offset2 ) ;
sections += 0x28 ;
}
if ( foffset > * dsize + 8192 ) {
cli_dbgmsg ( "UPX: wrong raw size - giving up rebuild\n" ) ;
free ( newbuf ) ;
return 0 ;
}
memcpy ( dst , newbuf , foffset ) ;
* dsize = foffset ;
free ( newbuf ) ;
cli_dbgmsg ( "UPX: PE structure rebuilt from compressed file\n" ) ;
return 1 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void get_current_db ( ) {
MYSQL_RES * res ;
if ( one_database ) return ;
my_free ( current_db ) ;
current_db = NULL ;
if ( ! mysql_query ( & mysql , "SELECT DATABASE()" ) && ( res = mysql_use_result ( & mysql ) ) ) {
MYSQL_ROW row = mysql_fetch_row ( res ) ;
if ( row && row [ 0 ] ) current_db = my_strdup ( row [ 0 ] , MYF ( MY_WME ) ) ;
mysql_free_result ( res ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void sig_erase_complete_msg ( WINDOW_REC * window , const char * word , const char * line ) {
SERVER_REC * server ;
MODULE_SERVER_REC * mserver ;
GSList * tmp ;
server = line_get_server ( line ) ;
if ( server == NULL ) {
server = window -> active_server ;
if ( server == NULL ) return ;
}
if ( * word == '\0' ) return ;
completion_last_message_remove ( word ) ;
if ( server != NULL ) {
mserver = MODULE_DATA ( server ) ;
for ( tmp = mserver -> lastmsgs ;
tmp != NULL ;
tmp = tmp -> next ) {
LAST_MSG_REC * rec = tmp -> data ;
if ( g_ascii_strcasecmp ( rec -> nick , word ) == 0 ) {
last_msg_destroy ( & mserver -> lastmsgs , rec ) ;
break ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int send_xmessage_using_XAUTHORITY ( struct proclistlist * pll , int lokke , char * message ) {
if ( lokke == pll -> length ) return 0 ;
{
char * xa_filename = get_pid_environ_val ( pll -> proclist [ lokke ] . pid , "XAUTHORITY" ) ;
if ( xa_filename != NULL ) {
if ( send_xmessage ( xa_filename , message ) == 1 ) {
free ( xa_filename ) ;
return 1 ;
}
}
free ( xa_filename ) ;
}
return send_xmessage_using_XAUTHORITY ( pll , lokke + 1 , message ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int16 get_typlen ( Oid typid ) {
HeapTuple tp ;
tp = SearchSysCache1 ( TYPEOID , ObjectIdGetDatum ( typid ) ) ;
if ( HeapTupleIsValid ( tp ) ) {
Form_pg_type typtup = ( Form_pg_type ) GETSTRUCT ( tp ) ;
int16 result ;
result = typtup -> typlen ;
ReleaseSysCache ( tp ) ;
return result ;
}
else return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static unsigned long xmlHashComputeQKey ( xmlHashTablePtr table , const xmlChar * prefix , const xmlChar * name , const xmlChar * prefix2 , const xmlChar * name2 , const xmlChar * prefix3 , const xmlChar * name3 ) {
unsigned long value = 0L ;
char ch ;
if ( prefix != NULL ) value += 30 * ( * prefix ) ;
else value += 30 * ( * name ) ;
if ( prefix != NULL ) {
while ( ( ch = * prefix ++ ) != 0 ) {
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ch ) ;
}
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ':' ) ;
}
if ( name != NULL ) {
while ( ( ch = * name ++ ) != 0 ) {
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ch ) ;
}
}
if ( prefix2 != NULL ) {
while ( ( ch = * prefix2 ++ ) != 0 ) {
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ch ) ;
}
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ':' ) ;
}
if ( name2 != NULL ) {
while ( ( ch = * name2 ++ ) != 0 ) {
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ch ) ;
}
}
if ( prefix3 != NULL ) {
while ( ( ch = * prefix3 ++ ) != 0 ) {
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ch ) ;
}
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ':' ) ;
}
if ( name3 != NULL ) {
while ( ( ch = * name3 ++ ) != 0 ) {
value = value ^ ( ( value << 5 ) + ( value >> 3 ) + ( unsigned long ) ch ) ;
}
}
return ( value % table -> size ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void h245_setup_channels ( packet_info * pinfo , channel_info_t * upcoming_channel_lcl ) {
gint * key ;
GHashTable * rtp_dyn_payload = NULL ;
struct srtp_info * dummy_srtp_info = NULL ;
if ( ! upcoming_channel_lcl ) return ;
if ( ! strcmp ( upcoming_channel_lcl -> data_type_str , "t38fax" ) ) {
if ( upcoming_channel_lcl -> media_addr . addr . type != AT_NONE && upcoming_channel_lcl -> media_addr . port != 0 ) {
t38_add_address ( pinfo , & upcoming_channel_lcl -> media_addr . addr , upcoming_channel_lcl -> media_addr . port , 0 , "H245" , pinfo -> fd -> num ) ;
}
return ;
}
if ( upcoming_channel_lcl -> rfc2198 > 0 ) {
encoding_name_and_rate_t * encoding_name_and_rate = wmem_new ( wmem_file_scope ( ) , encoding_name_and_rate_t ) ;
rtp_dyn_payload = g_hash_table_new ( g_int_hash , g_int_equal ) ;
encoding_name_and_rate -> encoding_name = wmem_strdup ( wmem_file_scope ( ) , "red" ) ;
encoding_name_and_rate -> sample_rate = 8000 ;
key = wmem_new ( wmem_file_scope ( ) , gint ) ;
* key = upcoming_channel_lcl -> rfc2198 ;
g_hash_table_insert ( rtp_dyn_payload , key , encoding_name_and_rate ) ;
}
if ( upcoming_channel_lcl -> srtp_flag ) {
dummy_srtp_info = wmem_new0 ( wmem_file_scope ( ) , struct srtp_info ) ;
}
if ( upcoming_channel_lcl -> media_addr . addr . type != AT_NONE && upcoming_channel_lcl -> media_addr . port != 0 ) {
srtp_add_address ( pinfo , & upcoming_channel_lcl -> media_addr . addr , upcoming_channel_lcl -> media_addr . port , 0 , "H245" , pinfo -> fd -> num , upcoming_channel_lcl -> is_video , rtp_dyn_payload , dummy_srtp_info ) ;
}
if ( upcoming_channel_lcl -> media_control_addr . addr . type != AT_NONE && upcoming_channel_lcl -> media_control_addr . port != 0 && rtcp_handle ) {
srtcp_add_address ( pinfo , & upcoming_channel_lcl -> media_control_addr . addr , upcoming_channel_lcl -> media_control_addr . port , 0 , "H245" , pinfo -> fd -> num , dummy_srtp_info ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * get_value ( PyObject * self , const char * buffer , int * position , int type , int max , PyObject * as_class , unsigned char tz_aware , unsigned char uuid_subtype ) {
struct module_state * state = GETSTATE ( self ) ;
PyObject * value ;
PyObject * error ;
switch ( type ) {
case 1 : {
double d ;
if ( max < 8 ) {
goto invalid ;
}
memcpy ( & d , buffer + * position , 8 ) ;
value = PyFloat_FromDouble ( d ) ;
if ( ! value ) {
return NULL ;
}
* position += 8 ;
break ;
}
case 2 : case 14 : {
int value_length = ( ( int * ) ( buffer + * position ) ) [ 0 ] - 1 ;
if ( max < value_length ) {
goto invalid ;
}
* position += 4 ;
value = PyUnicode_DecodeUTF8 ( buffer + * position , value_length , "strict" ) ;
if ( ! value ) {
return NULL ;
}
* position += value_length + 1 ;
break ;
}
case 3 : {
int size ;
memcpy ( & size , buffer + * position , 4 ) ;
if ( max < size ) {
goto invalid ;
}
value = elements_to_dict ( self , buffer + * position + 4 , size - 5 , as_class , tz_aware , uuid_subtype ) ;
if ( ! value ) {
return NULL ;
}
if ( strcmp ( buffer + * position + 5 , "$ref" ) == 0 ) {
PyObject * dbref ;
PyObject * collection = PyDict_GetItemString ( value , "$ref" ) ;
PyObject * id = PyDict_GetItemString ( value , "$id" ) ;
PyObject * database = PyDict_GetItemString ( value , "$db" ) ;
Py_INCREF ( collection ) ;
PyDict_DelItemString ( value , "$ref" ) ;
Py_INCREF ( id ) ;
PyDict_DelItemString ( value , "$id" ) ;
if ( database == NULL ) {
database = Py_None ;
Py_INCREF ( database ) ;
}
else {
Py_INCREF ( database ) ;
PyDict_DelItemString ( value , "$db" ) ;
}
dbref = PyObject_CallFunctionObjArgs ( state -> DBRef , collection , id , database , value , NULL ) ;
Py_DECREF ( value ) ;
value = dbref ;
Py_DECREF ( id ) ;
Py_DECREF ( collection ) ;
Py_DECREF ( database ) ;
if ( ! value ) {
return NULL ;
}
}
* position += size ;
break ;
}
case 4 : {
int size , end ;
memcpy ( & size , buffer + * position , 4 ) ;
if ( max < size ) {
goto invalid ;
}
end = * position + size - 1 ;
* position += 4 ;
value = PyList_New ( 0 ) ;
if ( ! value ) {
return NULL ;
}
while ( * position < end ) {
PyObject * to_append ;
int type = ( int ) buffer [ ( * position ) ++ ] ;
int key_size = strlen ( buffer + * position ) ;
* position += key_size + 1 ;
to_append = get_value ( self , buffer , position , type , max - key_size , as_class , tz_aware , uuid_subtype ) ;
if ( ! to_append ) {
Py_DECREF ( value ) ;
return NULL ;
}
PyList_Append ( value , to_append ) ;
Py_DECREF ( to_append ) ;
}
( * position ) ++ ;
break ;
}
case 5 : {
PyObject * data ;
PyObject * st ;
int length , subtype ;
memcpy ( & length , buffer + * position , 4 ) ;
if ( max < length ) {
goto invalid ;
}
subtype = ( unsigned char ) buffer [ * position + 4 ] ;
# if PY_MAJOR_VERSION >= 3 if ( subtype == 0 ) {
value = PyBytes_FromStringAndSize ( buffer + * position + 5 , length ) ;
* position += length + 5 ;
break ;
}
if ( subtype == 2 ) {
data = PyBytes_FromStringAndSize ( buffer + * position + 9 , length - 4 ) ;
}
else {
data = PyBytes_FromStringAndSize ( buffer + * position + 5 , length ) ;
}
# else if ( subtype == 2 ) {
data = PyString_FromStringAndSize ( buffer + * position + 9 , length - 4 ) ;
}
else {
data = PyString_FromStringAndSize ( buffer + * position + 5 , length ) ;
}
# endif if ( ! data ) {
return NULL ;
}
if ( ( subtype == 3 || subtype == 4 ) && state -> UUID ) {
PyObject * kwargs ;
PyObject * args = PyTuple_New ( 0 ) ;
if ( ! args ) {
Py_DECREF ( data ) ;
return NULL ;
}
kwargs = PyDict_New ( ) ;
if ( ! kwargs ) {
Py_DECREF ( data ) ;
Py_DECREF ( args ) ;
return NULL ;
}
assert ( length == 16 ) ;
if ( uuid_subtype == CSHARP_LEGACY ) {
PyDict_SetItemString ( kwargs , "bytes_le" , data ) ;
}
else {
if ( uuid_subtype == JAVA_LEGACY ) {
char big_endian [ 16 ] ;
_fix_java ( buffer + * position + 5 , big_endian ) ;
Py_DECREF ( data ) ;
# if PY_MAJOR_VERSION >= 3 data = PyBytes_FromStringAndSize ( big_endian , length ) ;
# else data = PyString_FromStringAndSize ( big_endian , length ) ;
# endif }
PyDict_SetItemString ( kwargs , "bytes" , data ) ;
}
value = PyObject_Call ( state -> UUID , args , kwargs ) ;
Py_DECREF ( args ) ;
Py_DECREF ( kwargs ) ;
Py_DECREF ( data ) ;
if ( ! value ) {
return NULL ;
}
* position += length + 5 ;
break ;
}
# if PY_MAJOR_VERSION >= 3 st = PyLong_FromLong ( subtype ) ;
# else st = PyInt_FromLong ( subtype ) ;
# endif if ( ! st ) {
Py_DECREF ( data ) ;
return NULL ;
}
value = PyObject_CallFunctionObjArgs ( state -> Binary , data , st , NULL ) ;
Py_DECREF ( st ) ;
Py_DECREF ( data ) ;
if ( ! value ) {
return NULL ;
}
* position += length + 5 ;
break ;
}
case 6 : case 10 : {
value = Py_None ;
Py_INCREF ( value ) ;
break ;
}
case 7 : {
if ( max < 12 ) {
goto invalid ;
}
# if PY_MAJOR_VERSION >= 3 value = PyObject_CallFunction ( state -> ObjectId , "y#" , buffer + * position , 12 ) ;
# else value = PyObject_CallFunction ( state -> ObjectId , "s#" , buffer + * position , 12 ) ;
# endif if ( ! value ) {
return NULL ;
}
* position += 12 ;
break ;
}
case 8 : {
value = buffer [ ( * position ) ++ ] ? Py_True : Py_False ;
Py_INCREF ( value ) ;
break ;
}
case 9 : {
PyObject * naive ;
PyObject * replace ;
PyObject * args ;
PyObject * kwargs ;
if ( max < 8 ) {
goto invalid ;
}
naive = datetime_from_millis ( * ( long long * ) ( buffer + * position ) ) ;
* position += 8 ;
if ( ! tz_aware ) {
value = naive ;
break ;
}
if ( ! naive ) {
return NULL ;
}
replace = PyObject_GetAttrString ( naive , "replace" ) ;
Py_DECREF ( naive ) ;
if ( ! replace ) {
return NULL ;
}
args = PyTuple_New ( 0 ) ;
if ( ! args ) {
Py_DECREF ( replace ) ;
return NULL ;
}
kwargs = PyDict_New ( ) ;
if ( ! kwargs ) {
Py_DECREF ( replace ) ;
Py_DECREF ( args ) ;
return NULL ;
}
if ( PyDict_SetItemString ( kwargs , "tzinfo" , state -> UTC ) == - 1 ) {
Py_DECREF ( replace ) ;
Py_DECREF ( args ) ;
Py_DECREF ( kwargs ) ;
return NULL ;
}
value = PyObject_Call ( replace , args , kwargs ) ;
Py_DECREF ( replace ) ;
Py_DECREF ( args ) ;
Py_DECREF ( kwargs ) ;
break ;
}
case 11 : {
PyObject * pattern ;
int flags_length , flags , i ;
int pattern_length = strlen ( buffer + * position ) ;
if ( max < pattern_length ) {
goto invalid ;
}
pattern = PyUnicode_DecodeUTF8 ( buffer + * position , pattern_length , "strict" ) ;
if ( ! pattern ) {
return NULL ;
}
* position += pattern_length + 1 ;
flags_length = strlen ( buffer + * position ) ;
if ( max < pattern_length + flags_length ) {
Py_DECREF ( pattern ) ;
goto invalid ;
}
flags = 0 ;
for ( i = 0 ;
i < flags_length ;
i ++ ) {
if ( buffer [ * position + i ] == 'i' ) {
flags |= 2 ;
}
else if ( buffer [ * position + i ] == 'l' ) {
flags |= 4 ;
}
else if ( buffer [ * position + i ] == 'm' ) {
flags |= 8 ;
}
else if ( buffer [ * position + i ] == 's' ) {
flags |= 16 ;
}
else if ( buffer [ * position + i ] == 'u' ) {
flags |= 32 ;
}
else if ( buffer [ * position + i ] == 'x' ) {
flags |= 64 ;
}
}
* position += flags_length + 1 ;
value = PyObject_CallFunction ( state -> RECompile , "Oi" , pattern , flags ) ;
Py_DECREF ( pattern ) ;
break ;
}
case 12 : {
int collection_length ;
PyObject * collection ;
PyObject * id ;
* position += 4 ;
collection_length = strlen ( buffer + * position ) ;
if ( max < collection_length ) {
goto invalid ;
}
collection = PyUnicode_DecodeUTF8 ( buffer + * position , collection_length , "strict" ) ;
if ( ! collection ) {
return NULL ;
}
* position += collection_length + 1 ;
if ( max < collection_length + 12 ) {
Py_DECREF ( collection ) ;
goto invalid ;
}
id = PyObject_CallFunction ( state -> ObjectId , "s#" , buffer + * position , 12 ) ;
if ( ! id ) {
Py_DECREF ( collection ) ;
return NULL ;
}
* position += 12 ;
value = PyObject_CallFunctionObjArgs ( state -> DBRef , collection , id , NULL ) ;
Py_DECREF ( collection ) ;
Py_DECREF ( id ) ;
break ;
}
case 13 : {
PyObject * code ;
int value_length = ( ( int * ) ( buffer + * position ) ) [ 0 ] - 1 ;
if ( max < value_length ) {
goto invalid ;
}
* position += 4 ;
code = PyUnicode_DecodeUTF8 ( buffer + * position , value_length , "strict" ) ;
if ( ! code ) {
return NULL ;
}
* position += value_length + 1 ;
value = PyObject_CallFunctionObjArgs ( state -> Code , code , NULL , NULL ) ;
Py_DECREF ( code ) ;
break ;
}
case 15 : {
int code_length , scope_size ;
PyObject * code ;
PyObject * scope ;
* position += 8 ;
code_length = strlen ( buffer + * position ) ;
if ( max < 8 + code_length ) {
goto invalid ;
}
code = PyUnicode_DecodeUTF8 ( buffer + * position , code_length , "strict" ) ;
if ( ! code ) {
return NULL ;
}
* position += code_length + 1 ;
memcpy ( & scope_size , buffer + * position , 4 ) ;
scope = elements_to_dict ( self , buffer + * position + 4 , scope_size - 5 , ( PyObject * ) & PyDict_Type , tz_aware , uuid_subtype ) ;
if ( ! scope ) {
Py_DECREF ( code ) ;
return NULL ;
}
* position += scope_size ;
value = PyObject_CallFunctionObjArgs ( state -> Code , code , scope , NULL ) ;
Py_DECREF ( code ) ;
Py_DECREF ( scope ) ;
break ;
}
case 16 : {
int i ;
if ( max < 4 ) {
goto invalid ;
}
memcpy ( & i , buffer + * position , 4 ) ;
# if PY_MAJOR_VERSION >= 3 value = PyLong_FromLong ( i ) ;
# else value = PyInt_FromLong ( i ) ;
# endif if ( ! value ) {
return NULL ;
}
* position += 4 ;
break ;
}
case 17 : {
unsigned int time , inc ;
if ( max < 8 ) {
goto invalid ;
}
memcpy ( & inc , buffer + * position , 4 ) ;
memcpy ( & time , buffer + * position + 4 , 4 ) ;
value = PyObject_CallFunction ( state -> Timestamp , "II" , time , inc ) ;
if ( ! value ) {
return NULL ;
}
* position += 8 ;
break ;
}
case 18 : {
long long ll ;
if ( max < 8 ) {
goto invalid ;
}
memcpy ( & ll , buffer + * position , 8 ) ;
value = PyLong_FromLongLong ( ll ) ;
if ( ! value ) {
return NULL ;
}
* position += 8 ;
break ;
}
case - 1 : {
value = PyObject_CallFunctionObjArgs ( state -> MinKey , NULL ) ;
break ;
}
case 127 : {
value = PyObject_CallFunctionObjArgs ( state -> MaxKey , NULL ) ;
break ;
}
default : {
PyObject * InvalidDocument = _error ( "InvalidDocument" ) ;
PyErr_SetString ( InvalidDocument , "no c decoder for this type yet" ) ;
Py_DECREF ( InvalidDocument ) ;
return NULL ;
}
}
return value ;
invalid : error = _error ( "InvalidBSON" ) ;
PyErr_SetNone ( error ) ;
Py_DECREF ( error ) ;
return NULL ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int kvm_put_one_msr ( X86CPU * cpu , int index , uint64_t value ) {
kvm_msr_buf_reset ( cpu ) ;
kvm_msr_entry_add ( cpu , index , value ) ;
return kvm_vcpu_ioctl ( CPU ( cpu ) , KVM_SET_MSRS , cpu -> kvm_msr_buf ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ieee80211_radiotap_iterator_next ( struct ieee80211_radiotap_iterator * iterator ) {
while ( 1 ) {
int hit = 0 ;
int pad , align , size , subns ;
guint32 oui ;
if ( ( iterator -> _arg_index % 32 ) == IEEE80211_RADIOTAP_EXT && ! ( iterator -> _bitmap_shifter & 1 ) ) return - ENOENT ;
if ( ! ( iterator -> _bitmap_shifter & 1 ) ) goto next_entry ;
switch ( iterator -> _arg_index % 32 ) {
case IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE : case IEEE80211_RADIOTAP_EXT : align = 1 ;
size = 0 ;
break ;
case IEEE80211_RADIOTAP_VENDOR_NAMESPACE : align = 2 ;
size = 6 ;
break ;
default : # ifdef RADIOTAP_SUPPORT_OVERRIDES if ( find_override ( iterator , & align , & size ) ) {
}
else # endif if ( ! iterator -> current_namespace || iterator -> _arg_index >= iterator -> current_namespace -> n_bits ) {
if ( iterator -> current_namespace == & radiotap_ns ) return - ENOENT ;
align = 0 ;
}
else {
align = iterator -> current_namespace -> align_size [ iterator -> _arg_index ] . align ;
size = iterator -> current_namespace -> align_size [ iterator -> _arg_index ] . size ;
}
if ( ! align ) {
iterator -> _arg = iterator -> _next_ns_data ;
iterator -> current_namespace = NULL ;
goto next_entry ;
}
break ;
}
pad = ( int ) ( ( iterator -> _arg - ( unsigned char * ) iterator -> _rtheader ) & ( align - 1 ) ) ;
if ( pad ) iterator -> _arg += align - pad ;
if ( iterator -> _arg_index % 32 == IEEE80211_RADIOTAP_VENDOR_NAMESPACE ) {
int vnslen ;
if ( ! ITERATOR_VALID ( iterator , size ) ) return - EINVAL ;
oui = ( * iterator -> _arg << 16 ) | ( * ( iterator -> _arg + 1 ) << 8 ) | * ( iterator -> _arg + 2 ) ;
subns = * ( iterator -> _arg + 3 ) ;
find_ns ( iterator , oui , subns ) ;
vnslen = get_unaligned_le16 ( iterator -> _arg + 4 ) ;
iterator -> _next_ns_data = iterator -> _arg + size + vnslen ;
if ( ! iterator -> current_namespace ) size += vnslen ;
}
iterator -> this_arg_index = iterator -> _arg_index ;
iterator -> this_arg = iterator -> _arg ;
iterator -> this_arg_size = size ;
iterator -> _arg += size ;
if ( ! ITERATOR_VALID ( iterator , 0 ) ) return - EINVAL ;
switch ( iterator -> _arg_index % 32 ) {
case IEEE80211_RADIOTAP_VENDOR_NAMESPACE : iterator -> _reset_on_ext = 1 ;
iterator -> is_radiotap_ns = 0 ;
iterator -> this_arg_index = IEEE80211_RADIOTAP_VENDOR_NAMESPACE ;
if ( ! iterator -> current_namespace ) hit = 1 ;
goto next_entry ;
case IEEE80211_RADIOTAP_RADIOTAP_NAMESPACE : iterator -> _reset_on_ext = 1 ;
iterator -> current_namespace = & radiotap_ns ;
iterator -> is_radiotap_ns = 1 ;
goto next_entry ;
case IEEE80211_RADIOTAP_EXT : iterator -> _bitmap_shifter = get_unaligned_le32 ( iterator -> _next_bitmap ) ;
iterator -> _next_bitmap ++ ;
if ( iterator -> _reset_on_ext ) iterator -> _arg_index = 0 ;
else iterator -> _arg_index ++ ;
iterator -> _reset_on_ext = 0 ;
break ;
default : hit = 1 ;
next_entry : iterator -> _bitmap_shifter >>= 1 ;
iterator -> _arg_index ++ ;
}
if ( hit ) return 0 ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void splay_move_to_root ( clump_t * x , gs_ref_memory_t * mem ) {
clump_t * y , * z ;
if ( x == NULL ) return ;
while ( ( y = x -> parent ) != NULL ) {
if ( ( z = y -> parent ) != NULL ) {
x -> parent = z -> parent ;
if ( x -> parent ) {
if ( x -> parent -> left == z ) x -> parent -> left = x ;
else x -> parent -> right = x ;
}
y -> parent = x ;
if ( y -> left == x ) {
if ( z -> left == y ) {
y -> left = x -> right ;
if ( y -> left ) y -> left -> parent = y ;
z -> left = y -> right ;
if ( z -> left ) z -> left -> parent = z ;
y -> right = z ;
z -> parent = y ;
}
else {
z -> right = x -> left ;
if ( z -> right ) z -> right -> parent = z ;
y -> left = x -> right ;
if ( y -> left ) y -> left -> parent = y ;
x -> left = z ;
z -> parent = x ;
}
x -> right = y ;
}
else {
if ( z -> left == y ) {
y -> right = x -> left ;
if ( y -> right ) y -> right -> parent = y ;
z -> left = x -> right ;
if ( z -> left ) z -> left -> parent = z ;
x -> right = z ;
z -> parent = x ;
}
else {
z -> right = y -> left ;
if ( z -> right ) z -> right -> parent = z ;
y -> right = x -> left ;
if ( y -> right ) y -> right -> parent = y ;
y -> left = z ;
z -> parent = y ;
}
x -> left = y ;
}
}
else {
x -> parent = NULL ;
y -> parent = x ;
if ( y -> left == x ) {
y -> left = x -> right ;
if ( y -> left ) y -> left -> parent = y ;
x -> right = y ;
}
else {
y -> right = x -> left ;
if ( y -> right ) y -> right -> parent = y ;
x -> left = y ;
}
}
}
mem -> root = x ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int read_code_table ( CLLCContext * ctx , GetBitContext * gb , VLC * vlc ) {
uint8_t symbols [ 256 ] ;
uint8_t bits [ 256 ] ;
uint16_t codes [ 256 ] ;
int num_lens , num_codes , num_codes_sum , prefix ;
int i , j , count ;
prefix = 0 ;
count = 0 ;
num_codes_sum = 0 ;
num_lens = get_bits ( gb , 5 ) ;
for ( i = 0 ;
i < num_lens ;
i ++ ) {
num_codes = get_bits ( gb , 9 ) ;
num_codes_sum += num_codes ;
if ( num_codes_sum > 256 ) {
vlc -> table = NULL ;
av_log ( ctx -> avctx , AV_LOG_ERROR , "Too many VLCs (%d) to be read.\n" , num_codes_sum ) ;
return AVERROR_INVALIDDATA ;
}
for ( j = 0 ;
j < num_codes ;
j ++ ) {
symbols [ count ] = get_bits ( gb , 8 ) ;
bits [ count ] = i + 1 ;
codes [ count ] = prefix ++ ;
count ++ ;
}
prefix <<= 1 ;
}
return ff_init_vlc_sparse ( vlc , 7 , count , bits , 1 , 1 , codes , 2 , 2 , symbols , 1 , 1 , 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int fourcc_is_ivf ( const char detect [ 4 ] ) {
if ( memcmp ( detect , "DKIF" , 4 ) == 0 ) {
return 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
fz_colorspace * fz_new_icc_colorspace ( fz_context * ctx , const char * name , int num , fz_buffer * buf ) {
# ifdef NO_ICC fz_throw ( ctx , FZ_ERROR_GENERIC , "ICC Profiles not supported in NO_ICC build" ) ;
# else fz_colorspace * cs = NULL ;
fz_iccprofile * profile ;
int is_lab = 0 ;
enum fz_colorspace_type type = FZ_COLORSPACE_NONE ;
int flags = FZ_COLORSPACE_IS_ICC ;
profile = fz_malloc_struct ( ctx , fz_iccprofile ) ;
fz_try ( ctx ) {
if ( buf == NULL ) {
size_t size ;
const unsigned char * data ;
data = fz_lookup_icc ( ctx , name , & size ) ;
profile -> buffer = fz_new_buffer_from_shared_data ( ctx , data , size ) ;
is_lab = ( strcmp ( name , FZ_ICC_PROFILE_LAB ) == 0 ) ;
profile -> bgr = ( strcmp ( name , FZ_ICC_PROFILE_BGR ) == 0 ) ;
flags |= FZ_COLORSPACE_IS_DEVICE ;
}
else {
profile -> buffer = fz_keep_buffer ( ctx , buf ) ;
}
fz_cmm_init_profile ( ctx , profile ) ;
if ( num != 0 && num != profile -> num_devcomp ) {
fz_drop_buffer ( ctx , profile -> buffer ) ;
fz_cmm_fin_profile ( ctx , profile ) ;
fz_free ( ctx , profile ) ;
break ;
}
fz_md5_icc ( ctx , profile ) ;
switch ( profile -> num_devcomp ) {
default : type = FZ_COLORSPACE_SEPARATION ;
break ;
case 1 : type = FZ_COLORSPACE_GRAY ;
break ;
case 3 : if ( is_lab ) type = FZ_COLORSPACE_LAB ;
else if ( profile -> bgr ) type = FZ_COLORSPACE_BGR ;
else type = FZ_COLORSPACE_RGB ;
break ;
case 4 : type = FZ_COLORSPACE_CMYK ;
break ;
}
cs = fz_new_colorspace ( ctx , name , type , flags , profile -> num_devcomp , NULL , NULL , NULL , is_lab ? clamp_lab_icc : clamp_default_icc , free_icc , profile , sizeof ( profile ) ) ;
switch ( profile -> num_devcomp ) {
case 1 : fz_colorspace_name_colorant ( ctx , cs , 0 , "Gray" ) ;
break ;
case 3 : if ( is_lab ) {
fz_colorspace_name_colorant ( ctx , cs , 0 , "L*" ) ;
fz_colorspace_name_colorant ( ctx , cs , 1 , "a*" ) ;
fz_colorspace_name_colorant ( ctx , cs , 2 , "b*" ) ;
}
else {
fz_colorspace_name_colorant ( ctx , cs , profile -> bgr ? 2 : 0 , "Red" ) ;
fz_colorspace_name_colorant ( ctx , cs , 1 , "Green" ) ;
fz_colorspace_name_colorant ( ctx , cs , profile -> bgr ? 0 : 2 , "Blue" ) ;
}
break ;
case 4 : fz_colorspace_name_colorant ( ctx , cs , 0 , "Cyan" ) ;
fz_colorspace_name_colorant ( ctx , cs , 1 , "Magenta" ) ;
fz_colorspace_name_colorant ( ctx , cs , 2 , "Yellow" ) ;
fz_colorspace_name_colorant ( ctx , cs , 3 , "Black" ) ;
break ;
}
}
fz_catch ( ctx ) {
fz_drop_buffer ( ctx , profile -> buffer ) ;
fz_cmm_fin_profile ( ctx , profile ) ;
fz_free ( ctx , profile ) ;
}
return cs ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void xmlListReverseWalk ( xmlListPtr l , xmlListWalker walker , const void * user ) {
xmlLinkPtr lk ;
if ( ( l == NULL ) || ( walker == NULL ) ) return ;
for ( lk = l -> sentinel -> prev ;
lk != l -> sentinel ;
lk = lk -> prev ) {
if ( ( walker ( lk -> data , user ) ) == 0 ) break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionWelcomeNotificationTest , WelcomeNotificationPreviouslyDismissedSyncedAndLocal ) {
StartPreferenceSyncing ( ) ;
SetBooleanPref ( prefs : : kWelcomeNotificationDismissed , true ) ;
SetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal , true ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
ShowChromeNowNotification ( ) ;
EXPECT_EQ ( message_center ( ) -> add_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> remove_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> notifications_with_shown_as_popup ( ) , 0 ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void arabic_joining ( hb_buffer_t * buffer ) {
unsigned int count = buffer -> len ;
hb_glyph_info_t * info = buffer -> info ;
unsigned int prev = ( unsigned int ) - 1 , state = 0 ;
for ( unsigned int i = 0 ;
i < buffer -> context_len [ 0 ] ;
i ++ ) {
unsigned int this_type = get_joining_type ( buffer -> context [ 0 ] [ i ] , buffer -> unicode -> general_category ( buffer -> context [ 0 ] [ i ] ) ) ;
if ( unlikely ( this_type == JOINING_TYPE_T ) ) continue ;
const arabic_state_table_entry * entry = & arabic_state_table [ state ] [ this_type ] ;
state = entry -> next_state ;
break ;
}
for ( unsigned int i = 0 ;
i < count ;
i ++ ) {
unsigned int this_type = get_joining_type ( info [ i ] . codepoint , _hb_glyph_info_get_general_category ( & info [ i ] ) ) ;
if ( unlikely ( this_type == JOINING_TYPE_T ) ) {
info [ i ] . arabic_shaping_action ( ) = NONE ;
continue ;
}
const arabic_state_table_entry * entry = & arabic_state_table [ state ] [ this_type ] ;
if ( entry -> prev_action != NONE && prev != ( unsigned int ) - 1 ) info [ prev ] . arabic_shaping_action ( ) = entry -> prev_action ;
info [ i ] . arabic_shaping_action ( ) = entry -> curr_action ;
prev = i ;
state = entry -> next_state ;
}
for ( unsigned int i = 0 ;
i < buffer -> context_len [ 1 ] ;
i ++ ) {
unsigned int this_type = get_joining_type ( buffer -> context [ 1 ] [ i ] , buffer -> unicode -> general_category ( buffer -> context [ 1 ] [ i ] ) ) ;
if ( unlikely ( this_type == JOINING_TYPE_T ) ) continue ;
const arabic_state_table_entry * entry = & arabic_state_table [ state ] [ this_type ] ;
if ( entry -> prev_action != NONE && prev != ( unsigned int ) - 1 ) info [ prev ] . arabic_shaping_action ( ) = entry -> prev_action ;
break ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int set_file_attrs ( const char * fname , struct file_struct * file , stat_x * sxp , const char * fnamecmp , int flags ) {
int updated = 0 ;
stat_x sx2 ;
int change_uid , change_gid ;
mode_t new_mode = file -> mode ;
int inherit ;
if ( ! sxp ) {
if ( dry_run ) return 1 ;
if ( link_stat ( fname , & sx2 . st , 0 ) < 0 ) {
rsyserr ( FERROR_XFER , errno , "stat %s failed" , full_fname ( fname ) ) ;
return 0 ;
}
init_stat_x ( & sx2 ) ;
sxp = & sx2 ;
inherit = ! preserve_perms ;
}
else inherit = ! preserve_perms && file -> flags & FLAG_DIR_CREATED ;
if ( inherit && S_ISDIR ( new_mode ) && sxp -> st . st_mode & S_ISGID ) {
new_mode |= S_ISGID ;
}
if ( daemon_chmod_modes && ! S_ISLNK ( new_mode ) ) new_mode = tweak_mode ( new_mode , daemon_chmod_modes ) ;
# ifdef SUPPORT_ACLS if ( preserve_acls && ! S_ISLNK ( file -> mode ) && ! ACL_READY ( * sxp ) ) get_acl ( fname , sxp ) ;
# endif change_uid = am_root && uid_ndx && sxp -> st . st_uid != ( uid_t ) F_OWNER ( file ) ;
change_gid = gid_ndx && ! ( file -> flags & FLAG_SKIP_GROUP ) && sxp -> st . st_gid != ( gid_t ) F_GROUP ( file ) ;
# ifndef CAN_CHOWN_SYMLINK if ( S_ISLNK ( sxp -> st . st_mode ) ) {
;
}
else # endif if ( change_uid || change_gid ) {
if ( DEBUG_GTE ( OWN , 1 ) ) {
if ( change_uid ) {
rprintf ( FINFO , "set uid of %s from %u to %u\n" , fname , ( unsigned ) sxp -> st . st_uid , F_OWNER ( file ) ) ;
}
if ( change_gid ) {
rprintf ( FINFO , "set gid of %s from %u to %u\n" , fname , ( unsigned ) sxp -> st . st_gid , F_GROUP ( file ) ) ;
}
}
if ( am_root >= 0 ) {
uid_t uid = change_uid ? ( uid_t ) F_OWNER ( file ) : sxp -> st . st_uid ;
gid_t gid = change_gid ? ( gid_t ) F_GROUP ( file ) : sxp -> st . st_gid ;
if ( do_lchown ( fname , uid , gid ) != 0 ) {
rsyserr ( FERROR_XFER , errno , "%s %s failed" , change_uid ? "chown" : "chgrp" , full_fname ( fname ) ) ;
goto cleanup ;
}
if ( uid == ( uid_t ) - 1 && sxp -> st . st_uid != ( uid_t ) - 1 ) rprintf ( FERROR_XFER , "uid 4294967295 (-1) is impossible to set on %s\n" , full_fname ( fname ) ) ;
if ( gid == ( gid_t ) - 1 && sxp -> st . st_gid != ( gid_t ) - 1 ) rprintf ( FERROR_XFER , "gid 4294967295 (-1) is impossible to set on %s\n" , full_fname ( fname ) ) ;
if ( sxp -> st . st_mode & ( S_ISUID | S_ISGID ) ) {
link_stat ( fname , & sxp -> st , keep_dirlinks && S_ISDIR ( sxp -> st . st_mode ) ) ;
}
}
updated = 1 ;
}
# ifdef SUPPORT_XATTRS if ( am_root < 0 ) set_stat_xattr ( fname , file , new_mode ) ;
if ( preserve_xattrs && fnamecmp ) set_xattr ( fname , file , fnamecmp , sxp ) ;
# endif if ( ! preserve_times || ( ! ( preserve_times & PRESERVE_DIR_TIMES ) && S_ISDIR ( sxp -> st . st_mode ) ) || ( ! ( preserve_times & PRESERVE_LINK_TIMES ) && S_ISLNK ( sxp -> st . st_mode ) ) ) flags |= ATTRS_SKIP_MTIME ;
if ( ! ( flags & ATTRS_SKIP_MTIME ) && ( sxp -> st . st_mtime != file -> modtime # ifdef ST_MTIME_NSEC || ( NSEC_BUMP ( file ) && ( uint32 ) sxp -> st . ST_MTIME_NSEC != F_MOD_NSEC ( file ) ) # endif ) ) {
int ret = set_modtime ( fname , file -> modtime , F_MOD_NSEC ( file ) , sxp -> st . st_mode ) ;
if ( ret < 0 ) {
rsyserr ( FERROR_XFER , errno , "failed to set times on %s" , full_fname ( fname ) ) ;
goto cleanup ;
}
if ( ret == 0 ) updated = 1 ;
else file -> flags |= FLAG_TIME_FAILED ;
}
# ifdef SUPPORT_ACLS if ( preserve_acls && ! S_ISLNK ( new_mode ) ) {
if ( set_acl ( fname , file , sxp , new_mode ) > 0 ) updated = 1 ;
}
# endif # ifdef HAVE_CHMOD if ( ! BITS_EQUAL ( sxp -> st . st_mode , new_mode , CHMOD_BITS ) ) {
int ret = am_root < 0 ? 0 : do_chmod ( fname , new_mode ) ;
if ( ret < 0 ) {
rsyserr ( FERROR_XFER , errno , "failed to set permissions on %s" , full_fname ( fname ) ) ;
goto cleanup ;
}
if ( ret == 0 ) updated = 1 ;
}
# endif if ( INFO_GTE ( NAME , 2 ) && flags & ATTRS_REPORT ) {
if ( updated ) rprintf ( FCLIENT , "%s\n" , fname ) ;
else rprintf ( FCLIENT , "%s is uptodate\n" , fname ) ;
}
cleanup : if ( sxp == & sx2 ) free_stat_x ( & sx2 ) ;
return updated ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileObject , fwrite ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
char * str ;
int str_len ;
long length = 0 ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "s|l" , & str , & str_len , & length ) == FAILURE ) {
return ;
}
if ( ZEND_NUM_ARGS ( ) > 1 ) {
str_len = MAX ( 0 , MIN ( length , str_len ) ) ;
}
if ( ! str_len ) {
RETURN_LONG ( 0 ) ;
}
RETURN_LONG ( php_stream_write ( intern -> u . file . stream , str , str_len ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ipvideo_decode_block_opcode_0x9 ( IpvideoContext * s , AVFrame * frame ) {
int x , y ;
unsigned char P [ 4 ] ;
bytestream2_get_buffer ( & s -> stream_ptr , P , 4 ) ;
if ( P [ 0 ] <= P [ 1 ] ) {
if ( P [ 2 ] <= P [ 3 ] ) {
for ( y = 0 ;
y < 8 ;
y ++ ) {
int flags = bytestream2_get_le16 ( & s -> stream_ptr ) ;
for ( x = 0 ;
x < 8 ;
x ++ , flags >>= 2 ) * s -> pixel_ptr ++ = P [ flags & 0x03 ] ;
s -> pixel_ptr += s -> line_inc ;
}
}
else {
uint32_t flags ;
flags = bytestream2_get_le32 ( & s -> stream_ptr ) ;
for ( y = 0 ;
y < 8 ;
y += 2 ) {
for ( x = 0 ;
x < 8 ;
x += 2 , flags >>= 2 ) {
s -> pixel_ptr [ x ] = s -> pixel_ptr [ x + 1 ] = s -> pixel_ptr [ x + s -> stride ] = s -> pixel_ptr [ x + 1 + s -> stride ] = P [ flags & 0x03 ] ;
}
s -> pixel_ptr += s -> stride * 2 ;
}
}
}
else {
uint64_t flags ;
flags = bytestream2_get_le64 ( & s -> stream_ptr ) ;
if ( P [ 2 ] <= P [ 3 ] ) {
for ( y = 0 ;
y < 8 ;
y ++ ) {
for ( x = 0 ;
x < 8 ;
x += 2 , flags >>= 2 ) {
s -> pixel_ptr [ x ] = s -> pixel_ptr [ x + 1 ] = P [ flags & 0x03 ] ;
}
s -> pixel_ptr += s -> stride ;
}
}
else {
for ( y = 0 ;
y < 8 ;
y += 2 ) {
for ( x = 0 ;
x < 8 ;
x ++ , flags >>= 2 ) {
s -> pixel_ptr [ x ] = s -> pixel_ptr [ x + s -> stride ] = P [ flags & 0x03 ] ;
}
s -> pixel_ptr += s -> stride * 2 ;
}
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_copy_pattern_gstate ( fz_context * ctx , pdf_gstate * gs , const pdf_gstate * old ) {
gs -> ctm = old -> ctm ;
pdf_drop_font ( ctx , gs -> text . font ) ;
gs -> text . font = pdf_keep_font ( ctx , old -> text . font ) ;
pdf_drop_xobject ( ctx , gs -> softmask ) ;
gs -> softmask = pdf_keep_xobject ( ctx , old -> softmask ) ;
fz_drop_stroke_state ( ctx , gs -> stroke_state ) ;
gs -> stroke_state = fz_keep_stroke_state ( ctx , old -> stroke_state ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void print_form_element ( int element , int cmd ) {
time_t t ;
int t_hour , t_min ;
char buffer [ MAX_INPUT_BUFFER ] ;
switch ( element ) {
case PRINT_COMMON_HEADER : printf ( "<tr><td COLSPAN=\"2\">
</td></tr>\n" ) ;
printf ( "<tr><td COLSPAN=\"2\" CLASS='sectionHeader'>Common Data</td></tr>\n" ) ;
printf ( "<tr><td COLSPAN=\"2\">
</td></tr>\n" ) ;
break ;
case PRINT_AUTHOR : printf ( "<tr><td class=\"objectDescription descriptionleft\">Author (Your Name):</td><td align=\"left\">" ) ;
if ( lock_author_names == TRUE ) printf ( "<INPUT TYPE='HIDDEN' NAME='com_author' VALUE='%s'>%s</td></tr>\n" , escape_string ( comment_author ) , escape_string ( comment_author ) ) ;
else printf ( "<INPUT TYPE='INPUT' NAME='com_author' VALUE='%s'></td></tr>\n" , escape_string ( comment_author ) ) ;
break ;
case PRINT_COMMENT_BOX : strcpy ( help_text , "If you work with other administrators, you may find it useful to share information about a host/service " "that is having problems if more than one of you may be working on it. " "Make sure to enter a brief description of what you are doing." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Comment:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<TEXTAREA ID=\"com_data\" NAME='com_data' COLS=25 ROWS=2 onkeyup=\"check_input();
\">%s</TEXTAREA>" , escape_string ( comment_data ) ) ;
printf ( "<BR><DIV ID='com_data_error' class=\"inputError\" style=\"display:none;
\">Comment data can't be sent empty</DIV>" ) ;
printf ( "</td></tr>\n" ) ;
break ;
case PRINT_CHECK_OUTPUT_BOX : snprintf ( help_text , sizeof ( help_text ) , "Fill in the exact output string which sould be sent to %s" , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Check Output:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<TEXTAREA ID=\"plugin_output\" NAME='plugin_output' COLS=25 ROWS=2 onkeyup=\"check_input();
\"></TEXTAREA>" ) ;
printf ( "<BR><DIV ID='plugin_output_error' class=\"inputError\" style=\"display:none;
\">Output string can't be send empty</DIV>" ) ;
printf ( "</td></tr>\n" ) ;
break ;
case PRINT_PERFORMANCE_DATA_BOX : snprintf ( help_text , sizeof ( help_text ) , "Fill in the exact performance data string which sould be sent to %s" , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Performance Data:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<TEXTAREA NAME='performance_data' COLS=25 ROWS=2></TEXTAREA></td></tr>\n" ) ;
break ;
case PRINT_STICKY_ACK : strcpy ( help_text , "If you want acknowledgement to disable notifications until the host/service recovers, check this option." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Sticky Acknowledgement:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' NAME='sticky_ack' %s></td></tr>\n" , ( sticky_ack == TRUE ) ? "CHECKED" : "" ) ;
break ;
case PRINT_SEND_NOTFICATION : strcpy ( help_text , "If you do not want an acknowledgement notification sent out to the appropriate contacts, uncheck this option." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Send Notification:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' NAME='send_notification' %s></td></tr>\n" , ( send_notification == TRUE ) ? "CHECKED" : "" ) ;
break ;
case PRINT_PERSISTENT : if ( cmd == CMD_ACKNOWLEDGE_HOST_PROBLEM || cmd == CMD_ACKNOWLEDGE_SVC_PROBLEM ) strcpy ( help_text , "If you would like the comment to remain once the acknowledgement is removed, check this checkbox." ) ;
else {
snprintf ( help_text , sizeof ( help_text ) , "If you uncheck this option, the comment will automatically be deleted the next time %s is restarted." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
}
printf ( "<tr><td class=\"objectDescription descriptionleft\">Persistent%s:" , ( cmd == CMD_ACKNOWLEDGE_HOST_PROBLEM || cmd == CMD_ACKNOWLEDGE_SVC_PROBLEM ) ? " Comment" : "" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' NAME='persistent' %s></td></tr>\n" , ( persistent_ack_comments == TRUE || cmd == CMD_ADD_HOST_COMMENT || cmd == CMD_ADD_SVC_COMMENT ) ? "CHECKED" : "" ) ;
break ;
case PRINT_NOTIFICATION_DELAY : strcpy ( help_text , "The notification delay will be disregarded if the host/service changes state before the next notification is scheduled to be sent out." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Notification Delay (minutes from now):" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='TEXT' ID='not_dly' NAME='not_dly' VALUE='%d' SIZE=\"4\">" , notification_delay ) ;
printf ( "<BR><DIV ID='not_dly_error' class=\"inputError\" style=\"display:none;
\">Notification delay can't be zero</DIV>" ) ;
printf ( "</td></tr>\n" ) ;
break ;
case PRINT_START_TIME : case PRINT_END_TIME : case PRINT_CHECK_TIME : time ( & t ) ;
if ( element == PRINT_END_TIME ) t += ( unsigned long ) default_downtime_duration ;
get_time_string ( & t , buffer , sizeof ( buffer ) - 1 , SHORT_DATE_TIME ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">" ) ;
if ( element == PRINT_START_TIME ) {
strcpy ( help_text , "Set the start date/time for the downtime." ) ;
printf ( "Start Time:" ) ;
}
else if ( element == PRINT_END_TIME ) {
strcpy ( help_text , "Set the end date/time for the downtime." ) ;
printf ( "End Time:" ) ;
}
else {
strcpy ( help_text , "Set the date/time when this check should be schedule to." ) ;
printf ( "Check Time:" ) ;
}
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\"><INPUT TYPE='TEXT' class='timepicker' NAME='%s_time' VALUE='%s' SIZE=\"25\"></td></tr>\n" , ( element == PRINT_END_TIME ) ? "end" : "start" , buffer ) ;
break ;
case PRINT_FIXED_FLEXIBLE_TYPE : default_downtime_duration = default_downtime_duration / 60 ;
t_min = default_downtime_duration % 60 ;
default_downtime_duration = default_downtime_duration - t_min ;
t_hour = ( default_downtime_duration / 60 ) ;
snprintf ( help_text , sizeof ( help_text ) , "If you select the <i>fixed</i> option, the downtime will be in effect between the start and end times you specify. If you do not select the <i>fixed</i> " "option, %s will treat this as <i>flexible</i> downtime. Flexible downtime starts when the host goes down or becomes unreachable / service becomes critical (sometime between the " "start and end times you specified) and lasts as long as the duration of time you enter. The duration fields do not apply for fixed downtime." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Type:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">\n" ) ;
printf ( "\t<SELECT ID=\"flexible_selection\" NAME='fixed' onChange=\"if (document.getElementById('flexible_selection').selectedIndex == 0) document.getElementById('fd_row').style.display = 'none';
else document.getElementById('fd_row').style.display = '';
\">\n" ) ;
printf ( "\t\t<OPTION VALUE=1\">Fixed</OPTION>\n" ) ;
printf ( "\t\t<OPTION VALUE=0\">Flexible</OPTION>\n" ) ;
printf ( "\t</SELECT>\n" ) ;
snprintf ( help_text , sizeof ( help_text ) , "Enter here the duration of the downtime. %s will automatically delete the downtime after this time expired." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
printf ( "<tr id=\"fd_row\" style=\"display:none;
\"><td class=\"objectDescription descriptionleft\">Flexible Duration:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">\n" ) ;
printf ( "\t<table border=0 cellspacing=0 cellpadding=0>\n" ) ;
printf ( "\t\t<tr>\n" ) ;
printf ( "\t\t\t<td><INPUT TYPE='TEXT' NAME='hours' VALUE='%d' SIZE=4 MAXLENGTH=4></td>\n" , t_hour ) ;
printf ( "\t\t\t<td width=\"50\">
Hours</td>\n" ) ;
printf ( "\t\t\t<td><INPUT TYPE='TEXT' NAME='minutes' VALUE='%d' SIZE=2 MAXLENGTH=2></td>\n" , t_min ) ;
printf ( "\t\t\t<td width=\"50\">
Minutes</td>\n" ) ;
printf ( "\t\t</tr>\n" ) ;
printf ( "\t</table>\n" ) ;
printf ( "</td></tr>\n" ) ;
break ;
case PRINT_EXPIRE_ACKNOWLEDGEMENT : strcpy ( help_text , "If you want to let the acknowledgement expire, check this option." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Use Expire Time:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' ID='expire_checkbox' NAME='use_ack_end_time' onClick=\"if (document.getElementById('expire_checkbox').checked == true) document.getElementById('expired_date_row').style.display = '';
else document.getElementById('expired_date_row').style.display = 'none';
\"></td></tr>\n" ) ;
snprintf ( help_text , sizeof ( help_text ) , "Enter here the expire date/time for this acknowledgement. %s will automatically delete the acknowledgement after this time expired." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
time ( & t ) ;
t += ( unsigned long ) default_expiring_acknowledgement_duration ;
get_time_string ( & t , buffer , sizeof ( buffer ) - 1 , SHORT_DATE_TIME ) ;
printf ( "<tr id=\"expired_date_row\" style=\"display:none;
\"><td class=\"objectDescription descriptionleft\">Expire Time:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\"><INPUT TYPE='TEXT' class='timepicker' NAME='end_time' VALUE='%s' SIZE=\"25\"></td></tr>\n" , buffer ) ;
break ;
case PRINT_EXPIRE_DISABLE_NOTIFICATIONS : strcpy ( help_text , "If you want to let the disabled notifications expire, check this option." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Use Expire Time:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' ID='expire_checkbox' NAME='use_disabled_notif_end_time' onClick=\"if (document.getElementById('expire_checkbox').checked == true) document.getElementById('expired_date_row').style.display = '';
else document.getElementById('expired_date_row').style.display = 'none';
\"></td></tr>\n" ) ;
snprintf ( help_text , sizeof ( help_text ) , "Enter the expire date/time for disabled notifications. %s will automatically re-enable all notifications after this time expired." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
time ( & t ) ;
t += ( unsigned long ) default_expiring_disabled_notifications_duration ;
get_time_string ( & t , buffer , sizeof ( buffer ) - 1 , SHORT_DATE_TIME ) ;
printf ( "<tr id=\"expired_date_row\" style=\"display:none;
\"><td class=\"objectDescription descriptionleft\">Expire Time:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\"><INPUT TYPE='TEXT' class='timepicker' NAME='end_time' VALUE='%s' SIZE=\"25\"></td></tr>\n" , buffer ) ;
break ;
case PRINT_FORCE_CHECK : snprintf ( help_text , sizeof ( help_text ) , "If you select this option, %s will force a check of the host/service regardless of both what time the scheduled check occurs and whether or not checks are enabled for the host/service." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Force Check:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' NAME='force_check' %s></td></tr>\n" , ( force_check == TRUE ) ? "CHECKED" : "" ) ;
break ;
case PRINT_BROADCAST_NOTIFICATION : strcpy ( help_text , "Selecting this option causes the notification to be sent out to all normal (non-escalated) and escalated contacts. These options allow you to override the normal notification logic if you need to get an important message out." ) ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Broadcast:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' NAME='broadcast_notification'></td></tr>\n" ) ;
break ;
case PRINT_FORCE_NOTIFICATION : snprintf ( help_text , sizeof ( help_text ) , "Custom notifications normally follow the regular notification logic in %s. Selecting this option will force the notification to be sent out, regardless of the time restrictions, whether or not notifications are enabled, etc." , PROGRAM_NAME ) ;
help_text [ sizeof ( help_text ) - 1 ] = '\x0' ;
printf ( "<tr><td class=\"objectDescription descriptionleft\">Forced:" ) ;
print_help_box ( help_text ) ;
printf ( "</td><td align=\"left\">" ) ;
printf ( "<INPUT TYPE='checkbox' NAME='force_notification'></td></tr>\n" ) ;
break ;
default : break ;
}
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp8_get_reference ( VP8_COMP * cpi , enum vpx_ref_frame_type ref_frame_flag , YV12_BUFFER_CONFIG * sd ) {
VP8_COMMON * cm = & cpi -> common ;
int ref_fb_idx ;
if ( ref_frame_flag == VP8_LAST_FRAME ) ref_fb_idx = cm -> lst_fb_idx ;
else if ( ref_frame_flag == VP8_GOLD_FRAME ) ref_fb_idx = cm -> gld_fb_idx ;
else if ( ref_frame_flag == VP8_ALTR_FRAME ) ref_fb_idx = cm -> alt_fb_idx ;
else return - 1 ;
vp8_yv12_copy_frame ( & cm -> yv12_fb [ ref_fb_idx ] , sd ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void sbr_qmf_post_shuffle_c ( float W [ 32 ] [ 2 ] , const float * z ) {
const union av_intfloat32 * zi = ( const union av_intfloat32 * ) z ;
union av_intfloat32 * Wi = ( union av_intfloat32 * ) W ;
int k ;
for ( k = 0 ;
k < 32 ;
k += 2 ) {
Wi [ 2 * k + 0 ] . i = zi [ 63 - k ] . i ^ ( 1U << 31 ) ;
Wi [ 2 * k + 1 ] . i = zi [ k + 0 ] . i ;
Wi [ 2 * k + 2 ] . i = zi [ 62 - k ] . i ^ ( 1U << 31 ) ;
Wi [ 2 * k + 3 ] . i = zi [ k + 1 ] . i ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int binkb_get_value ( BinkContext * c , int bundle_num ) {
int16_t ret ;
const int bits = binkb_bundle_sizes [ bundle_num ] ;
if ( bits <= 8 ) {
int val = * c -> bundle [ bundle_num ] . cur_ptr ++ ;
return binkb_bundle_signed [ bundle_num ] ? ( int8_t ) val : val ;
}
ret = * ( int16_t * ) c -> bundle [ bundle_num ] . cur_ptr ;
c -> bundle [ bundle_num ] . cur_ptr += 2 ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int32_t u_scanf_percent_handler ( UFILE * input , u_scanf_spec_info * info , ufmt_args * args , const UChar * fmt , int32_t * fmtConsumed , int32_t * argConverted ) {
int32_t len ;
double num ;
UNumberFormat * format ;
int32_t parsePos = 0 ;
UErrorCode status = U_ZERO_ERROR ;
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_PERCENT ) ;
if ( format == 0 ) return 0 ;
u_scanf_skip_leading_positive_sign ( input , format , & status ) ;
num = unum_parseDouble ( format , input -> str . fPos , len , & parsePos , & status ) ;
if ( ! info -> fSkipArg ) {
* ( double * ) ( args [ 0 ] . ptrValue ) = num ;
}
input -> str . fPos += parsePos ;
* argConverted = ! info -> fSkipArg ;
return parsePos ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ufile_close_translit ( UFILE * f ) {
# if ! UCONFIG_NO_TRANSLITERATION if ( ( ! f ) || ( ! f -> fTranslit ) ) return ;
# endif ufile_flush_translit ( f ) ;
# if ! UCONFIG_NO_TRANSLITERATION if ( f -> fTranslit -> translit ) utrans_close ( f -> fTranslit -> translit ) ;
if ( f -> fTranslit -> buffer ) {
uprv_free ( f -> fTranslit -> buffer ) ;
}
uprv_free ( f -> fTranslit ) ;
f -> fTranslit = NULL ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplDoublyLinkedList , unserialize ) {
spl_dllist_object * intern = ( spl_dllist_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
zval * flags , * elem ;
char * buf ;
int buf_len ;
const unsigned char * p , * s ;
php_unserialize_data_t var_hash ;
if ( zend_parse_parameters ( ZEND_NUM_ARGS ( ) TSRMLS_CC , "s" , & buf , & buf_len ) == FAILURE ) {
return ;
}
if ( buf_len == 0 ) {
zend_throw_exception_ex ( spl_ce_UnexpectedValueException , 0 TSRMLS_CC , "Serialized string cannot be empty" ) ;
return ;
}
s = p = ( const unsigned char * ) buf ;
PHP_VAR_UNSERIALIZE_INIT ( var_hash ) ;
ALLOC_INIT_ZVAL ( flags ) ;
if ( ! php_var_unserialize ( & flags , & p , s + buf_len , & var_hash TSRMLS_CC ) || Z_TYPE_P ( flags ) != IS_LONG ) {
zval_ptr_dtor ( & flags ) ;
goto error ;
}
intern -> flags = Z_LVAL_P ( flags ) ;
zval_ptr_dtor ( & flags ) ;
while ( * p == ':' ) {
++ p ;
ALLOC_INIT_ZVAL ( elem ) ;
if ( ! php_var_unserialize ( & elem , & p , s + buf_len , & var_hash TSRMLS_CC ) ) {
zval_ptr_dtor ( & elem ) ;
goto error ;
}
spl_ptr_llist_push ( intern -> llist , elem TSRMLS_CC ) ;
}
if ( * p != '\0' ) {
goto error ;
}
PHP_VAR_UNSERIALIZE_DESTROY ( var_hash ) ;
return ;
error : PHP_VAR_UNSERIALIZE_DESTROY ( var_hash ) ;
zend_throw_exception_ex ( spl_ce_UnexpectedValueException , 0 TSRMLS_CC , "Error at offset %ld of %d bytes" , ( long ) ( ( char * ) p - buf ) , buf_len ) ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gboolean make_file_name_valid_for_dest_fs ( char * filename , const char * dest_fs_type ) {
if ( dest_fs_type != NULL && filename != NULL ) {
if ( ! strcmp ( dest_fs_type , "fat" ) || ! strcmp ( dest_fs_type , "vfat" ) || ! strcmp ( dest_fs_type , "msdos" ) || ! strcmp ( dest_fs_type , "msdosfs" ) ) {
gboolean ret ;
int i , old_len ;
ret = fat_str_replace ( filename , '_' ) ;
old_len = strlen ( filename ) ;
for ( i = 0 ;
i < old_len ;
i ++ ) {
if ( filename [ i ] != ' ' ) {
g_strchomp ( filename ) ;
ret |= ( old_len != strlen ( filename ) ) ;
break ;
}
}
return ret ;
}
}
return FALSE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void Init_generator ( void ) {
rb_require ( "json/common" ) ;
mJSON = rb_define_module ( "JSON" ) ;
mExt = rb_define_module_under ( mJSON , "Ext" ) ;
mGenerator = rb_define_module_under ( mExt , "Generator" ) ;
eGeneratorError = rb_path2class ( "JSON::GeneratorError" ) ;
eNestingError = rb_path2class ( "JSON::NestingError" ) ;
cState = rb_define_class_under ( mGenerator , "State" , rb_cObject ) ;
rb_define_alloc_func ( cState , cState_s_allocate ) ;
rb_define_singleton_method ( cState , "from_state" , cState_from_state_s , 1 ) ;
rb_define_method ( cState , "initialize" , cState_initialize , - 1 ) ;
rb_define_method ( cState , "initialize_copy" , cState_init_copy , 1 ) ;
rb_define_method ( cState , "indent" , cState_indent , 0 ) ;
rb_define_method ( cState , "indent=" , cState_indent_set , 1 ) ;
rb_define_method ( cState , "space" , cState_space , 0 ) ;
rb_define_method ( cState , "space=" , cState_space_set , 1 ) ;
rb_define_method ( cState , "space_before" , cState_space_before , 0 ) ;
rb_define_method ( cState , "space_before=" , cState_space_before_set , 1 ) ;
rb_define_method ( cState , "object_nl" , cState_object_nl , 0 ) ;
rb_define_method ( cState , "object_nl=" , cState_object_nl_set , 1 ) ;
rb_define_method ( cState , "array_nl" , cState_array_nl , 0 ) ;
rb_define_method ( cState , "array_nl=" , cState_array_nl_set , 1 ) ;
rb_define_method ( cState , "max_nesting" , cState_max_nesting , 0 ) ;
rb_define_method ( cState , "max_nesting=" , cState_max_nesting_set , 1 ) ;
rb_define_method ( cState , "check_circular?" , cState_check_circular_p , 0 ) ;
rb_define_method ( cState , "allow_nan?" , cState_allow_nan_p , 0 ) ;
rb_define_method ( cState , "ascii_only?" , cState_ascii_only_p , 0 ) ;
rb_define_method ( cState , "depth" , cState_depth , 0 ) ;
rb_define_method ( cState , "depth=" , cState_depth_set , 1 ) ;
rb_define_method ( cState , "buffer_initial_length" , cState_buffer_initial_length , 0 ) ;
rb_define_method ( cState , "buffer_initial_length=" , cState_buffer_initial_length_set , 1 ) ;
rb_define_method ( cState , "configure" , cState_configure , 1 ) ;
rb_define_alias ( cState , "merge" , "configure" ) ;
rb_define_method ( cState , "to_h" , cState_to_h , 0 ) ;
rb_define_alias ( cState , "to_hash" , "to_h" ) ;
rb_define_method ( cState , "[]" , cState_aref , 1 ) ;
rb_define_method ( cState , "[]=" , cState_aset , 2 ) ;
rb_define_method ( cState , "generate" , cState_generate , 1 ) ;
mGeneratorMethods = rb_define_module_under ( mGenerator , "GeneratorMethods" ) ;
mObject = rb_define_module_under ( mGeneratorMethods , "Object" ) ;
rb_define_method ( mObject , "to_json" , mObject_to_json , - 1 ) ;
mHash = rb_define_module_under ( mGeneratorMethods , "Hash" ) ;
rb_define_method ( mHash , "to_json" , mHash_to_json , - 1 ) ;
mArray = rb_define_module_under ( mGeneratorMethods , "Array" ) ;
rb_define_method ( mArray , "to_json" , mArray_to_json , - 1 ) ;
# ifdef RUBY_INTEGER_UNIFICATION mInteger = rb_define_module_under ( mGeneratorMethods , "Integer" ) ;
rb_define_method ( mInteger , "to_json" , mInteger_to_json , - 1 ) ;
# else mFixnum = rb_define_module_under ( mGeneratorMethods , "Fixnum" ) ;
rb_define_method ( mFixnum , "to_json" , mFixnum_to_json , - 1 ) ;
mBignum = rb_define_module_under ( mGeneratorMethods , "Bignum" ) ;
rb_define_method ( mBignum , "to_json" , mBignum_to_json , - 1 ) ;
# endif mFloat = rb_define_module_under ( mGeneratorMethods , "Float" ) ;
rb_define_method ( mFloat , "to_json" , mFloat_to_json , - 1 ) ;
mString = rb_define_module_under ( mGeneratorMethods , "String" ) ;
rb_define_singleton_method ( mString , "included" , mString_included_s , 1 ) ;
rb_define_method ( mString , "to_json" , mString_to_json , - 1 ) ;
rb_define_method ( mString , "to_json_raw" , mString_to_json_raw , - 1 ) ;
rb_define_method ( mString , "to_json_raw_object" , mString_to_json_raw_object , 0 ) ;
mString_Extend = rb_define_module_under ( mString , "Extend" ) ;
rb_define_method ( mString_Extend , "json_create" , mString_Extend_json_create , 1 ) ;
mTrueClass = rb_define_module_under ( mGeneratorMethods , "TrueClass" ) ;
rb_define_method ( mTrueClass , "to_json" , mTrueClass_to_json , - 1 ) ;
mFalseClass = rb_define_module_under ( mGeneratorMethods , "FalseClass" ) ;
rb_define_method ( mFalseClass , "to_json" , mFalseClass_to_json , - 1 ) ;
mNilClass = rb_define_module_under ( mGeneratorMethods , "NilClass" ) ;
rb_define_method ( mNilClass , "to_json" , mNilClass_to_json , - 1 ) ;
CRegexp_MULTILINE = rb_const_get ( rb_cRegexp , rb_intern ( "MULTILINE" ) ) ;
i_to_s = rb_intern ( "to_s" ) ;
i_to_json = rb_intern ( "to_json" ) ;
i_new = rb_intern ( "new" ) ;
i_indent = rb_intern ( "indent" ) ;
i_space = rb_intern ( "space" ) ;
i_space_before = rb_intern ( "space_before" ) ;
i_object_nl = rb_intern ( "object_nl" ) ;
i_array_nl = rb_intern ( "array_nl" ) ;
i_max_nesting = rb_intern ( "max_nesting" ) ;
i_allow_nan = rb_intern ( "allow_nan" ) ;
i_ascii_only = rb_intern ( "ascii_only" ) ;
i_depth = rb_intern ( "depth" ) ;
i_buffer_initial_length = rb_intern ( "buffer_initial_length" ) ;
i_pack = rb_intern ( "pack" ) ;
i_unpack = rb_intern ( "unpack" ) ;
i_create_id = rb_intern ( "create_id" ) ;
i_extend = rb_intern ( "extend" ) ;
i_key_p = rb_intern ( "key?" ) ;
i_aref = rb_intern ( "[]" ) ;
i_send = rb_intern ( "__send__" ) ;
i_respond_to_p = rb_intern ( "respond_to?" ) ;
i_match = rb_intern ( "match" ) ;
i_keys = rb_intern ( "keys" ) ;
i_dup = rb_intern ( "dup" ) ;
# ifdef HAVE_RUBY_ENCODING_H CEncoding_UTF_8 = rb_funcall ( rb_path2class ( "Encoding" ) , rb_intern ( "find" ) , 1 , rb_str_new2 ( "utf-8" ) ) ;
i_encoding = rb_intern ( "encoding" ) ;
i_encode = rb_intern ( "encode" ) ;
# endif i_SAFE_STATE_PROTOTYPE = rb_intern ( "SAFE_STATE_PROTOTYPE" ) ;
CJSON_SAFE_STATE_PROTOTYPE = Qnil ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ff_draw_horiz_band ( AVCodecContext * avctx , DSPContext * dsp , Picture * cur , Picture * last , int y , int h , int picture_structure , int first_field , int draw_edges , int low_delay , int v_edge_pos , int h_edge_pos ) {
const AVPixFmtDescriptor * desc = av_pix_fmt_desc_get ( avctx -> pix_fmt ) ;
int hshift = desc -> log2_chroma_w ;
int vshift = desc -> log2_chroma_h ;
const int field_pic = picture_structure != PICT_FRAME ;
if ( field_pic ) {
h <<= 1 ;
y <<= 1 ;
}
if ( ! avctx -> hwaccel && ! ( avctx -> codec -> capabilities & CODEC_CAP_HWACCEL_VDPAU ) && draw_edges && cur -> f . reference && ! ( avctx -> flags & CODEC_FLAG_EMU_EDGE ) ) {
int * linesize = cur -> f . linesize ;
int sides = 0 , edge_h ;
if ( y == 0 ) sides |= EDGE_TOP ;
if ( y + h >= v_edge_pos ) sides |= EDGE_BOTTOM ;
edge_h = FFMIN ( h , v_edge_pos - y ) ;
dsp -> draw_edges ( cur -> f . data [ 0 ] + y * linesize [ 0 ] , linesize [ 0 ] , h_edge_pos , edge_h , EDGE_WIDTH , EDGE_WIDTH , sides ) ;
dsp -> draw_edges ( cur -> f . data [ 1 ] + ( y >> vshift ) * linesize [ 1 ] , linesize [ 1 ] , h_edge_pos >> hshift , edge_h >> vshift , EDGE_WIDTH >> hshift , EDGE_WIDTH >> vshift , sides ) ;
dsp -> draw_edges ( cur -> f . data [ 2 ] + ( y >> vshift ) * linesize [ 2 ] , linesize [ 2 ] , h_edge_pos >> hshift , edge_h >> vshift , EDGE_WIDTH >> hshift , EDGE_WIDTH >> vshift , sides ) ;
}
h = FFMIN ( h , avctx -> height - y ) ;
if ( field_pic && first_field && ! ( avctx -> slice_flags & SLICE_FLAG_ALLOW_FIELD ) ) return ;
if ( avctx -> draw_horiz_band ) {
AVFrame * src ;
int offset [ AV_NUM_DATA_POINTERS ] ;
int i ;
if ( cur -> f . pict_type == AV_PICTURE_TYPE_B || low_delay || ( avctx -> slice_flags & SLICE_FLAG_CODED_ORDER ) ) src = & cur -> f ;
else if ( last ) src = & last -> f ;
else return ;
if ( cur -> f . pict_type == AV_PICTURE_TYPE_B && picture_structure == PICT_FRAME && avctx -> codec_id != AV_CODEC_ID_H264 && avctx -> codec_id != AV_CODEC_ID_SVQ3 ) {
for ( i = 0 ;
i < AV_NUM_DATA_POINTERS ;
i ++ ) offset [ i ] = 0 ;
}
else {
offset [ 0 ] = y * src -> linesize [ 0 ] ;
offset [ 1 ] = offset [ 2 ] = ( y >> vshift ) * src -> linesize [ 1 ] ;
for ( i = 3 ;
i < AV_NUM_DATA_POINTERS ;
i ++ ) offset [ i ] = 0 ;
}
emms_c ( ) ;
avctx -> draw_horiz_band ( avctx , src , offset , y , picture_structure , h ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_pcp_message ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data _U_ ) {
proto_item * root_pcp_item ;
proto_tree * pcp_tree ;
conversation_t * conversation ;
pcp_conv_info_t * pcp_conv_info ;
guint32 packet_type ;
gint32 err_bytes ;
int offset = 0 ;
col_set_str ( pinfo -> cinfo , COL_PROTOCOL , "PCP" ) ;
col_clear ( pinfo -> cinfo , COL_INFO ) ;
conversation = find_or_create_conversation ( pinfo ) ;
pcp_conv_info = ( pcp_conv_info_t * ) conversation_get_proto_data ( conversation , proto_pcp ) ;
if ( pcp_conv_info == NULL ) {
pcp_conv_info = ( pcp_conv_info_t * ) g_malloc ( sizeof ( pcp_conv_info_t ) ) ;
conversation_add_proto_data ( conversation , proto_pcp , pcp_conv_info ) ;
pcp_conv_info -> pmid_name_candidates = wmem_array_new ( wmem_file_scope ( ) , sizeof ( guint8 * ) ) ;
pcp_conv_info -> pmid_to_name = wmem_map_new ( wmem_file_scope ( ) , g_direct_hash , g_direct_equal ) ;
pcp_conv_info -> last_pmns_names_frame = 0 ;
pcp_conv_info -> last_processed_pmns_names_frame = 0 ;
}
root_pcp_item = proto_tree_add_item ( tree , proto_pcp , tvb , 0 , - 1 , ENC_NA ) ;
pcp_tree = proto_item_add_subtree ( root_pcp_item , ett_pcp ) ;
packet_type = tvb_get_ntohl ( tvb , 4 ) ;
if ( pinfo -> srcport == PCP_PORT || pinfo -> srcport == PMPROXY_PORT ) {
col_set_str ( pinfo -> cinfo , COL_INFO , "Server > Client " ) ;
}
else {
col_set_str ( pinfo -> cinfo , COL_INFO , "Client > Server " ) ;
}
proto_tree_add_item ( pcp_tree , hf_pcp_pdu_length , tvb , offset , 4 , ENC_BIG_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( pcp_tree , hf_pcp_pdu_type , tvb , offset , 4 , ENC_BIG_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( pcp_tree , hf_pcp_pdu_pid , tvb , offset , 4 , ENC_BIG_ENDIAN ) ;
offset += 4 ;
switch ( packet_type ) {
case PCP_PDU_CREDS : dissect_pcp_message_creds ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_START_OR_ERROR : err_bytes = tvb_get_ntohl ( tvb , offset ) ;
if ( err_bytes < 0 ) {
dissect_pcp_message_error ( tvb , pinfo , pcp_tree , offset ) ;
}
else {
dissect_pcp_message_start ( tvb , pinfo , pcp_tree , offset ) ;
}
break ;
case PCP_PDU_PMNS_TRAVERSE : dissect_pcp_message_pmns_traverse ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PMNS_NAMES : dissect_pcp_message_pmns_names ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PMNS_CHILD : dissect_pcp_message_pmns_child ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PMNS_IDS : dissect_pcp_message_pmns_ids ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PROFILE : dissect_pcp_message_profile ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_FETCH : dissect_pcp_message_fetch ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_RESULT : dissect_pcp_message_result ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_DESC_REQ : dissect_pcp_message_desc_req ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_DESC : dissect_pcp_message_desc ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_INSTANCE_REQ : dissect_pcp_message_instance_req ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_INSTANCE : dissect_pcp_message_instance ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_TEXT_REQ : dissect_pcp_message_text_req ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_TEXT : dissect_pcp_message_text ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_USER_AUTH : dissect_pcp_message_user_auth ( tvb , pinfo , pcp_tree , offset ) ;
break ;
default : col_append_str ( pinfo -> cinfo , COL_INFO , "[UNIMPLEMENTED TYPE]" ) ;
expert_add_info ( pinfo , pcp_tree , & ei_pcp_unimplemented_packet_type ) ;
break ;
}
return tvb_captured_length ( tvb ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int master_service_settings_read ( struct master_service * service ATTR_UNUSED , const struct master_service_settings_input * input ATTR_UNUSED , struct master_service_settings_output * output_r , const char * * error_r ATTR_UNUSED ) {
* output_r = output ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int nbd_can_accept ( void ) {
return state == RUNNING && nb_fds < shared ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void WriteData ( Archive * AHX , const void * data , size_t dLen ) {
ArchiveHandle * AH = ( ArchiveHandle * ) AHX ;
if ( ! AH -> currToc ) exit_horribly ( modulename , "internal error -- WriteData cannot be called outside the context of a DataDumper routine\n" ) ;
( * AH -> WriteDataPtr ) ( AH , data , dLen ) ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ProtocolHandlerRegistryTest , MAYBE_TestInstallDefaultHandler ) {
RecreateRegistry ( false ) ;
registry ( ) -> AddPredefinedHandler ( CreateProtocolHandler ( "test" , GURL ( "http://test.com/%s" ) ) ) ;
registry ( ) -> InitProtocolSettings ( ) ;
std : : vector < std : : string > protocols ;
registry ( ) -> GetRegisteredProtocols ( & protocols ) ;
ASSERT_EQ ( static_cast < size_t > ( 1 ) , protocols . size ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint16 de_emerg_num_list ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo , guint32 offset , guint len _U_ , gchar * add_string _U_ , int string_len _U_ ) {
guint32 curr_offset ;
guint8 en_len ;
guint8 count ;
proto_tree * subtree ;
proto_item * item ;
const char * digit_str ;
curr_offset = offset ;
count = 1 ;
while ( ( curr_offset - offset ) < len ) {
en_len = tvb_get_guint8 ( tvb , curr_offset ) ;
item = proto_tree_add_uint ( tree , hf_gsm_a_dtap_emergency_number_information , tvb , curr_offset , en_len + 1 , count ) ;
subtree = proto_item_add_subtree ( item , ett_gsm_dtap_elem [ DE_EMERGENCY_NUM_LIST ] ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_emerg_num_info_length , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
proto_tree_add_bits_item ( subtree , hf_gsm_a_spare_bits , tvb , curr_offset << 3 , 3 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_serv_cat_b5 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_serv_cat_b4 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_serv_cat_b3 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_serv_cat_b2 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_serv_cat_b1 , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
en_len -- ;
digit_str = tvb_bcd_dig_to_wmem_packet_str ( tvb , curr_offset , en_len , NULL , FALSE ) ;
item = proto_tree_add_string ( subtree , hf_gsm_a_dtap_emergency_bcd_num , tvb , curr_offset , en_len , digit_str ) ;
if ( strchr ( digit_str , '?' ) ) {
expert_add_info ( pinfo , item , & ei_gsm_a_dtap_not_digit ) ;
}
curr_offset = curr_offset + en_len ;
count ++ ;
}
return ( len ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
uint gx_device_raster_plane ( const gx_device * dev , const gx_render_plane_t * render_plane ) {
ulong bpc = ( render_plane && render_plane -> index >= 0 ? render_plane -> depth : dev -> color_info . depth / ( dev -> is_planar ? dev -> color_info . num_components : 1 ) ) ;
ulong bits = ( ulong ) dev -> width * bpc ;
int l2align ;
l2align = dev -> log2_align_mod ;
if ( l2align < log2_align_bitmap_mod ) l2align = log2_align_bitmap_mod ;
return ( uint ) ( ( ( bits + ( 8 << l2align ) - 1 ) >> ( l2align + 3 ) ) << l2align ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static OFCondition parseMaxPDU ( DUL_MAXLENGTH * max , unsigned char * buf , unsigned long * itemLength , unsigned long availData ) {
if ( availData < 8 ) return makeLengthError ( "Max PDU" , availData , 8 ) ;
max -> type = * buf ++ ;
max -> rsv1 = * buf ++ ;
EXTRACT_SHORT_BIG ( buf , max -> length ) ;
buf += 2 ;
EXTRACT_LONG_BIG ( buf , max -> maxLength ) ;
* itemLength = 2 + 2 + max -> length ;
if ( max -> length != 4 ) DCMNET_WARN ( "Invalid length (" << max -> length << ") for maximum length item, must be 4" ) ;
DCMNET_TRACE ( "Maximum PDU Length: " << ( unsigned long ) max -> maxLength ) ;
return EC_Normal ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ResetPTStlb ( encoder_t * p_enc ) {
encoder_sys_t * p_sys = p_enc -> p_sys ;
for ( int i = 0 ;
i < SCHRO_PTS_TLB_SIZE ;
i ++ ) {
p_sys -> pts_tlb [ i ] . b_empty = true ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void copy_partitioning ( VP9_COMMON * cm , MODE_INFO * mi_8x8 , MODE_INFO * prev_mi_8x8 ) {
const int mis = cm -> mi_stride ;
int block_row , block_col ;
for ( block_row = 0 ;
block_row < 8 ;
++ block_row ) {
for ( block_col = 0 ;
block_col < 8 ;
++ block_col ) {
MODE_INFO * const prev_mi = prev_mi_8x8 [ block_row * mis + block_col ] . src_mi ;
const BLOCK_SIZE sb_type = prev_mi ? prev_mi -> mbmi . sb_type : 0 ;
if ( prev_mi ) {
const ptrdiff_t offset = prev_mi - cm -> prev_mi ;
mi_8x8 [ block_row * mis + block_col ] . src_mi = cm -> mi + offset ;
mi_8x8 [ block_row * mis + block_col ] . src_mi -> mbmi . sb_type = sb_type ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void h245dg_calls_init_tap ( void ) {
GString * error_string ;
if ( have_H245dg_tap_listener == FALSE ) {
error_string = register_tap_listener ( "h245dg" , & ( the_tapinfo_struct . h245dg_dummy ) , NULL , 0 , voip_calls_dlg_reset , H245dgcalls_packet , voip_calls_dlg_draw ) ;
if ( error_string != NULL ) {
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , "%s" , error_string -> str ) ;
g_string_free ( error_string , TRUE ) ;
exit ( 1 ) ;
}
have_H245dg_tap_listener = TRUE ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void relpTcpHintBurstBegin ( relpTcp_t * pThis ) {
setCORKopt ( pThis -> sock , 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static unsigned int read_sbr_data ( AACContext * ac , SpectralBandReplication * sbr , GetBitContext * gb , int id_aac ) {
unsigned int cnt = get_bits_count ( gb ) ;
sbr -> id_aac = id_aac ;
if ( id_aac == TYPE_SCE || id_aac == TYPE_CCE ) {
if ( read_sbr_single_channel_element ( ac , sbr , gb ) ) {
sbr_turnoff ( sbr ) ;
return get_bits_count ( gb ) - cnt ;
}
}
else if ( id_aac == TYPE_CPE ) {
if ( read_sbr_channel_pair_element ( ac , sbr , gb ) ) {
sbr_turnoff ( sbr ) ;
return get_bits_count ( gb ) - cnt ;
}
}
else {
av_log ( ac -> avctx , AV_LOG_ERROR , "Invalid bitstream - cannot apply SBR to element type %d\n" , id_aac ) ;
sbr_turnoff ( sbr ) ;
return get_bits_count ( gb ) - cnt ;
}
if ( get_bits1 ( gb ) ) {
int num_bits_left = get_bits ( gb , 4 ) ;
if ( num_bits_left == 15 ) num_bits_left += get_bits ( gb , 8 ) ;
num_bits_left <<= 3 ;
while ( num_bits_left > 7 ) {
num_bits_left -= 2 ;
read_sbr_extension ( ac , sbr , gb , get_bits ( gb , 2 ) , & num_bits_left ) ;
}
if ( num_bits_left < 0 ) {
av_log ( ac -> avctx , AV_LOG_ERROR , "SBR Extension over read.\n" ) ;
}
if ( num_bits_left > 0 ) skip_bits ( gb , num_bits_left ) ;
}
return get_bits_count ( gb ) - cnt ;
}
| 1True
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.