instruction
stringclasses 1
value | input
stringlengths 31
235k
| output
class label 2
classes |
|---|---|---|
Categorize the following code snippet as vulnerable or not. True or False
|
static void Type_Signature_Free ( struct _cms_typehandler_struct * self , void * Ptr ) {
_cmsFree ( self -> ContextID , Ptr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ __u32 __fswab32 ( __u32 val ) {
# if defined ( __arch_swab32 ) return __arch_swab32 ( val ) ;
# else return ___constant_swab32 ( val ) ;
# endif }
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int jbig2_decode_text_region ( Jbig2Ctx * ctx , Jbig2Segment * segment , const Jbig2TextRegionParams * params , const Jbig2SymbolDict * const * dicts , const uint32_t n_dicts , Jbig2Image * image , const byte * data , const size_t size , Jbig2ArithCx * GR_stats , Jbig2ArithState * as , Jbig2WordStream * ws ) {
uint32_t NINSTANCES ;
uint32_t ID ;
int32_t STRIPT ;
int32_t FIRSTS ;
int32_t DT ;
int32_t DFS ;
int32_t IDS ;
int32_t CURS ;
int32_t CURT ;
int S , T ;
int x , y ;
bool first_symbol ;
uint32_t index , SBNUMSYMS ;
Jbig2Image * IB = NULL ;
Jbig2HuffmanState * hs = NULL ;
Jbig2HuffmanTable * SBSYMCODES = NULL ;
int code = 0 ;
int RI ;
SBNUMSYMS = 0 ;
for ( index = 0 ;
index < n_dicts ;
index ++ ) {
SBNUMSYMS += dicts [ index ] -> n_symbols ;
}
jbig2_error ( ctx , JBIG2_SEVERITY_DEBUG , segment -> number , "symbol list contains %d glyphs in %d dictionaries" , SBNUMSYMS , n_dicts ) ;
if ( params -> SBHUFF ) {
Jbig2HuffmanTable * runcodes = NULL ;
Jbig2HuffmanParams runcodeparams ;
Jbig2HuffmanLine runcodelengths [ 35 ] ;
Jbig2HuffmanLine * symcodelengths = NULL ;
Jbig2HuffmanParams symcodeparams ;
int err , len , range , r ;
jbig2_error ( ctx , JBIG2_SEVERITY_DEBUG , segment -> number , "huffman coded text region" ) ;
hs = jbig2_huffman_new ( ctx , ws ) ;
if ( hs == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_WARNING , segment -> number , "failed to allocate storage for text region" ) ;
return - 1 ;
}
for ( index = 0 ;
index < 35 ;
index ++ ) {
runcodelengths [ index ] . PREFLEN = jbig2_huffman_get_bits ( hs , 4 , & code ) ;
if ( code < 0 ) goto cleanup1 ;
runcodelengths [ index ] . RANGELEN = 0 ;
runcodelengths [ index ] . RANGELOW = index ;
jbig2_error ( ctx , JBIG2_SEVERITY_DEBUG , segment -> number , " read runcode%d length %d" , index , runcodelengths [ index ] . PREFLEN ) ;
}
runcodeparams . HTOOB = 0 ;
runcodeparams . lines = runcodelengths ;
runcodeparams . n_lines = 35 ;
runcodes = jbig2_build_huffman_table ( ctx , & runcodeparams ) ;
if ( runcodes == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "error constructing symbol id runcode table!" ) ;
code = - 1 ;
goto cleanup1 ;
}
symcodelengths = jbig2_new ( ctx , Jbig2HuffmanLine , SBNUMSYMS ) ;
if ( symcodelengths == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "memory allocation failure reading symbol ID huffman table!" ) ;
code = - 1 ;
goto cleanup1 ;
}
index = 0 ;
while ( index < SBNUMSYMS ) {
code = jbig2_huffman_get ( hs , runcodes , & err ) ;
if ( err != 0 || code < 0 || code >= 35 ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "error reading symbol ID huffman table!" ) ;
code = err ? err : - 1 ;
goto cleanup1 ;
}
if ( code < 32 ) {
len = code ;
range = 1 ;
}
else {
if ( code == 32 ) {
if ( index < 1 ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "error decoding symbol id table: run length with no antecedent!" ) ;
code = - 1 ;
goto cleanup1 ;
}
len = symcodelengths [ index - 1 ] . PREFLEN ;
}
else {
len = 0 ;
}
err = 0 ;
if ( code == 32 ) range = jbig2_huffman_get_bits ( hs , 2 , & err ) + 3 ;
else if ( code == 33 ) range = jbig2_huffman_get_bits ( hs , 3 , & err ) + 3 ;
else if ( code == 34 ) range = jbig2_huffman_get_bits ( hs , 7 , & err ) + 11 ;
if ( err < 0 ) goto cleanup1 ;
}
jbig2_error ( ctx , JBIG2_SEVERITY_DEBUG , segment -> number , " read runcode%d at index %d (length %d range %d)" , code , index , len , range ) ;
if ( index + range > SBNUMSYMS ) {
jbig2_error ( ctx , JBIG2_SEVERITY_WARNING , segment -> number , "runlength extends %d entries beyond the end of symbol id table!" , index + range - SBNUMSYMS ) ;
range = SBNUMSYMS - index ;
}
for ( r = 0 ;
r < range ;
r ++ ) {
symcodelengths [ index + r ] . PREFLEN = len ;
symcodelengths [ index + r ] . RANGELEN = 0 ;
symcodelengths [ index + r ] . RANGELOW = index + r ;
}
index += r ;
}
if ( index < SBNUMSYMS ) {
jbig2_error ( ctx , JBIG2_SEVERITY_WARNING , segment -> number , "runlength codes do not cover the available symbol set" ) ;
}
symcodeparams . HTOOB = 0 ;
symcodeparams . lines = symcodelengths ;
symcodeparams . n_lines = SBNUMSYMS ;
jbig2_huffman_skip ( hs ) ;
SBSYMCODES = jbig2_build_huffman_table ( ctx , & symcodeparams ) ;
cleanup1 : jbig2_free ( ctx -> allocator , symcodelengths ) ;
jbig2_release_huffman_table ( ctx , runcodes ) ;
if ( SBSYMCODES == NULL ) {
jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "could not construct Symbol ID huffman table!" ) ;
jbig2_huffman_free ( ctx , hs ) ;
return ( ( code != 0 ) ? code : - 1 ) ;
}
}
jbig2_image_clear ( ctx , image , params -> SBDEFPIXEL ) ;
if ( params -> SBHUFF ) {
STRIPT = jbig2_huffman_get ( hs , params -> SBHUFFDT , & code ) ;
}
else {
code = jbig2_arith_int_decode ( params -> IADT , as , & STRIPT ) ;
}
if ( code < 0 ) goto cleanup2 ;
STRIPT *= - ( params -> SBSTRIPS ) ;
FIRSTS = 0 ;
NINSTANCES = 0 ;
while ( NINSTANCES < params -> SBNUMINSTANCES ) {
if ( params -> SBHUFF ) {
DT = jbig2_huffman_get ( hs , params -> SBHUFFDT , & code ) ;
}
else {
code = jbig2_arith_int_decode ( params -> IADT , as , & DT ) ;
}
if ( code < 0 ) goto cleanup2 ;
DT *= params -> SBSTRIPS ;
STRIPT += DT ;
first_symbol = TRUE ;
for ( ;
;
) {
if ( first_symbol ) {
if ( params -> SBHUFF ) {
DFS = jbig2_huffman_get ( hs , params -> SBHUFFFS , & code ) ;
}
else {
code = jbig2_arith_int_decode ( params -> IAFS , as , & DFS ) ;
}
if ( code < 0 ) goto cleanup2 ;
FIRSTS += DFS ;
CURS = FIRSTS ;
first_symbol = FALSE ;
}
else {
if ( NINSTANCES > params -> SBNUMINSTANCES ) {
code = jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "too many NINSTANCES (%d) decoded" , NINSTANCES ) ;
break ;
}
if ( params -> SBHUFF ) {
IDS = jbig2_huffman_get ( hs , params -> SBHUFFDS , & code ) ;
}
else {
code = jbig2_arith_int_decode ( params -> IADS , as , & IDS ) ;
}
if ( code ) {
break ;
}
CURS += IDS + params -> SBDSOFFSET ;
}
if ( params -> SBSTRIPS == 1 ) {
CURT = 0 ;
}
else if ( params -> SBHUFF ) {
CURT = jbig2_huffman_get_bits ( hs , params -> LOGSBSTRIPS , & code ) ;
}
else {
code = jbig2_arith_int_decode ( params -> IAIT , as , & CURT ) ;
}
if ( code < 0 ) goto cleanup2 ;
T = STRIPT + CURT ;
if ( params -> SBHUFF ) {
ID = jbig2_huffman_get ( hs , SBSYMCODES , & code ) ;
}
else {
code = jbig2_arith_iaid_decode ( params -> IAID , as , ( int * ) & ID ) ;
}
if ( code < 0 ) goto cleanup2 ;
if ( ID >= SBNUMSYMS ) {
code = jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "symbol id out of range! (%d/%d)" , ID , SBNUMSYMS ) ;
goto cleanup2 ;
}
{
uint32_t id = ID ;
index = 0 ;
while ( id >= dicts [ index ] -> n_symbols ) id -= dicts [ index ++ ] -> n_symbols ;
IB = jbig2_image_clone ( ctx , dicts [ index ] -> glyphs [ id ] ) ;
if ( ! IB ) {
code = jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "missing glyph %d/%d!" , index , id ) ;
goto cleanup2 ;
}
}
if ( params -> SBREFINE ) {
if ( params -> SBHUFF ) {
RI = jbig2_huffman_get_bits ( hs , 1 , & code ) ;
}
else {
code = jbig2_arith_int_decode ( params -> IARI , as , & RI ) ;
}
if ( code < 0 ) goto cleanup2 ;
}
else {
RI = 0 ;
}
if ( RI ) {
Jbig2RefinementRegionParams rparams ;
Jbig2Image * IBO ;
int32_t RDW , RDH , RDX , RDY ;
Jbig2Image * refimage ;
int BMSIZE = 0 ;
int code1 = 0 ;
int code2 = 0 ;
int code3 = 0 ;
int code4 = 0 ;
int code5 = 0 ;
if ( ! params -> SBHUFF ) {
code1 = jbig2_arith_int_decode ( params -> IARDW , as , & RDW ) ;
code2 = jbig2_arith_int_decode ( params -> IARDH , as , & RDH ) ;
code3 = jbig2_arith_int_decode ( params -> IARDX , as , & RDX ) ;
code4 = jbig2_arith_int_decode ( params -> IARDY , as , & RDY ) ;
}
else {
RDW = jbig2_huffman_get ( hs , params -> SBHUFFRDW , & code1 ) ;
RDH = jbig2_huffman_get ( hs , params -> SBHUFFRDH , & code2 ) ;
RDX = jbig2_huffman_get ( hs , params -> SBHUFFRDX , & code3 ) ;
RDY = jbig2_huffman_get ( hs , params -> SBHUFFRDY , & code4 ) ;
BMSIZE = jbig2_huffman_get ( hs , params -> SBHUFFRSIZE , & code5 ) ;
jbig2_huffman_skip ( hs ) ;
}
if ( ( code1 < 0 ) || ( code2 < 0 ) || ( code3 < 0 ) || ( code4 < 0 ) || ( code5 < 0 ) ) {
code = jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "failed to decode data" ) ;
goto cleanup2 ;
}
IBO = IB ;
refimage = jbig2_image_new ( ctx , IBO -> width + RDW , IBO -> height + RDH ) ;
if ( refimage == NULL ) {
jbig2_image_release ( ctx , IBO ) ;
if ( params -> SBHUFF ) {
jbig2_release_huffman_table ( ctx , SBSYMCODES ) ;
}
return jbig2_error ( ctx , JBIG2_SEVERITY_FATAL , segment -> number , "couldn't allocate reference image" ) ;
}
jbig2_image_clear ( ctx , refimage , 0x00 ) ;
rparams . GRTEMPLATE = params -> SBRTEMPLATE ;
rparams . reference = IBO ;
rparams . DX = ( RDW >> 1 ) + RDX ;
rparams . DY = ( RDH >> 1 ) + RDY ;
rparams . TPGRON = 0 ;
memcpy ( rparams . grat , params -> sbrat , 4 ) ;
code = jbig2_decode_refinement_region ( ctx , segment , & rparams , as , refimage , GR_stats ) ;
if ( code < 0 ) {
jbig2_image_release ( ctx , refimage ) ;
goto cleanup2 ;
}
IB = refimage ;
jbig2_image_release ( ctx , IBO ) ;
if ( params -> SBHUFF ) {
jbig2_huffman_advance ( hs , BMSIZE ) ;
}
}
if ( ( ! params -> TRANSPOSED ) && ( params -> REFCORNER > 1 ) ) {
CURS += IB -> width - 1 ;
}
else if ( ( params -> TRANSPOSED ) && ! ( params -> REFCORNER & 1 ) ) {
CURS += IB -> height - 1 ;
}
S = CURS ;
if ( ! params -> TRANSPOSED ) {
switch ( params -> REFCORNER ) {
case JBIG2_CORNER_TOPLEFT : x = S ;
y = T ;
break ;
case JBIG2_CORNER_TOPRIGHT : x = S - IB -> width + 1 ;
y = T ;
break ;
case JBIG2_CORNER_BOTTOMLEFT : x = S ;
y = T - IB -> height + 1 ;
break ;
default : case JBIG2_CORNER_BOTTOMRIGHT : x = S - IB -> width + 1 ;
y = T - IB -> height + 1 ;
break ;
}
}
else {
switch ( params -> REFCORNER ) {
case JBIG2_CORNER_TOPLEFT : x = T ;
y = S ;
break ;
case JBIG2_CORNER_TOPRIGHT : x = T - IB -> width + 1 ;
y = S ;
break ;
case JBIG2_CORNER_BOTTOMLEFT : x = T ;
y = S - IB -> height + 1 ;
break ;
default : case JBIG2_CORNER_BOTTOMRIGHT : x = T - IB -> width + 1 ;
y = S - IB -> height + 1 ;
break ;
}
}
# ifdef JBIG2_DEBUG jbig2_error ( ctx , JBIG2_SEVERITY_DEBUG , segment -> number , "composing glyph id %d: %dx%d @ (%d,%d) symbol %d/%d" , ID , IB -> width , IB -> height , x , y , NINSTANCES + 1 , params -> SBNUMINSTANCES ) ;
# endif code = jbig2_image_compose ( ctx , image , IB , x , y , params -> SBCOMBOP ) ;
if ( code < 0 ) {
jbig2_image_release ( ctx , IB ) ;
goto cleanup2 ;
}
if ( ( ! params -> TRANSPOSED ) && ( params -> REFCORNER < 2 ) ) {
CURS += IB -> width - 1 ;
}
else if ( ( params -> TRANSPOSED ) && ( params -> REFCORNER & 1 ) ) {
CURS += IB -> height - 1 ;
}
NINSTANCES ++ ;
jbig2_image_release ( ctx , IB ) ;
}
}
cleanup2 : if ( params -> SBHUFF ) {
jbig2_release_huffman_table ( ctx , SBSYMCODES ) ;
}
jbig2_huffman_free ( ctx , hs ) ;
return code ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_inode_getattr ( const struct path * path ) {
return path_has_perm ( current_cred ( ) , path , FILE__GETATTR ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * * create_argv_help ( const char * path , const char * command , const char * subcommand ) {
char * * req_argv = NULL ;
const char * program ;
if ( subcommand == NULL ) req_argv = xcalloc ( 3 , sizeof ( char * ) ) ;
else req_argv = xcalloc ( 4 , sizeof ( char * ) ) ;
program = strrchr ( path , '/' ) ;
if ( program == NULL ) program = path ;
else program ++ ;
req_argv [ 0 ] = xstrdup ( program ) ;
req_argv [ 1 ] = xstrdup ( command ) ;
if ( subcommand == NULL ) req_argv [ 2 ] = NULL ;
else {
req_argv [ 2 ] = xstrdup ( subcommand ) ;
req_argv [ 3 ] = NULL ;
}
return req_argv ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int get_ue_code ( GetBitContext * gb , int order ) {
if ( order ) {
int ret = get_ue_golomb ( gb ) << order ;
return ret + get_bits ( gb , order ) ;
}
return get_ue_golomb ( gb ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void mp_get_code ( MotionPixelsContext * mp , GetBitContext * gb , int size , int code ) {
while ( get_bits1 ( gb ) ) {
++ size ;
if ( size > mp -> max_codes_bits ) {
av_log ( mp -> avctx , AV_LOG_ERROR , "invalid code size %d/%d\n" , size , mp -> max_codes_bits ) ;
return ;
}
code <<= 1 ;
mp_get_code ( mp , gb , size , code + 1 ) ;
}
if ( mp -> current_codes_count >= MAX_HUFF_CODES ) {
av_log ( mp -> avctx , AV_LOG_ERROR , "too many codes\n" ) ;
return ;
}
mp -> codes [ mp -> current_codes_count ] . code = code ;
mp -> codes [ mp -> current_codes_count ++ ] . size = size ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int parse_CRangeCategSpec ( tvbuff_t * tvb , int offset , proto_tree * parent_tree , proto_tree * pad_tree , const char * fmt , ... ) {
proto_item * item ;
proto_tree * tree ;
va_list ap ;
unsigned i ;
const char * txt ;
guint32 cRange ;
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_CRangeCategSpec , & item , txt ) ;
offset = parse_lcid ( tvb , offset , tree , "lcid" ) ;
cRange = tvb_get_letohl ( tvb , offset ) ;
proto_tree_add_uint ( tree , hf_mswsp_crangecategspec_crange , tvb , offset , 4 , cRange ) ;
offset += 4 ;
for ( i = 0 ;
i < cRange ;
i ++ ) {
offset = parse_RANGEBOUNDARY ( tvb , offset , tree , pad_tree , "aRangeBegin[%u]" , i ) ;
}
proto_item_set_end ( item , tvb , offset ) ;
return offset ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
struct VP8_COMP * vp8_create_compressor ( VP8_CONFIG * oxcf ) {
int i ;
VP8_COMP * cpi ;
VP8_COMMON * cm ;
cpi = vpx_memalign ( 32 , sizeof ( VP8_COMP ) ) ;
if ( ! cpi ) return 0 ;
cm = & cpi -> common ;
vpx_memset ( cpi , 0 , sizeof ( VP8_COMP ) ) ;
if ( setjmp ( cm -> error . jmp ) ) {
cpi -> common . error . setjmp = 0 ;
vp8_remove_compressor ( & cpi ) ;
return 0 ;
}
cpi -> common . error . setjmp = 1 ;
CHECK_MEM_ERROR ( cpi -> mb . ss , vpx_calloc ( sizeof ( search_site ) , ( MAX_MVSEARCH_STEPS * 8 ) + 1 ) ) ;
vp8_create_common ( & cpi -> common ) ;
init_config ( cpi , oxcf ) ;
memcpy ( cpi -> base_skip_false_prob , vp8cx_base_skip_false_prob , sizeof ( vp8cx_base_skip_false_prob ) ) ;
cpi -> common . current_video_frame = 0 ;
cpi -> temporal_pattern_counter = 0 ;
cpi -> kf_overspend_bits = 0 ;
cpi -> kf_bitrate_adjustment = 0 ;
cpi -> frames_till_gf_update_due = 0 ;
cpi -> gf_overspend_bits = 0 ;
cpi -> non_gf_bitrate_adjustment = 0 ;
cpi -> prob_last_coded = 128 ;
cpi -> prob_gf_coded = 128 ;
cpi -> prob_intra_coded = 63 ;
cpi -> recent_ref_frame_usage [ INTRA_FRAME ] = 1 ;
cpi -> recent_ref_frame_usage [ LAST_FRAME ] = 1 ;
cpi -> recent_ref_frame_usage [ GOLDEN_FRAME ] = 1 ;
cpi -> recent_ref_frame_usage [ ALTREF_FRAME ] = 1 ;
cpi -> common . ref_frame_sign_bias [ ALTREF_FRAME ] = 1 ;
cpi -> twopass . gf_decay_rate = 0 ;
cpi -> baseline_gf_interval = DEFAULT_GF_INTERVAL ;
cpi -> gold_is_last = 0 ;
cpi -> alt_is_last = 0 ;
cpi -> gold_is_alt = 0 ;
cpi -> active_map_enabled = 0 ;
# if 0 if ( cpi -> pass == 0 ) {
cpi -> one_pass_frame_index = 0 ;
for ( i = 0 ;
i < MAX_LAG_BUFFERS ;
i ++ ) {
cpi -> one_pass_frame_stats [ i ] . frames_so_far = 0 ;
cpi -> one_pass_frame_stats [ i ] . frame_intra_error = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_coded_error = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_pcnt_inter = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_pcnt_motion = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_mvr = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_mvr_abs = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_mvc = 0.0 ;
cpi -> one_pass_frame_stats [ i ] . frame_mvc_abs = 0.0 ;
}
}
# endif cpi -> cyclic_refresh_mode_enabled = cpi -> oxcf . error_resilient_mode ;
cpi -> cyclic_refresh_mode_max_mbs_perframe = ( cpi -> common . mb_rows * cpi -> common . mb_cols ) / 5 ;
if ( cpi -> oxcf . number_of_layers == 1 ) {
cpi -> cyclic_refresh_mode_max_mbs_perframe = ( cpi -> common . mb_rows * cpi -> common . mb_cols ) / 20 ;
}
else if ( cpi -> oxcf . number_of_layers == 2 ) {
cpi -> cyclic_refresh_mode_max_mbs_perframe = ( cpi -> common . mb_rows * cpi -> common . mb_cols ) / 10 ;
}
cpi -> cyclic_refresh_mode_index = 0 ;
cpi -> cyclic_refresh_q = 32 ;
if ( cpi -> cyclic_refresh_mode_enabled ) {
CHECK_MEM_ERROR ( cpi -> cyclic_refresh_map , vpx_calloc ( ( cpi -> common . mb_rows * cpi -> common . mb_cols ) , 1 ) ) ;
}
else cpi -> cyclic_refresh_map = ( signed char * ) NULL ;
CHECK_MEM_ERROR ( cpi -> consec_zero_last , vpx_calloc ( cpi -> common . mb_rows * cpi -> common . mb_cols , 1 ) ) ;
# ifdef VP8_ENTROPY_STATS init_context_counters ( ) ;
# endif cpi -> activity_avg = 90 << 12 ;
cpi -> frames_since_key = 8 ;
cpi -> key_frame_frequency = cpi -> oxcf . key_freq ;
cpi -> this_key_frame_forced = 0 ;
cpi -> next_key_frame_forced = 0 ;
cpi -> source_alt_ref_pending = 0 ;
cpi -> source_alt_ref_active = 0 ;
cpi -> common . refresh_alt_ref_frame = 0 ;
cpi -> b_calculate_psnr = CONFIG_INTERNAL_STATS ;
# if CONFIG_INTERNAL_STATS cpi -> b_calculate_ssimg = 0 ;
cpi -> count = 0 ;
cpi -> bytes = 0 ;
if ( cpi -> b_calculate_psnr ) {
cpi -> total_sq_error = 0.0 ;
cpi -> total_sq_error2 = 0.0 ;
cpi -> total_y = 0.0 ;
cpi -> total_u = 0.0 ;
cpi -> total_v = 0.0 ;
cpi -> total = 0.0 ;
cpi -> totalp_y = 0.0 ;
cpi -> totalp_u = 0.0 ;
cpi -> totalp_v = 0.0 ;
cpi -> totalp = 0.0 ;
cpi -> tot_recode_hits = 0 ;
cpi -> summed_quality = 0 ;
cpi -> summed_weights = 0 ;
}
if ( cpi -> b_calculate_ssimg ) {
cpi -> total_ssimg_y = 0 ;
cpi -> total_ssimg_u = 0 ;
cpi -> total_ssimg_v = 0 ;
cpi -> total_ssimg_all = 0 ;
}
# endif cpi -> first_time_stamp_ever = 0x7FFFFFFF ;
cpi -> frames_till_gf_update_due = 0 ;
cpi -> key_frame_count = 1 ;
cpi -> ni_av_qi = cpi -> oxcf . worst_allowed_q ;
cpi -> ni_tot_qi = 0 ;
cpi -> ni_frames = 0 ;
cpi -> total_byte_count = 0 ;
cpi -> drop_frame = 0 ;
cpi -> rate_correction_factor = 1.0 ;
cpi -> key_frame_rate_correction_factor = 1.0 ;
cpi -> gf_rate_correction_factor = 1.0 ;
cpi -> twopass . est_max_qcorrection_factor = 1.0 ;
for ( i = 0 ;
i < KEY_FRAME_CONTEXT ;
i ++ ) {
cpi -> prior_key_frame_distance [ i ] = ( int ) cpi -> output_framerate ;
}
# ifdef OUTPUT_YUV_SRC yuv_file = fopen ( "bd.yuv" , "ab" ) ;
# endif # ifdef OUTPUT_YUV_DENOISED yuv_denoised_file = fopen ( "denoised.yuv" , "ab" ) ;
# endif # if 0 framepsnr = fopen ( "framepsnr.stt" , "a" ) ;
kf_list = fopen ( "kf_list.stt" , "w" ) ;
# endif cpi -> output_pkt_list = oxcf -> output_pkt_list ;
# if ! ( CONFIG_REALTIME_ONLY ) if ( cpi -> pass == 1 ) {
vp8_init_first_pass ( cpi ) ;
}
else if ( cpi -> pass == 2 ) {
size_t packet_sz = sizeof ( FIRSTPASS_STATS ) ;
int packets = ( int ) ( oxcf -> two_pass_stats_in . sz / packet_sz ) ;
cpi -> twopass . stats_in_start = oxcf -> two_pass_stats_in . buf ;
cpi -> twopass . stats_in = cpi -> twopass . stats_in_start ;
cpi -> twopass . stats_in_end = ( void * ) ( ( char * ) cpi -> twopass . stats_in + ( packets - 1 ) * packet_sz ) ;
vp8_init_second_pass ( cpi ) ;
}
# endif if ( cpi -> compressor_speed == 2 ) {
cpi -> avg_encode_time = 0 ;
cpi -> avg_pick_mode_time = 0 ;
}
vp8_set_speed_features ( cpi ) ;
for ( i = 0 ;
i < MAX_MODES ;
i ++ ) {
cpi -> mb . rd_thresh_mult [ i ] = 128 ;
}
# ifdef VP8_ENTROPY_STATS init_mv_ref_counts ( ) ;
# endif # if CONFIG_MULTITHREAD if ( vp8cx_create_encoder_threads ( cpi ) ) {
vp8_remove_compressor ( & cpi ) ;
return 0 ;
}
# endif cpi -> fn_ptr [ BLOCK_16X16 ] . sdf = vp8_sad16x16 ;
cpi -> fn_ptr [ BLOCK_16X16 ] . vf = vp8_variance16x16 ;
cpi -> fn_ptr [ BLOCK_16X16 ] . svf = vp8_sub_pixel_variance16x16 ;
cpi -> fn_ptr [ BLOCK_16X16 ] . svf_halfpix_h = vp8_variance_halfpixvar16x16_h ;
cpi -> fn_ptr [ BLOCK_16X16 ] . svf_halfpix_v = vp8_variance_halfpixvar16x16_v ;
cpi -> fn_ptr [ BLOCK_16X16 ] . svf_halfpix_hv = vp8_variance_halfpixvar16x16_hv ;
cpi -> fn_ptr [ BLOCK_16X16 ] . sdx3f = vp8_sad16x16x3 ;
cpi -> fn_ptr [ BLOCK_16X16 ] . sdx8f = vp8_sad16x16x8 ;
cpi -> fn_ptr [ BLOCK_16X16 ] . sdx4df = vp8_sad16x16x4d ;
cpi -> fn_ptr [ BLOCK_16X8 ] . sdf = vp8_sad16x8 ;
cpi -> fn_ptr [ BLOCK_16X8 ] . vf = vp8_variance16x8 ;
cpi -> fn_ptr [ BLOCK_16X8 ] . svf = vp8_sub_pixel_variance16x8 ;
cpi -> fn_ptr [ BLOCK_16X8 ] . svf_halfpix_h = NULL ;
cpi -> fn_ptr [ BLOCK_16X8 ] . svf_halfpix_v = NULL ;
cpi -> fn_ptr [ BLOCK_16X8 ] . svf_halfpix_hv = NULL ;
cpi -> fn_ptr [ BLOCK_16X8 ] . sdx3f = vp8_sad16x8x3 ;
cpi -> fn_ptr [ BLOCK_16X8 ] . sdx8f = vp8_sad16x8x8 ;
cpi -> fn_ptr [ BLOCK_16X8 ] . sdx4df = vp8_sad16x8x4d ;
cpi -> fn_ptr [ BLOCK_8X16 ] . sdf = vp8_sad8x16 ;
cpi -> fn_ptr [ BLOCK_8X16 ] . vf = vp8_variance8x16 ;
cpi -> fn_ptr [ BLOCK_8X16 ] . svf = vp8_sub_pixel_variance8x16 ;
cpi -> fn_ptr [ BLOCK_8X16 ] . svf_halfpix_h = NULL ;
cpi -> fn_ptr [ BLOCK_8X16 ] . svf_halfpix_v = NULL ;
cpi -> fn_ptr [ BLOCK_8X16 ] . svf_halfpix_hv = NULL ;
cpi -> fn_ptr [ BLOCK_8X16 ] . sdx3f = vp8_sad8x16x3 ;
cpi -> fn_ptr [ BLOCK_8X16 ] . sdx8f = vp8_sad8x16x8 ;
cpi -> fn_ptr [ BLOCK_8X16 ] . sdx4df = vp8_sad8x16x4d ;
cpi -> fn_ptr [ BLOCK_8X8 ] . sdf = vp8_sad8x8 ;
cpi -> fn_ptr [ BLOCK_8X8 ] . vf = vp8_variance8x8 ;
cpi -> fn_ptr [ BLOCK_8X8 ] . svf = vp8_sub_pixel_variance8x8 ;
cpi -> fn_ptr [ BLOCK_8X8 ] . svf_halfpix_h = NULL ;
cpi -> fn_ptr [ BLOCK_8X8 ] . svf_halfpix_v = NULL ;
cpi -> fn_ptr [ BLOCK_8X8 ] . svf_halfpix_hv = NULL ;
cpi -> fn_ptr [ BLOCK_8X8 ] . sdx3f = vp8_sad8x8x3 ;
cpi -> fn_ptr [ BLOCK_8X8 ] . sdx8f = vp8_sad8x8x8 ;
cpi -> fn_ptr [ BLOCK_8X8 ] . sdx4df = vp8_sad8x8x4d ;
cpi -> fn_ptr [ BLOCK_4X4 ] . sdf = vp8_sad4x4 ;
cpi -> fn_ptr [ BLOCK_4X4 ] . vf = vp8_variance4x4 ;
cpi -> fn_ptr [ BLOCK_4X4 ] . svf = vp8_sub_pixel_variance4x4 ;
cpi -> fn_ptr [ BLOCK_4X4 ] . svf_halfpix_h = NULL ;
cpi -> fn_ptr [ BLOCK_4X4 ] . svf_halfpix_v = NULL ;
cpi -> fn_ptr [ BLOCK_4X4 ] . svf_halfpix_hv = NULL ;
cpi -> fn_ptr [ BLOCK_4X4 ] . sdx3f = vp8_sad4x4x3 ;
cpi -> fn_ptr [ BLOCK_4X4 ] . sdx8f = vp8_sad4x4x8 ;
cpi -> fn_ptr [ BLOCK_4X4 ] . sdx4df = vp8_sad4x4x4d ;
# if ARCH_X86 || ARCH_X86_64 cpi -> fn_ptr [ BLOCK_16X16 ] . copymem = vp8_copy32xn ;
cpi -> fn_ptr [ BLOCK_16X8 ] . copymem = vp8_copy32xn ;
cpi -> fn_ptr [ BLOCK_8X16 ] . copymem = vp8_copy32xn ;
cpi -> fn_ptr [ BLOCK_8X8 ] . copymem = vp8_copy32xn ;
cpi -> fn_ptr [ BLOCK_4X4 ] . copymem = vp8_copy32xn ;
# endif cpi -> full_search_sad = vp8_full_search_sad ;
cpi -> diamond_search_sad = vp8_diamond_search_sad ;
cpi -> refining_search_sad = vp8_refining_search_sad ;
cpi -> mb . error_bins [ 0 ] = cpi -> common . MBs ;
vp8cx_init_quantizer ( cpi ) ;
vp8_loop_filter_init ( cm ) ;
cpi -> common . error . setjmp = 0 ;
# if CONFIG_MULTI_RES_ENCODING if ( cpi -> oxcf . mr_encoder_id > 0 ) vp8_cal_low_res_mb_cols ( cpi ) ;
# endif cpi -> mb . mvcost [ 0 ] = & cpi -> rd_costs . mvcosts [ 0 ] [ mv_max + 1 ] ;
cpi -> mb . mvcost [ 1 ] = & cpi -> rd_costs . mvcosts [ 1 ] [ mv_max + 1 ] ;
cpi -> mb . mvsadcost [ 0 ] = & cpi -> rd_costs . mvsadcosts [ 0 ] [ mvfp_max + 1 ] ;
cpi -> mb . mvsadcost [ 1 ] = & cpi -> rd_costs . mvsadcosts [ 1 ] [ mvfp_max + 1 ] ;
cal_mvsadcosts ( cpi -> mb . mvsadcost ) ;
cpi -> mb . mbmode_cost = cpi -> rd_costs . mbmode_cost ;
cpi -> mb . intra_uv_mode_cost = cpi -> rd_costs . intra_uv_mode_cost ;
cpi -> mb . bmode_costs = cpi -> rd_costs . bmode_costs ;
cpi -> mb . inter_bmode_costs = cpi -> rd_costs . inter_bmode_costs ;
cpi -> mb . token_costs = cpi -> rd_costs . token_costs ;
vp8_setup_block_ptrs ( & cpi -> mb ) ;
vp8_setup_block_dptrs ( & cpi -> mb . e_mbd ) ;
return cpi ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_wl4435_2 ( ) {
MYSQL_STMT * stmt ;
int i ;
int rc ;
char query [ MAX_TEST_QUERY_LENGTH ] ;
myheader ( "test_wl4435_2" ) ;
mct_start_logging ( "test_wl4435_2" ) ;
for ( i = 0 ;
i < 10 ;
++ i ) {
rc = mysql_query ( mysql , "DROP PROCEDURE IF EXISTS p1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE PROCEDURE p1()" "BEGIN " " SELECT 1;
" " SELECT 2, 3 UNION SELECT 4, 5;
" " SELECT 6, 7, 8;
" "END" ) ;
myquery ( rc ) ;
strmov ( query , "CALL p1()" ) ;
stmt = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
mysql_stmt_close ( stmt ) ;
rc = mysql_commit ( mysql ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP PROCEDURE p1" ) ;
myquery ( rc ) ;
}
mct_close_log ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * ext_t_1_wml_10 ( tvbuff_t * tvb , guint32 value , guint32 str_tbl ) {
char * str = wmem_strdup_printf ( wmem_packet_scope ( ) , "Variable substitution - unescaped: '%s'" , tvb_get_const_stringz ( tvb , str_tbl + value , NULL ) ) ;
return str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
err_status_t srtp_add_stream ( srtp_t session , const srtp_policy_t * policy ) {
err_status_t status ;
srtp_stream_t tmp ;
if ( ( session == NULL ) || ( policy == NULL ) || ( policy -> key == NULL ) ) return err_status_bad_param ;
status = srtp_stream_alloc ( & tmp , policy ) ;
if ( status ) {
return status ;
}
status = srtp_stream_init ( tmp , policy ) ;
if ( status ) {
crypto_free ( tmp ) ;
return status ;
}
switch ( policy -> ssrc . type ) {
case ( ssrc_any_outbound ) : if ( session -> stream_template ) {
return err_status_bad_param ;
}
session -> stream_template = tmp ;
session -> stream_template -> direction = dir_srtp_sender ;
break ;
case ( ssrc_any_inbound ) : if ( session -> stream_template ) {
return err_status_bad_param ;
}
session -> stream_template = tmp ;
session -> stream_template -> direction = dir_srtp_receiver ;
break ;
case ( ssrc_specific ) : tmp -> next = session -> stream_list ;
session -> stream_list = tmp ;
break ;
case ( ssrc_undefined ) : default : crypto_free ( tmp ) ;
return err_status_bad_param ;
}
return err_status_ok ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( VirtualKeyboardBrowserTest , IsKeyboardLoaded ) {
content : : RenderViewHost * keyboard_rvh = GetKeyboardRenderViewHost ( ) ;
ASSERT_TRUE ( keyboard_rvh ) ;
bool loaded = false ;
std : : string script = "!!chrome.virtualKeyboardPrivate" ;
EXPECT_TRUE ( content : : ExecuteScriptAndExtractBool ( keyboard_rvh , "window.domAutomationController.send(" + script + ");
" , & loaded ) ) ;
ASSERT_TRUE ( loaded ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ohci_die ( OHCIState * ohci ) {
OHCIPCIState * dev = container_of ( ohci , OHCIPCIState , state ) ;
trace_usb_ohci_die ( ) ;
ohci_set_interrupt ( ohci , OHCI_INTR_UE ) ;
ohci_bus_stop ( ohci ) ;
pci_set_word ( dev -> parent_obj . config + PCI_STATUS , PCI_STATUS_DETECTED_PARITY ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void t38_add_address ( packet_info * pinfo , address * addr , int port , int other_port , const gchar * setup_method , guint32 setup_frame_number ) {
address null_addr ;
conversation_t * p_conversation ;
t38_conv * p_conversation_data = NULL ;
if ( ( pinfo -> fd -> flags . visited ) || ( t38_udp_handle == NULL ) ) {
return ;
}
SET_ADDRESS ( & null_addr , AT_NONE , 0 , NULL ) ;
p_conversation = find_conversation ( setup_frame_number , addr , & null_addr , PT_UDP , port , other_port , NO_ADDR_B | ( ! other_port ? NO_PORT_B : 0 ) ) ;
if ( ! p_conversation || p_conversation -> setup_frame != setup_frame_number ) {
p_conversation = conversation_new ( setup_frame_number , addr , & null_addr , PT_UDP , ( guint32 ) port , ( guint32 ) other_port , NO_ADDR2 | ( ! other_port ? NO_PORT2 : 0 ) ) ;
}
conversation_set_dissector ( p_conversation , t38_udp_handle ) ;
p_conversation_data = ( t38_conv * ) conversation_get_proto_data ( p_conversation , proto_t38 ) ;
if ( ! p_conversation_data ) {
p_conversation_data = wmem_new ( wmem_file_scope ( ) , t38_conv ) ;
conversation_add_proto_data ( p_conversation , proto_t38 , p_conversation_data ) ;
}
g_strlcpy ( p_conversation_data -> setup_method , setup_method , MAX_T38_SETUP_METHOD_SIZE ) ;
p_conversation_data -> setup_frame_number = setup_frame_number ;
p_conversation_data -> src_t38_info . reass_ID = 0 ;
p_conversation_data -> src_t38_info . reass_start_seqnum = - 1 ;
p_conversation_data -> src_t38_info . reass_data_type = 0 ;
p_conversation_data -> src_t38_info . last_seqnum = - 1 ;
p_conversation_data -> src_t38_info . packet_lost = 0 ;
p_conversation_data -> src_t38_info . burst_lost = 0 ;
p_conversation_data -> src_t38_info . time_first_t4_data = 0 ;
p_conversation_data -> src_t38_info . additional_hdlc_data_field_counter = 0 ;
p_conversation_data -> src_t38_info . seqnum_prev_data_field = - 1 ;
p_conversation_data -> dst_t38_info . reass_ID = 0 ;
p_conversation_data -> dst_t38_info . reass_start_seqnum = - 1 ;
p_conversation_data -> dst_t38_info . reass_data_type = 0 ;
p_conversation_data -> dst_t38_info . last_seqnum = - 1 ;
p_conversation_data -> dst_t38_info . packet_lost = 0 ;
p_conversation_data -> dst_t38_info . burst_lost = 0 ;
p_conversation_data -> dst_t38_info . time_first_t4_data = 0 ;
p_conversation_data -> dst_t38_info . additional_hdlc_data_field_counter = 0 ;
p_conversation_data -> dst_t38_info . seqnum_prev_data_field = - 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
MSG_PROCESS_RETURN tls_process_cert_verify ( SSL * s , PACKET * pkt ) {
EVP_PKEY * pkey = NULL ;
const unsigned char * sig , * data ;
# ifndef OPENSSL_NO_GOST unsigned char * gost_data = NULL ;
# endif int al , ret = MSG_PROCESS_ERROR ;
int type = 0 , j ;
unsigned int len ;
X509 * peer ;
const EVP_MD * md = NULL ;
long hdatalen = 0 ;
void * hdata ;
EVP_MD_CTX * mctx = EVP_MD_CTX_new ( ) ;
if ( mctx == NULL ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , ERR_R_MALLOC_FAILURE ) ;
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
peer = s -> session -> peer ;
pkey = X509_get0_pubkey ( peer ) ;
type = X509_certificate_type ( peer , pkey ) ;
if ( ! ( type & EVP_PKT_SIGN ) ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , SSL_R_SIGNATURE_FOR_NON_SIGNING_CERTIFICATE ) ;
al = SSL_AD_ILLEGAL_PARAMETER ;
goto f_err ;
}
# ifndef OPENSSL_NO_GOST if ( PACKET_remaining ( pkt ) == 64 && EVP_PKEY_id ( pkey ) == NID_id_GostR3410_2001 ) {
len = 64 ;
}
else # endif {
if ( SSL_USE_SIGALGS ( s ) ) {
int rv ;
if ( ! PACKET_get_bytes ( pkt , & sig , 2 ) ) {
al = SSL_AD_DECODE_ERROR ;
goto f_err ;
}
rv = tls12_check_peer_sigalg ( & md , s , sig , pkey ) ;
if ( rv == - 1 ) {
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
else if ( rv == 0 ) {
al = SSL_AD_DECODE_ERROR ;
goto f_err ;
}
# ifdef SSL_DEBUG fprintf ( stderr , "USING TLSv1.2 HASH %s\n" , EVP_MD_name ( md ) ) ;
# endif }
else {
int idx = ssl_cert_type ( NULL , pkey ) ;
if ( idx >= 0 ) md = s -> s3 -> tmp . md [ idx ] ;
if ( md == NULL ) {
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
}
if ( ! PACKET_get_net_2 ( pkt , & len ) ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , SSL_R_LENGTH_MISMATCH ) ;
al = SSL_AD_DECODE_ERROR ;
goto f_err ;
}
}
j = EVP_PKEY_size ( pkey ) ;
if ( ( ( int ) len > j ) || ( ( int ) PACKET_remaining ( pkt ) > j ) || ( PACKET_remaining ( pkt ) == 0 ) ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , SSL_R_WRONG_SIGNATURE_SIZE ) ;
al = SSL_AD_DECODE_ERROR ;
goto f_err ;
}
if ( ! PACKET_get_bytes ( pkt , & data , len ) ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , SSL_R_LENGTH_MISMATCH ) ;
al = SSL_AD_DECODE_ERROR ;
goto f_err ;
}
hdatalen = BIO_get_mem_data ( s -> s3 -> handshake_buffer , & hdata ) ;
if ( hdatalen <= 0 ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , ERR_R_INTERNAL_ERROR ) ;
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
# ifdef SSL_DEBUG fprintf ( stderr , "Using client verify alg %s\n" , EVP_MD_name ( md ) ) ;
# endif if ( ! EVP_VerifyInit_ex ( mctx , md , NULL ) || ! EVP_VerifyUpdate ( mctx , hdata , hdatalen ) ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , ERR_R_EVP_LIB ) ;
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
# ifndef OPENSSL_NO_GOST {
int pktype = EVP_PKEY_id ( pkey ) ;
if ( pktype == NID_id_GostR3410_2001 || pktype == NID_id_GostR3410_2012_256 || pktype == NID_id_GostR3410_2012_512 ) {
if ( ( gost_data = OPENSSL_malloc ( len ) ) == NULL ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , ERR_R_MALLOC_FAILURE ) ;
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
BUF_reverse ( gost_data , data , len ) ;
data = gost_data ;
}
}
# endif if ( s -> version == SSL3_VERSION && ! EVP_MD_CTX_ctrl ( mctx , EVP_CTRL_SSL3_MASTER_SECRET , s -> session -> master_key_length , s -> session -> master_key ) ) {
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , ERR_R_EVP_LIB ) ;
al = SSL_AD_INTERNAL_ERROR ;
goto f_err ;
}
if ( EVP_VerifyFinal ( mctx , data , len , pkey ) <= 0 ) {
al = SSL_AD_DECRYPT_ERROR ;
SSLerr ( SSL_F_TLS_PROCESS_CERT_VERIFY , SSL_R_BAD_SIGNATURE ) ;
goto f_err ;
}
ret = MSG_PROCESS_CONTINUE_PROCESSING ;
if ( 0 ) {
f_err : ssl3_send_alert ( s , SSL3_AL_FATAL , al ) ;
ossl_statem_set_error ( s ) ;
}
BIO_free ( s -> s3 -> handshake_buffer ) ;
s -> s3 -> handshake_buffer = NULL ;
EVP_MD_CTX_free ( mctx ) ;
# ifndef OPENSSL_NO_GOST OPENSSL_free ( gost_data ) ;
# endif return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_file_send_sigiotask ( struct task_struct * tsk , struct fown_struct * fown , int signum ) {
struct file * file ;
u32 sid = task_sid ( tsk ) ;
u32 perm ;
struct file_security_struct * fsec ;
file = container_of ( fown , struct file , f_owner ) ;
fsec = file -> f_security ;
if ( ! signum ) perm = signal_to_av ( SIGIO ) ;
else perm = signal_to_av ( signum ) ;
return avc_has_perm ( fsec -> fown_sid , sid , SECCLASS_PROCESS , perm , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_frame_header ( ProresContext * ctx , const uint8_t * buf , const int data_size , AVCodecContext * avctx ) {
int hdr_size , version , width , height , flags ;
const uint8_t * ptr ;
hdr_size = AV_RB16 ( buf ) ;
if ( hdr_size > data_size ) {
av_log ( avctx , AV_LOG_ERROR , "frame data too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
version = AV_RB16 ( buf + 2 ) ;
if ( version >= 2 ) {
av_log ( avctx , AV_LOG_ERROR , "unsupported header version: %d\n" , version ) ;
return AVERROR_INVALIDDATA ;
}
width = AV_RB16 ( buf + 8 ) ;
height = AV_RB16 ( buf + 10 ) ;
if ( width != avctx -> width || height != avctx -> height ) {
av_log ( avctx , AV_LOG_ERROR , "picture dimension changed: old: %d x %d, new: %d x %d\n" , avctx -> width , avctx -> height , width , height ) ;
return AVERROR_INVALIDDATA ;
}
ctx -> frame_type = ( buf [ 12 ] >> 2 ) & 3 ;
if ( ctx -> frame_type > 2 ) {
av_log ( avctx , AV_LOG_ERROR , "unsupported frame type: %d\n" , ctx -> frame_type ) ;
return AVERROR_INVALIDDATA ;
}
ctx -> chroma_factor = ( buf [ 12 ] >> 6 ) & 3 ;
ctx -> mb_chroma_factor = ctx -> chroma_factor + 2 ;
ctx -> num_chroma_blocks = ( 1 << ctx -> chroma_factor ) >> 1 ;
switch ( ctx -> chroma_factor ) {
case 2 : avctx -> pix_fmt = AV_PIX_FMT_YUV422P10 ;
break ;
case 3 : avctx -> pix_fmt = AV_PIX_FMT_YUV444P10 ;
break ;
default : av_log ( avctx , AV_LOG_ERROR , "unsupported picture format: %d\n" , ctx -> pic_format ) ;
return AVERROR_INVALIDDATA ;
}
if ( ctx -> scantable_type != ctx -> frame_type ) {
if ( ! ctx -> frame_type ) ff_init_scantable ( ctx -> dsp . idct_permutation , & ctx -> scantable , ff_prores_progressive_scan ) ;
else ff_init_scantable ( ctx -> dsp . idct_permutation , & ctx -> scantable , ff_prores_interlaced_scan ) ;
ctx -> scantable_type = ctx -> frame_type ;
}
if ( ctx -> frame_type ) {
ctx -> frame -> interlaced_frame = 1 ;
ctx -> frame -> top_field_first = ctx -> frame_type & 1 ;
}
else {
ctx -> frame -> interlaced_frame = 0 ;
}
avctx -> color_primaries = buf [ 14 ] ;
avctx -> color_trc = buf [ 15 ] ;
avctx -> colorspace = buf [ 16 ] ;
ctx -> alpha_info = buf [ 17 ] & 0xf ;
if ( ctx -> alpha_info ) av_log_missing_feature ( avctx , "Alpha channel" , 0 ) ;
ctx -> qmat_changed = 0 ;
ptr = buf + 20 ;
flags = buf [ 19 ] ;
if ( flags & 2 ) {
if ( ptr - buf > hdr_size - 64 ) {
av_log ( avctx , AV_LOG_ERROR , "header data too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( memcmp ( ctx -> qmat_luma , ptr , 64 ) ) {
memcpy ( ctx -> qmat_luma , ptr , 64 ) ;
ctx -> qmat_changed = 1 ;
}
ptr += 64 ;
}
else {
memset ( ctx -> qmat_luma , 4 , 64 ) ;
ctx -> qmat_changed = 1 ;
}
if ( flags & 1 ) {
if ( ptr - buf > hdr_size - 64 ) {
av_log ( avctx , AV_LOG_ERROR , "header data too small\n" ) ;
return - 1 ;
}
if ( memcmp ( ctx -> qmat_chroma , ptr , 64 ) ) {
memcpy ( ctx -> qmat_chroma , ptr , 64 ) ;
ctx -> qmat_changed = 1 ;
}
}
else {
memset ( ctx -> qmat_chroma , 4 , 64 ) ;
ctx -> qmat_changed = 1 ;
}
return hdr_size ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_IntegrityCapability ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_IntegrityCapability , IntegrityCapability_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void q931_init ( void ) {
reassembly_table_init ( & q931_reassembly_table , & addresses_reassembly_table_functions ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void remove_tap_listener_iax2_calls ( void ) {
remove_tap_listener ( & ( the_tapinfo_struct . iax2_dummy ) ) ;
have_iax2_tap_listener = FALSE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ClientHintsBrowserTest , ClientHintsLifetimeNotAttachedJavaScriptBlocked ) {
base : : HistogramTester histogram_tester ;
ContentSettingsForOneType host_settings ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> GetSettingsForOneType ( CONTENT_SETTINGS_TYPE_CLIENT_HINTS , std : : string ( ) , & host_settings ) ;
EXPECT_EQ ( 0u , host_settings . size ( ) ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , accept_ch_with_lifetime_url ( ) ) ;
histogram_tester . ExpectUniqueSample ( "ClientHints.UpdateEventCount" , 1 , 1 ) ;
content : : FetchHistogramsFromChildProcesses ( ) ;
SubprocessMetricsProvider : : MergeHistogramDeltasForTesting ( ) ;
histogram_tester . ExpectUniqueSample ( "ClientHints.UpdateSize" , 3 , 1 ) ;
histogram_tester . ExpectUniqueSample ( "ClientHints.PersistDuration" , * 1000 , 1 ) ;
base : : RunLoop ( ) . RunUntilIdle ( ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> GetSettingsForOneType ( CONTENT_SETTINGS_TYPE_CLIENT_HINTS , std : : string ( ) , & host_settings ) ;
EXPECT_EQ ( 1u , host_settings . size ( ) ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> SetContentSettingDefaultScope ( without_accept_ch_without_lifetime_url ( ) , GURL ( ) , CONTENT_SETTINGS_TYPE_JAVASCRIPT , std : : string ( ) , CONTENT_SETTING_BLOCK ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , without_accept_ch_without_lifetime_url ( ) ) ;
EXPECT_EQ ( 0u , count_client_hints_headers_seen ( ) ) ;
HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> SetContentSettingDefaultScope ( without_accept_ch_without_lifetime_url ( ) , GURL ( ) , CONTENT_SETTINGS_TYPE_JAVASCRIPT , std : : string ( ) , CONTENT_SETTING_ALLOW ) ;
SetClientHintExpectationsOnMainFrame ( true ) ;
SetClientHintExpectationsOnSubresources ( true ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , without_accept_ch_without_lifetime_url ( ) ) ;
# if defined ( OS_ANDROID ) EXPECT_EQ ( 4u , count_client_hints_headers_seen ( ) ) ;
# else EXPECT_EQ ( 6u , count_client_hints_headers_seen ( ) ) ;
# endif HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) -> ClearSettingsForOneType ( CONTENT_SETTINGS_TYPE_JAVASCRIPT ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int x ( struct vcache * avc , int afun , struct vrequest * areq , \ struct afs_pdata * ain , struct afs_pdata * aout , \ afs_ucred_t * * acred ) DECL_PIOCTL ( PGetFID ) ;
DECL_PIOCTL ( PSetAcl ) ;
DECL_PIOCTL ( PStoreBehind ) ;
DECL_PIOCTL ( PGCPAGs ) ;
DECL_PIOCTL ( PGetAcl ) ;
DECL_PIOCTL ( PNoop )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mime_parse_day ( const char * & buf , const char * end , int * day ) {
const char * e ;
while ( ( buf != end ) && * buf && ! ParseRules : : is_alpha ( * buf ) ) {
buf += 1 ;
}
e = buf ;
while ( ( e != end ) && * e && ParseRules : : is_alpha ( * e ) ) {
e += 1 ;
}
* day = day_names_dfa -> match ( buf , e - buf ) ;
if ( * day < 0 ) {
return 0 ;
}
else {
buf = e ;
return 1 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _IMAPToUnicodeWithOffsets ( UConverterToUnicodeArgs * pArgs , UErrorCode * pErrorCode ) {
UConverter * cnv ;
const uint8_t * source , * sourceLimit ;
UChar * target ;
const UChar * targetLimit ;
int32_t * offsets ;
uint8_t * bytes ;
uint8_t byteIndex ;
int32_t length , targetCapacity ;
uint16_t bits ;
int8_t base64Counter ;
UBool inDirectMode ;
int8_t base64Value ;
int32_t sourceIndex , nextSourceIndex ;
UChar c ;
uint8_t b ;
cnv = pArgs -> converter ;
source = ( const uint8_t * ) pArgs -> source ;
sourceLimit = ( const uint8_t * ) pArgs -> sourceLimit ;
target = pArgs -> target ;
targetLimit = pArgs -> targetLimit ;
offsets = pArgs -> offsets ;
{
uint32_t status = cnv -> toUnicodeStatus ;
inDirectMode = ( UBool ) ( ( status >> 24 ) & 1 ) ;
base64Counter = ( int8_t ) ( status >> 16 ) ;
bits = ( uint16_t ) status ;
}
bytes = cnv -> toUBytes ;
byteIndex = cnv -> toULength ;
sourceIndex = byteIndex == 0 ? 0 : - 1 ;
nextSourceIndex = 0 ;
if ( inDirectMode ) {
directMode : byteIndex = 0 ;
length = ( int32_t ) ( sourceLimit - source ) ;
targetCapacity = ( int32_t ) ( targetLimit - target ) ;
if ( length > targetCapacity ) {
length = targetCapacity ;
}
while ( length > 0 ) {
b = * source ++ ;
if ( ! isLegalIMAP ( b ) ) {
bytes [ 0 ] = b ;
byteIndex = 1 ;
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
break ;
}
else if ( b != AMPERSAND ) {
* target ++ = b ;
if ( offsets != NULL ) {
* offsets ++ = sourceIndex ++ ;
}
}
else {
nextSourceIndex = ++ sourceIndex ;
inDirectMode = FALSE ;
byteIndex = 0 ;
bits = 0 ;
base64Counter = - 1 ;
goto unicodeMode ;
}
-- length ;
}
if ( source < sourceLimit && target >= targetLimit ) {
* pErrorCode = U_BUFFER_OVERFLOW_ERROR ;
}
}
else {
unicodeMode : while ( source < sourceLimit ) {
if ( target < targetLimit ) {
bytes [ byteIndex ++ ] = b = * source ++ ;
++ nextSourceIndex ;
if ( b > 0x7e ) {
inDirectMode = TRUE ;
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
break ;
}
else if ( ( base64Value = FROM_BASE64_IMAP ( b ) ) >= 0 ) {
switch ( base64Counter ) {
case - 1 : case 0 : bits = base64Value ;
base64Counter = 1 ;
break ;
case 1 : case 3 : case 4 : case 6 : bits = ( uint16_t ) ( ( bits << 6 ) | base64Value ) ;
++ base64Counter ;
break ;
case 2 : c = ( UChar ) ( ( bits << 4 ) | ( base64Value >> 2 ) ) ;
if ( isLegalIMAP ( c ) ) {
inDirectMode = TRUE ;
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
goto endloop ;
}
* target ++ = c ;
if ( offsets != NULL ) {
* offsets ++ = sourceIndex ;
sourceIndex = nextSourceIndex - 1 ;
}
bytes [ 0 ] = b ;
byteIndex = 1 ;
bits = ( uint16_t ) ( base64Value & 3 ) ;
base64Counter = 3 ;
break ;
case 5 : c = ( UChar ) ( ( bits << 2 ) | ( base64Value >> 4 ) ) ;
if ( isLegalIMAP ( c ) ) {
inDirectMode = TRUE ;
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
goto endloop ;
}
* target ++ = c ;
if ( offsets != NULL ) {
* offsets ++ = sourceIndex ;
sourceIndex = nextSourceIndex - 1 ;
}
bytes [ 0 ] = b ;
byteIndex = 1 ;
bits = ( uint16_t ) ( base64Value & 15 ) ;
base64Counter = 6 ;
break ;
case 7 : c = ( UChar ) ( ( bits << 6 ) | base64Value ) ;
if ( isLegalIMAP ( c ) ) {
inDirectMode = TRUE ;
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
goto endloop ;
}
* target ++ = c ;
if ( offsets != NULL ) {
* offsets ++ = sourceIndex ;
sourceIndex = nextSourceIndex ;
}
byteIndex = 0 ;
bits = 0 ;
base64Counter = 0 ;
break ;
default : break ;
}
}
else if ( base64Value == - 2 ) {
inDirectMode = TRUE ;
if ( base64Counter == - 1 ) {
* target ++ = AMPERSAND ;
if ( offsets != NULL ) {
* offsets ++ = sourceIndex - 1 ;
}
}
else {
if ( bits != 0 || ( base64Counter != 0 && base64Counter != 3 && base64Counter != 6 ) ) {
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
break ;
}
}
sourceIndex = nextSourceIndex ;
goto directMode ;
}
else {
if ( base64Counter == - 1 ) {
-- sourceIndex ;
bytes [ 0 ] = AMPERSAND ;
bytes [ 1 ] = b ;
byteIndex = 2 ;
}
inDirectMode = TRUE ;
* pErrorCode = U_ILLEGAL_CHAR_FOUND ;
break ;
}
}
else {
* pErrorCode = U_BUFFER_OVERFLOW_ERROR ;
break ;
}
}
}
endloop : if ( U_SUCCESS ( * pErrorCode ) && ! inDirectMode && byteIndex == 0 && pArgs -> flush && source >= sourceLimit ) {
if ( base64Counter == - 1 ) {
bytes [ 0 ] = AMPERSAND ;
byteIndex = 1 ;
}
inDirectMode = TRUE ;
* pErrorCode = U_TRUNCATED_CHAR_FOUND ;
}
cnv -> toUnicodeStatus = ( ( uint32_t ) inDirectMode << 24 ) | ( ( uint32_t ) ( ( uint8_t ) base64Counter ) << 16 ) | ( uint32_t ) bits ;
cnv -> toULength = byteIndex ;
pArgs -> source = ( const char * ) source ;
pArgs -> target = target ;
pArgs -> offsets = offsets ;
return ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ContentFaviconDriverTest , LoadIconFromWebManifest ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
GURL url = embedded_test_server ( ) -> GetURL ( "/favicon/page_with_manifest.html" ) ;
GURL icon_url = embedded_test_server ( ) -> GetURL ( "/favicon/icon.png" ) ;
std : : unique_ptr < TestResourceDispatcherHostDelegate > delegate ( new TestResourceDispatcherHostDelegate ( icon_url ) ) ;
content : : ResourceDispatcherHost : : Get ( ) -> SetDelegate ( delegate . get ( ) ) ;
PendingTaskWaiter waiter ( web_contents ( ) ) ;
ui_test_utils : : NavigateToURLWithDisposition ( browser ( ) , url , WindowOpenDisposition : : CURRENT_TAB , ui_test_utils : : BROWSER_TEST_NONE ) ;
waiter . Wait ( ) ;
# if defined ( OS_ANDROID ) EXPECT_TRUE ( delegate -> was_requested ( ) ) ;
EXPECT_NE ( nullptr , GetFaviconForPageURL ( url , favicon_base : : IconType : : kWebManifestIcon ) . bitmap_data ) ;
# else EXPECT_FALSE ( delegate -> was_requested ( ) ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int MDC2_Update ( MDC2_CTX * c , const unsigned char * in , size_t len ) {
size_t i , j ;
i = c -> num ;
if ( i != 0 ) {
if ( len < MDC2_BLOCK - i ) {
memcpy ( & ( c -> data [ i ] ) , in , len ) ;
c -> num += ( int ) len ;
return 1 ;
}
else {
j = MDC2_BLOCK - i ;
memcpy ( & ( c -> data [ i ] ) , in , j ) ;
len -= j ;
in += j ;
c -> num = 0 ;
mdc2_body ( c , & ( c -> data [ 0 ] ) , MDC2_BLOCK ) ;
}
}
i = len & ~ ( ( size_t ) MDC2_BLOCK - 1 ) ;
if ( i > 0 ) mdc2_body ( c , in , i ) ;
j = len - i ;
if ( j > 0 ) {
memcpy ( & ( c -> data [ 0 ] ) , & ( in [ i ] ) , j ) ;
c -> num = ( int ) j ;
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_frm_bug ( ) {
MYSQL_STMT * stmt ;
MYSQL_BIND my_bind [ 2 ] ;
MYSQL_RES * result ;
MYSQL_ROW row ;
FILE * test_file ;
char data_dir [ FN_REFLEN ] ;
char test_frm [ FN_REFLEN ] ;
int rc ;
myheader ( "test_frm_bug" ) ;
mysql_autocommit ( mysql , TRUE ) ;
rc = mysql_query ( mysql , "drop table if exists test_frm_bug" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "flush tables" ) ;
myquery ( rc ) ;
stmt = mysql_simple_prepare ( mysql , "show variables like 'datadir'" ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 0 ] . buffer = data_dir ;
my_bind [ 0 ] . buffer_length = FN_REFLEN ;
my_bind [ 1 ] = my_bind [ 0 ] ;
rc = mysql_stmt_bind_result ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_fetch ( stmt ) ;
check_execute ( stmt , rc ) ;
if ( ! opt_silent ) fprintf ( stdout , "\n data directory: %s" , data_dir ) ;
rc = mysql_stmt_fetch ( stmt ) ;
DIE_UNLESS ( rc == MYSQL_NO_DATA ) ;
strxmov ( test_frm , data_dir , "/" , current_db , "/" , "test_frm_bug.frm" , NullS ) ;
if ( ! opt_silent ) fprintf ( stdout , "\n test_frm: %s" , test_frm ) ;
if ( ! ( test_file = my_fopen ( test_frm , ( int ) ( O_RDWR | O_CREAT ) , MYF ( MY_WME ) ) ) ) {
fprintf ( stdout , "\n ERROR: my_fopen failed for '%s'" , test_frm ) ;
fprintf ( stdout , "\n test cancelled" ) ;
exit ( 1 ) ;
}
if ( ! opt_silent ) fprintf ( test_file , "this is a junk file for test" ) ;
rc = mysql_query ( mysql , "SHOW TABLE STATUS like 'test_frm_bug'" ) ;
myquery ( rc ) ;
result = mysql_store_result ( mysql ) ;
mytest ( result ) ;
rc = my_process_result_set ( result ) ;
DIE_UNLESS ( rc == 1 ) ;
mysql_data_seek ( result , 0 ) ;
row = mysql_fetch_row ( result ) ;
mytest ( row ) ;
if ( ! opt_silent ) fprintf ( stdout , "\n Comment: %s" , row [ 17 ] ) ;
DIE_UNLESS ( row [ 17 ] != 0 ) ;
mysql_free_result ( result ) ;
mysql_stmt_close ( stmt ) ;
my_fclose ( test_file , MYF ( 0 ) ) ;
mysql_query ( mysql , "drop table if exists test_frm_bug" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
GType hb_gobject_ ## name ## _get_type ( void ) \ {
static gsize type_id = 0 ;
if ( g_once_init_enter ( & type_id ) ) {
GType id = g_boxed_type_register_static ( g_intern_static_string ( "hb_" # name "_t" ) , ( GBoxedCopyFunc ) copy_func , ( GBoxedFreeFunc ) free_func ) ;
g_once_init_leave ( & type_id , id ) ;
}
return type_id ;
\ }
# define HB_DEFINE_OBJECT_TYPE ( name ) HB_DEFINE_BOXED_TYPE ( name , hb_ ## name ## _reference , hb_ ## name ## _destroy ) ;
# define HB_DEFINE_VALUE_TYPE ( name ) static hb_ ## name ## _t * _hb_ ## name ## _reference ( const hb_ ## name ## _t * l ) {
hb_ ## name ## _t * c = ( hb_ ## name ## _t * ) calloc ( 1 , sizeof ( hb_ ## name ## _t ) ) ;
if ( unlikely ( ! c ) ) return NULL ;
* c = * l ;
return c ;
}
static void _hb_ ## name ## _destroy ( hb_ ## name ## _t * l ) {
free ( l ) ;
}
HB_DEFINE_BOXED_TYPE ( name , _hb_ ## name ## _reference , _hb_ ## name ## _destroy ) ;
HB_DEFINE_OBJECT_TYPE ( buffer ) HB_DEFINE_OBJECT_TYPE ( blob )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PREDICTION_MODE read_intra_mode_y ( VP9_COMMON * cm , vp9_reader * r , int size_group ) {
const PREDICTION_MODE y_mode = read_intra_mode ( r , cm -> fc . y_mode_prob [ size_group ] ) ;
if ( ! cm -> frame_parallel_decoding_mode ) ++ cm -> counts . y_mode [ size_group ] [ y_mode ] ;
return y_mode ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void input_DecoderChangeDelay ( decoder_t * p_dec , mtime_t i_delay ) {
decoder_owner_sys_t * p_owner = p_dec -> p_owner ;
vlc_mutex_lock ( & p_owner -> lock ) ;
p_owner -> i_ts_delay = i_delay ;
vlc_mutex_unlock ( & p_owner -> lock ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int unpack_bitstream ( G723_1_Context * p , const uint8_t * buf , int buf_size ) {
GetBitContext gb ;
int ad_cb_len ;
int temp , info_bits , i ;
init_get_bits ( & gb , buf , buf_size * 8 ) ;
info_bits = get_bits ( & gb , 2 ) ;
if ( info_bits == 3 ) {
p -> cur_frame_type = UNTRANSMITTED_FRAME ;
return 0 ;
}
p -> lsp_index [ 2 ] = get_bits ( & gb , 8 ) ;
p -> lsp_index [ 1 ] = get_bits ( & gb , 8 ) ;
p -> lsp_index [ 0 ] = get_bits ( & gb , 8 ) ;
if ( info_bits == 2 ) {
p -> cur_frame_type = SID_FRAME ;
p -> subframe [ 0 ] . amp_index = get_bits ( & gb , 6 ) ;
return 0 ;
}
p -> cur_rate = info_bits ? RATE_5300 : RATE_6300 ;
p -> cur_frame_type = ACTIVE_FRAME ;
p -> pitch_lag [ 0 ] = get_bits ( & gb , 7 ) ;
if ( p -> pitch_lag [ 0 ] > 123 ) return - 1 ;
p -> pitch_lag [ 0 ] += PITCH_MIN ;
p -> subframe [ 1 ] . ad_cb_lag = get_bits ( & gb , 2 ) ;
p -> pitch_lag [ 1 ] = get_bits ( & gb , 7 ) ;
if ( p -> pitch_lag [ 1 ] > 123 ) return - 1 ;
p -> pitch_lag [ 1 ] += PITCH_MIN ;
p -> subframe [ 3 ] . ad_cb_lag = get_bits ( & gb , 2 ) ;
p -> subframe [ 0 ] . ad_cb_lag = 1 ;
p -> subframe [ 2 ] . ad_cb_lag = 1 ;
for ( i = 0 ;
i < SUBFRAMES ;
i ++ ) {
temp = get_bits ( & gb , 12 ) ;
ad_cb_len = 170 ;
p -> subframe [ i ] . dirac_train = 0 ;
if ( p -> cur_rate == RATE_6300 && p -> pitch_lag [ i >> 1 ] < SUBFRAME_LEN - 2 ) {
p -> subframe [ i ] . dirac_train = temp >> 11 ;
temp &= 0x7FF ;
ad_cb_len = 85 ;
}
p -> subframe [ i ] . ad_cb_gain = FASTDIV ( temp , GAIN_LEVELS ) ;
if ( p -> subframe [ i ] . ad_cb_gain < ad_cb_len ) {
p -> subframe [ i ] . amp_index = temp - p -> subframe [ i ] . ad_cb_gain * GAIN_LEVELS ;
}
else {
return - 1 ;
}
}
p -> subframe [ 0 ] . grid_index = get_bits ( & gb , 1 ) ;
p -> subframe [ 1 ] . grid_index = get_bits ( & gb , 1 ) ;
p -> subframe [ 2 ] . grid_index = get_bits ( & gb , 1 ) ;
p -> subframe [ 3 ] . grid_index = get_bits ( & gb , 1 ) ;
if ( p -> cur_rate == RATE_6300 ) {
skip_bits ( & gb , 1 ) ;
temp = get_bits ( & gb , 13 ) ;
p -> subframe [ 0 ] . pulse_pos = temp / 810 ;
temp -= p -> subframe [ 0 ] . pulse_pos * 810 ;
p -> subframe [ 1 ] . pulse_pos = FASTDIV ( temp , 90 ) ;
temp -= p -> subframe [ 1 ] . pulse_pos * 90 ;
p -> subframe [ 2 ] . pulse_pos = FASTDIV ( temp , 9 ) ;
p -> subframe [ 3 ] . pulse_pos = temp - p -> subframe [ 2 ] . pulse_pos * 9 ;
p -> subframe [ 0 ] . pulse_pos = ( p -> subframe [ 0 ] . pulse_pos << 16 ) + get_bits ( & gb , 16 ) ;
p -> subframe [ 1 ] . pulse_pos = ( p -> subframe [ 1 ] . pulse_pos << 14 ) + get_bits ( & gb , 14 ) ;
p -> subframe [ 2 ] . pulse_pos = ( p -> subframe [ 2 ] . pulse_pos << 16 ) + get_bits ( & gb , 16 ) ;
p -> subframe [ 3 ] . pulse_pos = ( p -> subframe [ 3 ] . pulse_pos << 14 ) + get_bits ( & gb , 14 ) ;
p -> subframe [ 0 ] . pulse_sign = get_bits ( & gb , 6 ) ;
p -> subframe [ 1 ] . pulse_sign = get_bits ( & gb , 5 ) ;
p -> subframe [ 2 ] . pulse_sign = get_bits ( & gb , 6 ) ;
p -> subframe [ 3 ] . pulse_sign = get_bits ( & gb , 5 ) ;
}
else {
p -> subframe [ 0 ] . pulse_pos = get_bits ( & gb , 12 ) ;
p -> subframe [ 1 ] . pulse_pos = get_bits ( & gb , 12 ) ;
p -> subframe [ 2 ] . pulse_pos = get_bits ( & gb , 12 ) ;
p -> subframe [ 3 ] . pulse_pos = get_bits ( & gb , 12 ) ;
p -> subframe [ 0 ] . pulse_sign = get_bits ( & gb , 4 ) ;
p -> subframe [ 1 ] . pulse_sign = get_bits ( & gb , 4 ) ;
p -> subframe [ 2 ] . pulse_sign = get_bits ( & gb , 4 ) ;
p -> subframe [ 3 ] . pulse_sign = get_bits ( & gb , 4 ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t write8 ( FileStream * out , uint8_t byte , uint32_t column ) {
char s [ 4 ] ;
int i = 0 ;
if ( byte >= 100 ) {
s [ i ++ ] = ( char ) ( '0' + byte / 100 ) ;
byte %= 100 ;
}
if ( i > 0 || byte >= 10 ) {
s [ i ++ ] = ( char ) ( '0' + byte / 10 ) ;
byte %= 10 ;
}
s [ i ++ ] = ( char ) ( '0' + byte ) ;
s [ i ] = 0 ;
if ( column == MAX_COLUMN ) {
column = 1 ;
}
else if ( column < 16 ) {
T_FileStream_writeLine ( out , "," ) ;
++ column ;
}
else {
T_FileStream_writeLine ( out , ",\n" ) ;
column = 1 ;
}
T_FileStream_writeLine ( out , s ) ;
return column ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ProfileBrowserTest , CreateOldProfileSynchronous ) {
base : : ScopedTempDir temp_dir ;
ASSERT_TRUE ( temp_dir . CreateUniqueTempDir ( ) ) ;
CreatePrefsFileInDirectory ( temp_dir . path ( ) ) ;
MockProfileDelegate delegate ;
EXPECT_CALL ( delegate , OnProfileCreated ( testing : : NotNull ( ) , true , false ) ) ;
{
std : : unique_ptr < Profile > profile ( CreateProfile ( temp_dir . path ( ) , & delegate , Profile : : CREATE_MODE_SYNCHRONOUS ) ) ;
CheckChromeVersion ( profile . get ( ) , false ) ;
}
FlushIoTaskRunnerAndSpinThreads ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
size_t vpx_svc_get_rc_stats_buffer_size ( const SvcContext * svc_ctx ) {
const SvcInternal * const si = get_const_svc_internal ( svc_ctx ) ;
if ( svc_ctx == NULL || si == NULL ) return 0 ;
return si -> rc_stats_buf_used ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dumpcidglyphs ( SplineFont * sf , struct alltabs * at ) {
int i ;
struct pschars * glbls = NULL , * chrs ;
at -> cfff = tmpfile ( ) ;
at -> sidf = tmpfile ( ) ;
at -> sidh = tmpfile ( ) ;
at -> charset = tmpfile ( ) ;
at -> fdselect = tmpfile ( ) ;
at -> fdarray = tmpfile ( ) ;
at -> globalsubrs = tmpfile ( ) ;
at -> fds = calloc ( sf -> subfontcnt , sizeof ( struct fd2data ) ) ;
for ( i = 0 ;
i < sf -> subfontcnt ;
++ i ) {
at -> fds [ i ] . private = tmpfile ( ) ;
ATFigureDefWidth ( sf -> subfonts [ i ] , at , i ) ;
}
if ( ( chrs = CID2ChrsSubrs2 ( sf , at -> fds , at -> gi . flags , & glbls , at -> gi . layer ) ) == NULL ) return ( false ) ;
for ( i = 0 ;
i < sf -> subfontcnt ;
++ i ) {
dumpcffprivate ( sf -> subfonts [ i ] , at , i , at -> fds [ i ] . subrs -> next ) ;
if ( at -> fds [ i ] . subrs -> next != 0 ) _dumpcffstrings ( at -> fds [ i ] . private , at -> fds [ i ] . subrs ) ;
PSCharsFree ( at -> fds [ i ] . subrs ) ;
}
_dumpcffstrings ( at -> globalsubrs , glbls ) ;
PSCharsFree ( glbls ) ;
dumpcffheader ( at -> cfff ) ;
dumpcffnames ( sf , at -> cfff ) ;
dumpcffcidset ( at ) ;
dumpcfffdselect ( sf , at ) ;
dumpcffdictindex ( sf , at ) ;
if ( ( at -> charstrings = dumpcffstrings ( chrs ) ) == NULL ) return ( false ) ;
dumpcffcidtopdict ( sf , at ) ;
finishupcid ( sf , at ) ;
at -> cfflen = ftell ( at -> cfff ) ;
if ( at -> cfflen & 3 ) {
for ( i = 4 - ( at -> cfflen & 3 ) ;
i > 0 ;
-- i ) putc ( '\0' , at -> cfff ) ;
}
if ( at -> format != ff_cffcid ) dumpcffcidhmtx ( at , sf ) ;
return ( true ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mysql_store_result_for_lazy ( MYSQL_RES * * result ) {
if ( ( * result = mysql_store_result ( & mysql ) ) ) return 0 ;
if ( mysql_error ( & mysql ) [ 0 ] ) return put_error ( & mysql ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int32_t u_scanf_spellout_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 ;
int32_t skipped ;
UErrorCode status = U_ZERO_ERROR ;
skipped = u_scanf_skip_leading_ws ( input , info -> fPadChar ) ;
ufile_fill_uchar_buffer ( input ) ;
len = ( int32_t ) ( input -> str . fLimit - input -> str . fPos ) ;
if ( info -> fWidth != - 1 ) len = ufmt_min ( len , info -> fWidth ) ;
format = u_locbund_getNumberFormat ( & input -> str . fBundle , UNUM_SPELLOUT ) ;
if ( format == 0 ) return 0 ;
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 + skipped ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * kq_init ( struct event_base * base ) {
int i , kq ;
struct kqop * kqueueop ;
if ( evutil_getenv ( "EVENT_NOKQUEUE" ) ) return ( NULL ) ;
if ( ! ( kqueueop = calloc ( 1 , sizeof ( struct kqop ) ) ) ) return ( NULL ) ;
if ( ( kq = kqueue ( ) ) == - 1 ) {
event_warn ( "kqueue" ) ;
free ( kqueueop ) ;
return ( NULL ) ;
}
kqueueop -> kq = kq ;
kqueueop -> pid = getpid ( ) ;
kqueueop -> changes = malloc ( NEVENT * sizeof ( struct kevent ) ) ;
if ( kqueueop -> changes == NULL ) {
free ( kqueueop ) ;
return ( NULL ) ;
}
kqueueop -> events = malloc ( NEVENT * sizeof ( struct kevent ) ) ;
if ( kqueueop -> events == NULL ) {
free ( kqueueop -> changes ) ;
free ( kqueueop ) ;
return ( NULL ) ;
}
kqueueop -> nevents = NEVENT ;
for ( i = 0 ;
i < NSIG ;
++ i ) {
TAILQ_INIT ( & kqueueop -> evsigevents [ i ] ) ;
}
kqueueop -> changes [ 0 ] . ident = - 1 ;
kqueueop -> changes [ 0 ] . filter = EVFILT_READ ;
kqueueop -> changes [ 0 ] . flags = EV_ADD ;
if ( kevent ( kq , kqueueop -> changes , 1 , kqueueop -> events , NEVENT , NULL ) != 1 || kqueueop -> events [ 0 ] . ident != - 1 || kqueueop -> events [ 0 ] . flags != EV_ERROR ) {
event_warn ( "%s: detected broken kqueue;
not using." , __func__ ) ;
free ( kqueueop -> changes ) ;
free ( kqueueop -> events ) ;
free ( kqueueop ) ;
close ( kq ) ;
return ( NULL ) ;
}
return ( kqueueop ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static celt element ( struct vars * v , const chr * startp , const chr * endp ) {
const struct cname * cn ;
size_t len ;
assert ( startp < endp ) ;
len = endp - startp ;
if ( len == 1 ) return * startp ;
NOTE ( REG_ULOCALE ) ;
for ( cn = cnames ;
cn -> name != NULL ;
cn ++ ) {
if ( strlen ( cn -> name ) == len && pg_char_and_wchar_strncmp ( cn -> name , startp , len ) == 0 ) {
break ;
}
}
if ( cn -> name != NULL ) return CHR ( cn -> code ) ;
ERR ( REG_ECOLLATE ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
wtap_open_return_val k12_open ( wtap * wth , int * err , gchar * * err_info ) {
k12_src_desc_t * rec ;
guint8 header_buffer [ K12_FILE_HDR_LEN ] ;
guint8 * read_buffer ;
guint32 type ;
long offset ;
long len ;
guint port_type ;
guint32 rec_len ;
guint32 hwpart_len ;
guint32 name_len ;
guint32 stack_len ;
guint i ;
k12_t * file_data ;
# ifdef DEBUG_K12 gchar * env_level = getenv ( "K12_DEBUG_LEVEL" ) ;
env_file = getenv ( "K12_DEBUG_FILENAME" ) ;
if ( env_file ) {
dbg_out = ws_fopen ( env_file , "w" ) ;
if ( dbg_out == NULL ) {
dbg_out = stderr ;
K12_DBG ( 1 , ( "unable to open K12 DEBUG FILENAME for writing! Logging to standard error" ) ) ;
}
}
else dbg_out = stderr ;
if ( env_level ) debug_level = ( unsigned int ) strtoul ( env_level , NULL , 10 ) ;
K12_DBG ( 1 , ( "k12_open: ENTER debug_level=%u" , debug_level ) ) ;
# endif if ( ! wtap_read_bytes ( wth -> fh , header_buffer , K12_FILE_HDR_LEN , err , err_info ) ) {
K12_DBG ( 1 , ( "k12_open: FILE HEADER TOO SHORT OR READ ERROR" ) ) ;
if ( * err != WTAP_ERR_SHORT_READ ) {
return WTAP_OPEN_ERROR ;
}
return WTAP_OPEN_NOT_MINE ;
}
if ( memcmp ( header_buffer , k12_file_magic , 8 ) != 0 ) {
K12_DBG ( 1 , ( "k12_open: BAD MAGIC" ) ) ;
return WTAP_OPEN_NOT_MINE ;
}
offset = K12_FILE_HDR_LEN ;
file_data = new_k12_file_data ( ) ;
file_data -> file_len = pntoh32 ( header_buffer + 0x8 ) ;
if ( memiszero ( header_buffer + 0x10 , K12_FILE_HDR_LEN - 0x10 ) ) {
file_data -> num_of_records = pntoh32 ( header_buffer + 0x0C ) ;
}
else {
file_data -> num_of_records = pntoh32 ( header_buffer + K12_FILE_HDR_RECORD_COUNT_1 ) ;
if ( file_data -> num_of_records != pntoh32 ( header_buffer + K12_FILE_HDR_RECORD_COUNT_2 ) ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "k12: two different record counts, %u at 0x%02x and %u at 0x%02x" , file_data -> num_of_records , K12_FILE_HDR_RECORD_COUNT_1 , pntoh32 ( header_buffer + K12_FILE_HDR_RECORD_COUNT_2 ) , K12_FILE_HDR_RECORD_COUNT_2 ) ;
return WTAP_OPEN_ERROR ;
}
}
K12_DBG ( 5 , ( "k12_open: FILE_HEADER OK: offset=%x file_len=%i records=%i" , offset , file_data -> file_len , file_data -> num_of_records ) ) ;
do {
if ( file_data -> num_of_records == 0 ) {
* err = WTAP_ERR_SHORT_READ ;
destroy_k12_file_data ( file_data ) ;
return WTAP_OPEN_ERROR ;
}
len = get_record ( file_data , wth -> fh , offset , FALSE , err , err_info ) ;
if ( len < 0 ) {
K12_DBG ( 1 , ( "k12_open: BAD HEADER RECORD" , len ) ) ;
destroy_k12_file_data ( file_data ) ;
return WTAP_OPEN_ERROR ;
}
if ( len == 0 ) {
K12_DBG ( 1 , ( "k12_open: BAD HEADER RECORD" , len ) ) ;
* err = WTAP_ERR_SHORT_READ ;
destroy_k12_file_data ( file_data ) ;
return WTAP_OPEN_ERROR ;
}
read_buffer = file_data -> seq_read_buff ;
rec_len = pntoh32 ( read_buffer + K12_RECORD_LEN ) ;
if ( rec_len < K12_RECORD_TYPE + 4 ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "k12_open: record length %u < %u" , rec_len , K12_RECORD_TYPE + 4 ) ;
return WTAP_OPEN_ERROR ;
}
type = pntoh32 ( read_buffer + K12_RECORD_TYPE ) ;
if ( ( type & K12_MASK_PACKET ) == K12_REC_PACKET || ( type & K12_MASK_PACKET ) == K12_REC_D0020 ) {
if ( file_seek ( wth -> fh , offset , SEEK_SET , err ) == - 1 ) {
destroy_k12_file_data ( file_data ) ;
return WTAP_OPEN_ERROR ;
}
K12_DBG ( 5 , ( "k12_open: FIRST PACKET offset=%x" , offset ) ) ;
break ;
}
switch ( type ) {
case K12_REC_SRCDSC : case K12_REC_SRCDSC2 : rec = g_new0 ( k12_src_desc_t , 1 ) ;
if ( rec_len < K12_SRCDESC_HWPART ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "k12_open: source descriptor record length %u < %u" , rec_len , K12_SRCDESC_HWPART ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_ERROR ;
}
port_type = read_buffer [ K12_SRCDESC_PORT_TYPE ] ;
hwpart_len = pntoh16 ( read_buffer + K12_SRCDESC_HWPARTLEN ) ;
name_len = pntoh16 ( read_buffer + K12_SRCDESC_NAMELEN ) ;
stack_len = pntoh16 ( read_buffer + K12_SRCDESC_STACKLEN ) ;
rec -> input = pntoh32 ( read_buffer + K12_RECORD_SRC_ID ) ;
K12_DBG ( 5 , ( "k12_open: INTERFACE RECORD offset=%x interface=%x" , offset , rec -> input ) ) ;
if ( name_len == 0 ) {
K12_DBG ( 5 , ( "k12_open: failed (name_len == 0 in source description" ) ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_NOT_MINE ;
}
if ( stack_len == 0 ) {
K12_DBG ( 5 , ( "k12_open: failed (stack_len == 0 in source description" ) ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_NOT_MINE ;
}
if ( rec_len < K12_SRCDESC_HWPART + hwpart_len + name_len + stack_len ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "k12_open: source descriptor record length %u < %u (%u + %u + %u + %u)" , rec_len , K12_SRCDESC_HWPART + hwpart_len + name_len + stack_len , K12_SRCDESC_HWPART , hwpart_len , name_len , stack_len ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_ERROR ;
}
if ( hwpart_len ) {
if ( hwpart_len < 4 ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "k12_open: source descriptor hardware part length %u < 4" , hwpart_len ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_ERROR ;
}
switch ( ( rec -> input_type = pntoh32 ( read_buffer + K12_SRCDESC_HWPART + K12_SRCDESC_HWPARTTYPE ) ) ) {
case K12_PORT_DS0S : rec -> input_info . ds0mask = 0x00000000 ;
if ( hwpart_len > K12_SRCDESC_DS0_MASK ) {
for ( i = 0 ;
i < hwpart_len - K12_SRCDESC_DS0_MASK ;
i ++ ) {
rec -> input_info . ds0mask |= ( * ( read_buffer + K12_SRCDESC_HWPART + K12_SRCDESC_DS0_MASK + i ) == 0xff ) ? 1U << ( 31 - i ) : 0x0 ;
}
}
break ;
case K12_PORT_ATMPVC : if ( hwpart_len < K12_SRCDESC_ATM_VCI + 2 ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup_printf ( "k12_open: source descriptor hardware part length %u < %u" , hwpart_len , K12_SRCDESC_ATM_VCI + 2 ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_ERROR ;
}
rec -> input_info . atm . vp = pntoh16 ( read_buffer + K12_SRCDESC_HWPART + K12_SRCDESC_ATM_VPI ) ;
rec -> input_info . atm . vc = pntoh16 ( read_buffer + K12_SRCDESC_HWPART + K12_SRCDESC_ATM_VCI ) ;
break ;
default : break ;
}
}
else {
if ( port_type >= 0x14 && port_type <= 0x17 ) {
rec -> input_type = K12_PORT_ATMPVC ;
rec -> input_info . atm . vp = 0 ;
rec -> input_info . atm . vc = 0 ;
}
}
if ( read_buffer [ K12_SRCDESC_HWPART + hwpart_len + name_len - 1 ] != '\0' ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup ( "k12_open: source descriptor record contains non-null-terminated link-layer name" ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_ERROR ;
}
if ( read_buffer [ K12_SRCDESC_HWPART + hwpart_len + name_len + stack_len - 1 ] != '\0' ) {
* err = WTAP_ERR_BAD_FILE ;
* err_info = g_strdup ( "k12_open: source descriptor record contains non-null-terminated stack path" ) ;
destroy_k12_file_data ( file_data ) ;
g_free ( rec ) ;
return WTAP_OPEN_ERROR ;
}
rec -> input_name = ( gchar * ) g_memdup ( read_buffer + K12_SRCDESC_HWPART + hwpart_len , name_len ) ;
rec -> stack_file = ( gchar * ) g_memdup ( read_buffer + K12_SRCDESC_HWPART + hwpart_len + name_len , stack_len ) ;
ascii_strdown_inplace ( rec -> stack_file ) ;
g_hash_table_insert ( file_data -> src_by_id , GUINT_TO_POINTER ( rec -> input ) , rec ) ;
g_hash_table_insert ( file_data -> src_by_name , rec -> stack_file , rec ) ;
break ;
case K12_REC_STK_FILE : K12_DBG ( 1 , ( "k12_open: K12_REC_STK_FILE" ) ) ;
K12_DBG ( 1 , ( "Field 1: 0x%08x" , pntoh32 ( read_buffer + 0x08 ) ) ) ;
K12_DBG ( 1 , ( "Field 2: 0x%08x" , pntoh32 ( read_buffer + 0x0c ) ) ) ;
K12_ASCII_DUMP ( 1 , read_buffer , rec_len , 16 ) ;
break ;
default : K12_DBG ( 1 , ( "k12_open: RECORD TYPE 0x%08x" , type ) ) ;
break ;
}
offset += len ;
file_data -> num_of_records -- ;
}
while ( 1 ) ;
wth -> file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_K12 ;
wth -> file_encap = WTAP_ENCAP_K12 ;
wth -> snapshot_length = 0 ;
wth -> subtype_read = k12_read ;
wth -> subtype_seek_read = k12_seek_read ;
wth -> subtype_close = k12_close ;
wth -> priv = ( void * ) file_data ;
wth -> file_tsprec = WTAP_TSPREC_NSEC ;
return WTAP_OPEN_MINE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void proto_reg_handoff_ipmi_trace ( void ) {
dissector_handle_t ipmi_trace_handle ;
ipmi_trace_handle = create_dissector_handle ( dissect_ipmi_trace , proto_ipmi_trace ) ;
dissector_add_uint ( "wtap_encap" , WTAP_ENCAP_IPMI_TRACE , ipmi_trace_handle ) ;
dissector_add_uint ( "ipmi.protocol" , IPMI_PROTO_IPMB_1_0 , find_dissector ( "ipmb" ) ) ;
dissector_add_uint ( "ipmi.protocol" , IPMI_PROTO_KCS , find_dissector ( "kcs" ) ) ;
dissector_add_uint ( "ipmi.protocol" , IPMI_PROTO_TMODE , find_dissector ( "tmode" ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PHP_MINFO_FUNCTION ( zip ) {
php_info_print_table_start ( ) ;
php_info_print_table_row ( 2 , "Zip" , "enabled" ) ;
php_info_print_table_row ( 2 , "Extension Version" , "$Id$" ) ;
php_info_print_table_row ( 2 , "Zip version" , PHP_ZIP_VERSION_STRING ) ;
php_info_print_table_row ( 2 , "Libzip version" , LIBZIP_VERSION ) ;
php_info_print_table_end ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * authGSSServerResponse ( PyObject * self , PyObject * args ) {
gss_server_state * state ;
PyObject * pystate ;
if ( ! PyArg_ParseTuple ( args , "O" , & pystate ) ) return NULL ;
# if PY_MAJOR_VERSION >= 3 if ( ! PyCapsule_CheckExact ( pystate ) ) {
# else if ( ! PyCObject_Check ( pystate ) ) {
# endif PyErr_SetString ( PyExc_TypeError , "Expected a context object" ) ;
return NULL ;
}
# if PY_MAJOR_VERSION >= 3 state = PyCapsule_GetPointer ( pystate , NULL ) ;
# else state = ( gss_client_state * ) PyCObject_AsVoidPtr ( pystate ) ;
# endif if ( state == NULL ) return NULL ;
return Py_BuildValue ( "s" , state -> response ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void check_for_isn_and_int8_passing_mismatch ( ClusterInfo * cluster ) {
int dbnum ;
FILE * script = NULL ;
bool found = false ;
char output_path [ MAXPGPATH ] ;
prep_status ( "Checking for contrib/isn with bigint-passing mismatch" ) ;
if ( old_cluster . controldata . float8_pass_by_value == new_cluster . controldata . float8_pass_by_value ) {
check_ok ( ) ;
return ;
}
snprintf ( output_path , sizeof ( output_path ) , "contrib_isn_and_int8_pass_by_value.txt" ) ;
for ( dbnum = 0 ;
dbnum < cluster -> dbarr . ndbs ;
dbnum ++ ) {
PGresult * res ;
bool db_used = false ;
int ntups ;
int rowno ;
int i_nspname , i_proname ;
DbInfo * active_db = & cluster -> dbarr . dbs [ dbnum ] ;
PGconn * conn = connectToServer ( cluster , active_db -> db_name ) ;
res = executeQueryOrDie ( conn , "SELECT n.nspname, p.proname " "FROM pg_catalog.pg_proc p, " " pg_catalog.pg_namespace n " "WHERE p.pronamespace = n.oid AND " " p.probin = '$libdir/isn'" ) ;
ntups = PQntuples ( res ) ;
i_nspname = PQfnumber ( res , "nspname" ) ;
i_proname = PQfnumber ( res , "proname" ) ;
for ( rowno = 0 ;
rowno < ntups ;
rowno ++ ) {
found = true ;
if ( script == NULL && ( script = fopen_priv ( output_path , "w" ) ) == NULL ) pg_fatal ( "Could not open file \"%s\": %s\n" , output_path , getErrorText ( ) ) ;
if ( ! db_used ) {
fprintf ( script , "Database: %s\n" , active_db -> db_name ) ;
db_used = true ;
}
fprintf ( script , " %s.%s\n" , PQgetvalue ( res , rowno , i_nspname ) , PQgetvalue ( res , rowno , i_proname ) ) ;
}
PQclear ( res ) ;
PQfinish ( conn ) ;
}
if ( script ) fclose ( script ) ;
if ( found ) {
pg_log ( PG_REPORT , "fatal\n" ) ;
pg_fatal ( "Your installation contains \"contrib/isn\" functions which rely on the\n" "bigint data type. Your old and new clusters pass bigint values\n" "differently so this cluster cannot currently be upgraded. You can\n" "manually upgrade databases that use \"contrib/isn\" facilities and remove\n" "\"contrib/isn\" from the old cluster and restart the upgrade. A list of\n" "the problem functions is in the file:\n" " %s\n\n" , output_path ) ;
}
else check_ok ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_set_pattern ( fz_context * ctx , pdf_run_processor * pr , int what , pdf_pattern * pat , float * v ) {
pdf_gstate * gs ;
pdf_material * mat ;
gs = pdf_flush_text ( ctx , pr ) ;
mat = what == PDF_FILL ? & gs -> fill : & gs -> stroke ;
pdf_drop_pattern ( ctx , mat -> pattern ) ;
mat -> pattern = NULL ;
mat -> kind = PDF_MAT_PATTERN ;
if ( pat ) mat -> pattern = pdf_keep_pattern ( ctx , pat ) ;
if ( v ) pdf_set_color ( ctx , pr , what , v ) ;
mat -> gstate_num = pr -> gparent ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void restrict_update_of_old_passwords_var ( THD * thd , enum_var_type var_type ) {
if ( var_type == OPT_GLOBAL ) {
pthread_mutex_lock ( & LOCK_global_system_variables ) ;
global_system_variables . old_passwords = 1 ;
pthread_mutex_unlock ( & LOCK_global_system_variables ) ;
}
else thd -> variables . old_passwords = 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void init_dequantizer ( Vp3DecodeContext * s , int qpi ) {
int ac_scale_factor = s -> coded_ac_scale_factor [ s -> qps [ qpi ] ] ;
int dc_scale_factor = s -> coded_dc_scale_factor [ s -> qps [ qpi ] ] ;
int i , plane , inter , qri , bmi , bmj , qistart ;
for ( inter = 0 ;
inter < 2 ;
inter ++ ) {
for ( plane = 0 ;
plane < 3 ;
plane ++ ) {
int sum = 0 ;
for ( qri = 0 ;
qri < s -> qr_count [ inter ] [ plane ] ;
qri ++ ) {
sum += s -> qr_size [ inter ] [ plane ] [ qri ] ;
if ( s -> qps [ qpi ] <= sum ) break ;
}
qistart = sum - s -> qr_size [ inter ] [ plane ] [ qri ] ;
bmi = s -> qr_base [ inter ] [ plane ] [ qri ] ;
bmj = s -> qr_base [ inter ] [ plane ] [ qri + 1 ] ;
for ( i = 0 ;
i < 64 ;
i ++ ) {
int coeff = ( 2 * ( sum - s -> qps [ qpi ] ) * s -> base_matrix [ bmi ] [ i ] - 2 * ( qistart - s -> qps [ qpi ] ) * s -> base_matrix [ bmj ] [ i ] + s -> qr_size [ inter ] [ plane ] [ qri ] ) / ( 2 * s -> qr_size [ inter ] [ plane ] [ qri ] ) ;
int qmin = 8 << ( inter + ! i ) ;
int qscale = i ? ac_scale_factor : dc_scale_factor ;
s -> qmat [ qpi ] [ inter ] [ plane ] [ s -> dsp . idct_permutation [ i ] ] = av_clip ( ( qscale * coeff ) / 100 * 4 , qmin , 4096 ) ;
}
s -> qmat [ qpi ] [ inter ] [ plane ] [ 0 ] = s -> qmat [ 0 ] [ inter ] [ plane ] [ 0 ] ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dumpcffcidhmtx ( struct alltabs * at , SplineFont * _sf ) {
DBounds b ;
SplineChar * sc ;
int cid , i , cnt = 0 , max ;
SplineFont * sf ;
int dovmetrics = _sf -> hasvmetrics ;
at -> gi . hmtx = tmpfile ( ) ;
if ( dovmetrics ) at -> gi . vmtx = tmpfile ( ) ;
FigureFullMetricsEnd ( _sf , & at -> gi , false ) ;
max = 0 ;
for ( i = 0 ;
i < _sf -> subfontcnt ;
++ i ) if ( max < _sf -> subfonts [ i ] -> glyphcnt ) max = _sf -> subfonts [ i ] -> glyphcnt ;
for ( cid = 0 ;
cid < max ;
++ cid ) {
for ( i = 0 ;
i < _sf -> subfontcnt ;
++ i ) {
sf = _sf -> subfonts [ i ] ;
if ( cid < sf -> glyphcnt && SCWorthOutputting ( sf -> glyphs [ cid ] ) ) break ;
}
if ( i != _sf -> subfontcnt ) {
sc = sf -> glyphs [ cid ] ;
if ( sc -> ttf_glyph <= at -> gi . lasthwidth ) putshort ( at -> gi . hmtx , sc -> width ) ;
SplineCharLayerFindBounds ( sc , at -> gi . layer , & b ) ;
putshort ( at -> gi . hmtx , b . minx ) ;
if ( dovmetrics ) {
if ( sc -> ttf_glyph <= at -> gi . lastvwidth ) putshort ( at -> gi . vmtx , sc -> vwidth ) ;
putshort ( at -> gi . vmtx , b . maxy ) ;
}
++ cnt ;
if ( sc -> ttf_glyph == at -> gi . lasthwidth ) at -> gi . hfullcnt = cnt ;
if ( sc -> ttf_glyph == at -> gi . lastvwidth ) at -> gi . vfullcnt = cnt ;
}
else if ( cid == 0 ) {
sf = _sf -> subfonts [ 0 ] ;
putshort ( at -> gi . hmtx , sf -> ascent + sf -> descent ) ;
putshort ( at -> gi . hmtx , 0 ) ;
++ cnt ;
if ( dovmetrics ) {
putshort ( at -> gi . vmtx , sf -> ascent + sf -> descent ) ;
putshort ( at -> gi . vmtx , 0 ) ;
}
}
}
at -> gi . hmtxlen = ftell ( at -> gi . hmtx ) ;
if ( at -> gi . hmtxlen & 2 ) putshort ( at -> gi . hmtx , 0 ) ;
if ( dovmetrics ) {
at -> gi . vmtxlen = ftell ( at -> gi . vmtx ) ;
if ( at -> gi . vmtxlen & 2 ) putshort ( at -> gi . vmtx , 0 ) ;
}
at -> gi . maxp -> numGlyphs = cnt ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * default_opaque_literal_tag ( tvbuff_t * tvb , guint32 offset , const char * token _U_ , guint8 codepage _U_ , guint32 * length ) {
guint32 data_len = tvb_get_guintvar ( tvb , offset , length ) ;
char * str = wmem_strdup_printf ( wmem_packet_scope ( ) , "(%d bytes of opaque data)" , data_len ) ;
* length += data_len ;
return str ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_zcl_groups_add_remove_group_response ( tvbuff_t * tvb , proto_tree * tree , guint * offset ) {
proto_tree_add_item ( tree , hf_zbee_zcl_groups_status , tvb , * offset , 1 , ENC_LITTLE_ENDIAN ) ;
* offset += 1 ;
proto_tree_add_item ( tree , hf_zbee_zcl_groups_group_id , tvb , * offset , 2 , ENC_LITTLE_ENDIAN ) ;
* offset += 2 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void init_signals ( void ) {
sigset_t set ;
struct sigaction sa ;
DBUG_ENTER ( "init_signals" ) ;
my_sigset ( THR_SERVER_ALARM , print_signal_warning ) ;
if ( opt_stack_trace || ( test_flags & TEST_CORE_ON_SIGNAL ) ) {
sa . sa_flags = SA_RESETHAND | SA_NODEFER ;
sigemptyset ( & sa . sa_mask ) ;
sigprocmask ( SIG_SETMASK , & sa . sa_mask , NULL ) ;
my_init_stacktrace ( ) ;
# if defined ( __amiga__ ) sa . sa_handler = ( void ( * ) ( ) ) handle_fatal_signal ;
# else sa . sa_handler = handle_fatal_signal ;
# endif sigaction ( SIGSEGV , & sa , NULL ) ;
sigaction ( SIGABRT , & sa , NULL ) ;
# ifdef SIGBUS sigaction ( SIGBUS , & sa , NULL ) ;
# endif sigaction ( SIGILL , & sa , NULL ) ;
sigaction ( SIGFPE , & sa , NULL ) ;
}
# ifdef HAVE_GETRLIMIT if ( test_flags & TEST_CORE_ON_SIGNAL ) {
STRUCT_RLIMIT rl ;
rl . rlim_cur = rl . rlim_max = ( rlim_t ) RLIM_INFINITY ;
if ( setrlimit ( RLIMIT_CORE , & rl ) && global_system_variables . log_warnings ) sql_print_warning ( "setrlimit could not change the size of core files to 'infinity';
We may not be able to generate a core file on signals" ) ;
}
# endif ( void ) sigemptyset ( & set ) ;
my_sigset ( SIGPIPE , SIG_IGN ) ;
sigaddset ( & set , SIGPIPE ) ;
# ifndef IGNORE_SIGHUP_SIGQUIT sigaddset ( & set , SIGQUIT ) ;
sigaddset ( & set , SIGHUP ) ;
# endif sigaddset ( & set , SIGTERM ) ;
sigemptyset ( & sa . sa_mask ) ;
sa . sa_flags = 0 ;
sa . sa_handler = print_signal_warning ;
sigaction ( SIGTERM , & sa , ( struct sigaction * ) 0 ) ;
sa . sa_flags = 0 ;
sa . sa_handler = print_signal_warning ;
sigaction ( SIGHUP , & sa , ( struct sigaction * ) 0 ) ;
if ( thd_lib_detected != THD_LIB_LT ) sigaddset ( & set , THR_SERVER_ALARM ) ;
if ( test_flags & TEST_SIGINT ) {
my_sigset ( SIGINT , end_mysqld_signal ) ;
sigdelset ( & set , SIGINT ) ;
}
else {
sigaddset ( & set , SIGINT ) ;
# ifdef SIGTSTP sigaddset ( & set , SIGTSTP ) ;
# endif }
sigprocmask ( SIG_SETMASK , & set , NULL ) ;
pthread_sigmask ( SIG_SETMASK , & set , NULL ) ;
DBUG_VOID_RETURN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
afs_int32 SPR_UpdateEntry ( struct rx_call * call , afs_int32 aid , char * name , struct PrUpdateEntry * uentry ) {
afs_int32 code ;
afs_int32 cid = ANONYMOUSID ;
code = UpdateEntry ( call , aid , name , uentry , & cid ) ;
osi_auditU ( call , PTS_UpdEntEvent , code , AUD_ID , aid , AUD_STR , name , AUD_END ) ;
ViceLog ( 5 , ( "PTS_UpdateEntry: code %d cid %d aid %d name %s\n" , code , cid , aid , name ) ) ;
return code ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static CodeBook unpack_codebook ( GetBitContext * gb , unsigned depth , unsigned size ) {
unsigned i , j ;
CodeBook cb = {
0 }
;
if ( ! can_safely_read ( gb , size * 34 ) ) return cb ;
if ( size >= INT_MAX / sizeof ( MacroBlock ) ) return cb ;
cb . blocks = av_malloc ( size ? size * sizeof ( MacroBlock ) : 1 ) ;
if ( ! cb . blocks ) return cb ;
cb . depth = depth ;
cb . size = size ;
for ( i = 0 ;
i < size ;
i ++ ) {
unsigned mask_bits = get_bits ( gb , 4 ) ;
unsigned color0 = get_bits ( gb , 15 ) ;
unsigned color1 = get_bits ( gb , 15 ) ;
for ( j = 0 ;
j < 4 ;
j ++ ) {
if ( mask_bits & ( 1 << j ) ) cb . blocks [ i ] . pixels [ j ] = color1 ;
else cb . blocks [ i ] . pixels [ j ] = color0 ;
}
}
return cb ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int read_sbr_single_channel_element ( AACContext * ac , SpectralBandReplication * sbr , GetBitContext * gb ) {
if ( get_bits1 ( gb ) ) skip_bits ( gb , 4 ) ;
if ( read_sbr_grid ( ac , sbr , gb , & sbr -> data [ 0 ] ) ) return - 1 ;
read_sbr_dtdf ( sbr , gb , & sbr -> data [ 0 ] ) ;
read_sbr_invf ( sbr , gb , & sbr -> data [ 0 ] ) ;
read_sbr_envelope ( sbr , gb , & sbr -> data [ 0 ] , 0 ) ;
read_sbr_noise ( sbr , gb , & sbr -> data [ 0 ] , 0 ) ;
if ( ( sbr -> data [ 0 ] . bs_add_harmonic_flag = get_bits1 ( gb ) ) ) get_bits1_vector ( gb , sbr -> data [ 0 ] . bs_add_harmonic , sbr -> n [ 1 ] ) ;
return 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static unsigned long write_reuse_object ( struct sha1file * f , struct object_entry * entry , unsigned long limit , int usable_delta ) {
struct packed_git * p = entry -> in_pack ;
struct pack_window * w_curs = NULL ;
struct revindex_entry * revidx ;
off_t offset ;
enum object_type type = entry -> type ;
unsigned long datalen ;
unsigned char header [ 10 ] , dheader [ 10 ] ;
unsigned hdrlen ;
if ( entry -> delta ) type = ( allow_ofs_delta && entry -> delta -> idx . offset ) ? OBJ_OFS_DELTA : OBJ_REF_DELTA ;
hdrlen = encode_in_pack_object_header ( type , entry -> size , header ) ;
offset = entry -> in_pack_offset ;
revidx = find_pack_revindex ( p , offset ) ;
datalen = revidx [ 1 ] . offset - offset ;
if ( ! pack_to_stdout && p -> index_version > 1 && check_pack_crc ( p , & w_curs , offset , datalen , revidx -> nr ) ) {
error ( "bad packed object CRC for %s" , sha1_to_hex ( entry -> idx . sha1 ) ) ;
unuse_pack ( & w_curs ) ;
return write_no_reuse_object ( f , entry , limit , usable_delta ) ;
}
offset += entry -> in_pack_header_size ;
datalen -= entry -> in_pack_header_size ;
if ( ! pack_to_stdout && p -> index_version == 1 && check_pack_inflate ( p , & w_curs , offset , datalen , entry -> size ) ) {
error ( "corrupt packed object for %s" , sha1_to_hex ( entry -> idx . sha1 ) ) ;
unuse_pack ( & w_curs ) ;
return write_no_reuse_object ( f , entry , limit , usable_delta ) ;
}
if ( type == OBJ_OFS_DELTA ) {
off_t ofs = entry -> idx . offset - entry -> delta -> idx . offset ;
unsigned pos = sizeof ( dheader ) - 1 ;
dheader [ pos ] = ofs & 127 ;
while ( ofs >>= 7 ) dheader [ -- pos ] = 128 | ( -- ofs & 127 ) ;
if ( limit && hdrlen + sizeof ( dheader ) - pos + datalen + 20 >= limit ) {
unuse_pack ( & w_curs ) ;
return 0 ;
}
sha1write ( f , header , hdrlen ) ;
sha1write ( f , dheader + pos , sizeof ( dheader ) - pos ) ;
hdrlen += sizeof ( dheader ) - pos ;
reused_delta ++ ;
}
else if ( type == OBJ_REF_DELTA ) {
if ( limit && hdrlen + 20 + datalen + 20 >= limit ) {
unuse_pack ( & w_curs ) ;
return 0 ;
}
sha1write ( f , header , hdrlen ) ;
sha1write ( f , entry -> delta -> idx . sha1 , 20 ) ;
hdrlen += 20 ;
reused_delta ++ ;
}
else {
if ( limit && hdrlen + datalen + 20 >= limit ) {
unuse_pack ( & w_curs ) ;
return 0 ;
}
sha1write ( f , header , hdrlen ) ;
}
copy_pack_data ( f , p , & w_curs , offset , datalen ) ;
unuse_pack ( & w_curs ) ;
reused ++ ;
return hdrlen + datalen ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ohci_attach ( USBPort * port1 ) {
OHCIState * s = port1 -> opaque ;
OHCIPort * port = & s -> rhport [ port1 -> index ] ;
uint32_t old_state = port -> ctrl ;
port -> ctrl |= OHCI_PORT_CCS | OHCI_PORT_CSC ;
if ( port -> port . dev -> speed == USB_SPEED_LOW ) {
port -> ctrl |= OHCI_PORT_LSDA ;
}
else {
port -> ctrl &= ~ OHCI_PORT_LSDA ;
}
if ( ( s -> ctl & OHCI_CTL_HCFS ) == OHCI_USB_SUSPEND ) {
ohci_set_interrupt ( s , OHCI_INTR_RD ) ;
}
trace_usb_ohci_port_attach ( port1 -> index ) ;
if ( old_state != port -> ctrl ) {
ohci_set_interrupt ( s , OHCI_INTR_RHSC ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
xmlStructuredErrorFunc * __xmlStructuredError ( void ) {
if ( IS_MAIN_THREAD ) return ( & xmlStructuredError ) ;
else return ( & xmlGetGlobalState ( ) -> xmlStructuredError ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int AssignTTFBitGlyph ( struct glyphinfo * gi , SplineFont * sf , EncMap * map , int32 * bsizes ) {
int i , j ;
BDFFont * bdf ;
int * bygid = malloc ( ( sf -> glyphcnt + 3 ) * sizeof ( int ) ) ;
memset ( bygid , 0xff , ( sf -> glyphcnt + 3 ) * sizeof ( int ) ) ;
AssignNotdefNull ( sf , bygid , false ) ;
for ( bdf = sf -> bitmaps ;
bdf != NULL ;
bdf = bdf -> next ) {
for ( j = 0 ;
bsizes [ j ] != 0 && ( ( bsizes [ j ] & 0xffff ) != bdf -> pixelsize || ( bsizes [ j ] >> 16 ) != BDFDepth ( bdf ) ) ;
++ j ) ;
if ( bsizes [ j ] == 0 ) continue ;
for ( i = 0 ;
i < bdf -> glyphcnt ;
++ i ) if ( ! IsntBDFChar ( bdf -> glyphs [ i ] ) ) sf -> glyphs [ i ] -> ttf_glyph = - 2 ;
}
j = 3 ;
for ( i = 0 ;
i < map -> enccount ;
++ i ) if ( map -> map [ i ] != - 1 ) {
SplineChar * sc = sf -> glyphs [ map -> map [ i ] ] ;
if ( sc -> ttf_glyph == - 2 ) {
sc -> ttf_glyph = j ;
bygid [ j ++ ] = sc -> orig_pos ;
}
}
for ( i = 0 ;
i < sf -> glyphcnt ;
++ i ) if ( sf -> glyphs [ i ] != NULL ) {
SplineChar * sc = sf -> glyphs [ i ] ;
if ( sc -> ttf_glyph == - 2 ) {
sc -> ttf_glyph = j ;
bygid [ j ++ ] = i ;
}
}
gi -> bygid = bygid ;
gi -> gcnt = j ;
return j ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Dwarf_Small dwarf_elf_object_access_get_length_size ( void * obj_in ) {
dwarf_elf_object_access_internals_t * obj = ( dwarf_elf_object_access_internals_t * ) obj_in ;
return obj -> length_size ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_pvfs2_mgmt_event_mon_response ( tvbuff_t * tvb , proto_tree * tree , int offset ) {
proto_tree_add_item ( tree , hf_pvfs_mgmt_event_mon_response_api , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( tree , hf_pvfs_mgmt_event_mon_response_operation , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( tree , hf_pvfs_mgmt_event_mon_response_value , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
offset = dissect_pvfs_uint64 ( tvb , tree , offset , hf_pvfs_id_gen_t , NULL ) ;
proto_tree_add_item ( tree , hf_pvfs_mgmt_event_mon_response_flags , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( tree , hf_pvfs_mgmt_event_mon_response_tv_sec , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( tree , hf_pvfs_mgmt_event_mon_response_tv_usec , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ;
offset += 4 ;
offset += 4 ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int mvsad_err_cost ( const MACROBLOCK * x , const MV * mv , const MV * ref , int error_per_bit ) {
if ( x -> nmvsadcost ) {
const MV diff = {
mv -> row - ref -> row , mv -> col - ref -> col }
;
return ROUND_POWER_OF_TWO ( mv_cost ( & diff , x -> nmvjointsadcost , x -> nmvsadcost ) * error_per_bit , 8 ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int wma_decode_block ( WMACodecContext * s ) {
int n , v , a , ch , bsize ;
int coef_nb_bits , total_gain ;
int nb_coefs [ MAX_CHANNELS ] ;
float mdct_norm ;
FFTContext * mdct ;
# ifdef TRACE tprintf ( s -> avctx , "***decode_block: %d:%d\n" , s -> frame_count - 1 , s -> block_num ) ;
# endif if ( s -> use_variable_block_len ) {
n = av_log2 ( s -> nb_block_sizes - 1 ) + 1 ;
if ( s -> reset_block_lengths ) {
s -> reset_block_lengths = 0 ;
v = get_bits ( & s -> gb , n ) ;
if ( v >= s -> nb_block_sizes ) {
av_log ( s -> avctx , AV_LOG_ERROR , "prev_block_len_bits %d out of range\n" , s -> frame_len_bits - v ) ;
return - 1 ;
}
s -> prev_block_len_bits = s -> frame_len_bits - v ;
v = get_bits ( & s -> gb , n ) ;
if ( v >= s -> nb_block_sizes ) {
av_log ( s -> avctx , AV_LOG_ERROR , "block_len_bits %d out of range\n" , s -> frame_len_bits - v ) ;
return - 1 ;
}
s -> block_len_bits = s -> frame_len_bits - v ;
}
else {
s -> prev_block_len_bits = s -> block_len_bits ;
s -> block_len_bits = s -> next_block_len_bits ;
}
v = get_bits ( & s -> gb , n ) ;
if ( v >= s -> nb_block_sizes ) {
av_log ( s -> avctx , AV_LOG_ERROR , "next_block_len_bits %d out of range\n" , s -> frame_len_bits - v ) ;
return - 1 ;
}
s -> next_block_len_bits = s -> frame_len_bits - v ;
}
else {
s -> next_block_len_bits = s -> frame_len_bits ;
s -> prev_block_len_bits = s -> frame_len_bits ;
s -> block_len_bits = s -> frame_len_bits ;
}
s -> block_len = 1 << s -> block_len_bits ;
if ( ( s -> block_pos + s -> block_len ) > s -> frame_len ) {
av_log ( s -> avctx , AV_LOG_ERROR , "frame_len overflow\n" ) ;
return - 1 ;
}
if ( s -> avctx -> channels == 2 ) {
s -> ms_stereo = get_bits1 ( & s -> gb ) ;
}
v = 0 ;
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
a = get_bits1 ( & s -> gb ) ;
s -> channel_coded [ ch ] = a ;
v |= a ;
}
bsize = s -> frame_len_bits - s -> block_len_bits ;
if ( ! v ) goto next ;
total_gain = 1 ;
for ( ;
;
) {
a = get_bits ( & s -> gb , 7 ) ;
total_gain += a ;
if ( a != 127 ) break ;
}
coef_nb_bits = ff_wma_total_gain_to_bits ( total_gain ) ;
n = s -> coefs_end [ bsize ] - s -> coefs_start ;
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) nb_coefs [ ch ] = n ;
if ( s -> use_noise_coding ) {
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
if ( s -> channel_coded [ ch ] ) {
int i , n , a ;
n = s -> exponent_high_sizes [ bsize ] ;
for ( i = 0 ;
i < n ;
i ++ ) {
a = get_bits1 ( & s -> gb ) ;
s -> high_band_coded [ ch ] [ i ] = a ;
if ( a ) nb_coefs [ ch ] -= s -> exponent_high_bands [ bsize ] [ i ] ;
}
}
}
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
if ( s -> channel_coded [ ch ] ) {
int i , n , val , code ;
n = s -> exponent_high_sizes [ bsize ] ;
val = ( int ) 0x80000000 ;
for ( i = 0 ;
i < n ;
i ++ ) {
if ( s -> high_band_coded [ ch ] [ i ] ) {
if ( val == ( int ) 0x80000000 ) {
val = get_bits ( & s -> gb , 7 ) - 19 ;
}
else {
code = get_vlc2 ( & s -> gb , s -> hgain_vlc . table , HGAINVLCBITS , HGAINMAX ) ;
if ( code < 0 ) {
av_log ( s -> avctx , AV_LOG_ERROR , "hgain vlc invalid\n" ) ;
return - 1 ;
}
val += code - 18 ;
}
s -> high_band_values [ ch ] [ i ] = val ;
}
}
}
}
}
if ( ( s -> block_len_bits == s -> frame_len_bits ) || get_bits1 ( & s -> gb ) ) {
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
if ( s -> channel_coded [ ch ] ) {
if ( s -> use_exp_vlc ) {
if ( decode_exp_vlc ( s , ch ) < 0 ) return - 1 ;
}
else {
decode_exp_lsp ( s , ch ) ;
}
s -> exponents_bsize [ ch ] = bsize ;
}
}
}
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
if ( s -> channel_coded [ ch ] ) {
int tindex ;
WMACoef * ptr = & s -> coefs1 [ ch ] [ 0 ] ;
tindex = ( ch == 1 && s -> ms_stereo ) ;
memset ( ptr , 0 , s -> block_len * sizeof ( WMACoef ) ) ;
ff_wma_run_level_decode ( s -> avctx , & s -> gb , & s -> coef_vlc [ tindex ] , s -> level_table [ tindex ] , s -> run_table [ tindex ] , 0 , ptr , 0 , nb_coefs [ ch ] , s -> block_len , s -> frame_len_bits , coef_nb_bits ) ;
}
if ( s -> version == 1 && s -> avctx -> channels >= 2 ) {
align_get_bits ( & s -> gb ) ;
}
}
{
int n4 = s -> block_len / 2 ;
mdct_norm = 1.0 / ( float ) n4 ;
if ( s -> version == 1 ) {
mdct_norm *= sqrt ( n4 ) ;
}
}
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
if ( s -> channel_coded [ ch ] ) {
WMACoef * coefs1 ;
float * coefs , * exponents , mult , mult1 , noise ;
int i , j , n , n1 , last_high_band , esize ;
float exp_power [ HIGH_BAND_MAX_SIZE ] ;
coefs1 = s -> coefs1 [ ch ] ;
exponents = s -> exponents [ ch ] ;
esize = s -> exponents_bsize [ ch ] ;
mult = pow ( 10 , total_gain * 0.05 ) / s -> max_exponent [ ch ] ;
mult *= mdct_norm ;
coefs = s -> coefs [ ch ] ;
if ( s -> use_noise_coding ) {
mult1 = mult ;
for ( i = 0 ;
i < s -> coefs_start ;
i ++ ) {
* coefs ++ = s -> noise_table [ s -> noise_index ] * exponents [ i << bsize >> esize ] * mult1 ;
s -> noise_index = ( s -> noise_index + 1 ) & ( NOISE_TAB_SIZE - 1 ) ;
}
n1 = s -> exponent_high_sizes [ bsize ] ;
exponents = s -> exponents [ ch ] + ( s -> high_band_start [ bsize ] << bsize >> esize ) ;
last_high_band = 0 ;
for ( j = 0 ;
j < n1 ;
j ++ ) {
n = s -> exponent_high_bands [ s -> frame_len_bits - s -> block_len_bits ] [ j ] ;
if ( s -> high_band_coded [ ch ] [ j ] ) {
float e2 , v ;
e2 = 0 ;
for ( i = 0 ;
i < n ;
i ++ ) {
v = exponents [ i << bsize >> esize ] ;
e2 += v * v ;
}
exp_power [ j ] = e2 / n ;
last_high_band = j ;
tprintf ( s -> avctx , "%d: power=%f (%d)\n" , j , exp_power [ j ] , n ) ;
}
exponents += n << bsize >> esize ;
}
exponents = s -> exponents [ ch ] + ( s -> coefs_start << bsize >> esize ) ;
for ( j = - 1 ;
j < n1 ;
j ++ ) {
if ( j < 0 ) {
n = s -> high_band_start [ bsize ] - s -> coefs_start ;
}
else {
n = s -> exponent_high_bands [ s -> frame_len_bits - s -> block_len_bits ] [ j ] ;
}
if ( j >= 0 && s -> high_band_coded [ ch ] [ j ] ) {
mult1 = sqrt ( exp_power [ j ] / exp_power [ last_high_band ] ) ;
mult1 = mult1 * pow ( 10 , s -> high_band_values [ ch ] [ j ] * 0.05 ) ;
mult1 = mult1 / ( s -> max_exponent [ ch ] * s -> noise_mult ) ;
mult1 *= mdct_norm ;
for ( i = 0 ;
i < n ;
i ++ ) {
noise = s -> noise_table [ s -> noise_index ] ;
s -> noise_index = ( s -> noise_index + 1 ) & ( NOISE_TAB_SIZE - 1 ) ;
* coefs ++ = noise * exponents [ i << bsize >> esize ] * mult1 ;
}
exponents += n << bsize >> esize ;
}
else {
for ( i = 0 ;
i < n ;
i ++ ) {
noise = s -> noise_table [ s -> noise_index ] ;
s -> noise_index = ( s -> noise_index + 1 ) & ( NOISE_TAB_SIZE - 1 ) ;
* coefs ++ = ( ( * coefs1 ++ ) + noise ) * exponents [ i << bsize >> esize ] * mult ;
}
exponents += n << bsize >> esize ;
}
}
n = s -> block_len - s -> coefs_end [ bsize ] ;
mult1 = mult * exponents [ ( ( - 1 << bsize ) ) >> esize ] ;
for ( i = 0 ;
i < n ;
i ++ ) {
* coefs ++ = s -> noise_table [ s -> noise_index ] * mult1 ;
s -> noise_index = ( s -> noise_index + 1 ) & ( NOISE_TAB_SIZE - 1 ) ;
}
}
else {
for ( i = 0 ;
i < s -> coefs_start ;
i ++ ) * coefs ++ = 0.0 ;
n = nb_coefs [ ch ] ;
for ( i = 0 ;
i < n ;
i ++ ) {
* coefs ++ = coefs1 [ i ] * exponents [ i << bsize >> esize ] * mult ;
}
n = s -> block_len - s -> coefs_end [ bsize ] ;
for ( i = 0 ;
i < n ;
i ++ ) * coefs ++ = 0.0 ;
}
}
}
# ifdef TRACE for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
if ( s -> channel_coded [ ch ] ) {
dump_floats ( s , "exponents" , 3 , s -> exponents [ ch ] , s -> block_len ) ;
dump_floats ( s , "coefs" , 1 , s -> coefs [ ch ] , s -> block_len ) ;
}
}
# endif if ( s -> ms_stereo && s -> channel_coded [ 1 ] ) {
if ( ! s -> channel_coded [ 0 ] ) {
tprintf ( s -> avctx , "rare ms-stereo case happened\n" ) ;
memset ( s -> coefs [ 0 ] , 0 , sizeof ( float ) * s -> block_len ) ;
s -> channel_coded [ 0 ] = 1 ;
}
s -> fdsp . butterflies_float ( s -> coefs [ 0 ] , s -> coefs [ 1 ] , s -> block_len ) ;
}
next : mdct = & s -> mdct_ctx [ bsize ] ;
for ( ch = 0 ;
ch < s -> avctx -> channels ;
ch ++ ) {
int n4 , index ;
n4 = s -> block_len / 2 ;
if ( s -> channel_coded [ ch ] ) {
mdct -> imdct_calc ( mdct , s -> output , s -> coefs [ ch ] ) ;
}
else if ( ! ( s -> ms_stereo && ch == 1 ) ) memset ( s -> output , 0 , sizeof ( s -> output ) ) ;
index = ( s -> frame_len / 2 ) + s -> block_pos - n4 ;
wma_window ( s , & s -> frame_out [ ch ] [ index ] ) ;
}
s -> block_num ++ ;
s -> block_pos += s -> block_len ;
if ( s -> block_pos >= s -> frame_len ) return 1 ;
else return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExternalProtocolHandlerTest , DISABLED_TestLaunchSchemeUnknownChromeNotDefault ) {
DoTest ( ExternalProtocolHandler : : UNKNOWN , shell_integration : : NOT_DEFAULT , Action : : PROMPT ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int tm_atnode ( tm_task_id tid , tm_node_id * node ) {
task_info * tp ;
if ( ! init_done ) return TM_BADINIT ;
if ( ( tp = find_task ( tid ) ) == NULL ) return TM_ENOTFOUND ;
* node = tp -> t_node ;
return TM_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void gic_init_irqs_and_distributor ( GICState * s , int num_irq ) {
int i ;
i = s -> num_irq - GIC_INTERNAL ;
if ( s -> revision != REV_NVIC ) {
i += ( GIC_INTERNAL * s -> num_cpu ) ;
}
qdev_init_gpio_in ( & s -> busdev . qdev , gic_set_irq , i ) ;
for ( i = 0 ;
i < NUM_CPU ( s ) ;
i ++ ) {
sysbus_init_irq ( & s -> busdev , & s -> parent_irq [ i ] ) ;
}
memory_region_init_io ( & s -> iomem , OBJECT ( s ) , & gic_dist_ops , s , "gic_dist" , 0x1000 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static time_t _warc_rdrtm ( const char * buf , size_t bsz ) {
static const char _key [ ] = "\r\nWARC-Date:" ;
const char * val , * eol ;
char * on = NULL ;
time_t res ;
if ( ( val = xmemmem ( buf , bsz , _key , sizeof ( _key ) - 1U ) ) == NULL ) {
return ( time_t ) - 1 ;
}
val += sizeof ( _key ) - 1U ;
if ( ( eol = _warc_find_eol ( val , buf + bsz - val ) ) == NULL ) {
return - 1 ;
}
res = xstrpisotime ( val , & on ) ;
if ( on != eol ) {
return - 1 ;
}
return res ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int x ( struct vcache * avc , int afun , struct vrequest * areq , \ struct afs_pdata * ain , struct afs_pdata * aout , \ afs_ucred_t * * acred ) DECL_PIOCTL ( PGetFID ) ;
DECL_PIOCTL ( PSetAcl ) ;
DECL_PIOCTL ( PStoreBehind ) ;
DECL_PIOCTL ( PGCPAGs ) ;
DECL_PIOCTL ( PGetAcl ) ;
DECL_PIOCTL ( PNoop ) ;
DECL_PIOCTL ( PBogus ) ;
DECL_PIOCTL ( PGetFileCell ) ;
DECL_PIOCTL ( PGetWSCell ) ;
DECL_PIOCTL ( PGetUserCell ) ;
DECL_PIOCTL ( PSetTokens ) ;
DECL_PIOCTL ( PGetVolumeStatus ) ;
DECL_PIOCTL ( PSetVolumeStatus ) ;
DECL_PIOCTL ( PFlush ) ;
DECL_PIOCTL ( PNewStatMount ) ;
DECL_PIOCTL ( PGetTokens ) ;
DECL_PIOCTL ( PUnlog ) ;
DECL_PIOCTL ( PMariner ) ;
DECL_PIOCTL ( PCheckServers ) ;
DECL_PIOCTL ( PCheckVolNames ) ;
DECL_PIOCTL ( PCheckAuth ) ;
DECL_PIOCTL ( PFindVolume )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp9_compute_rd_mult ( const VP9_COMP * cpi , int qindex ) {
const int q = vp9_dc_quant ( qindex , 0 , cpi -> common . bit_depth ) ;
# if CONFIG_VP9_HIGHBITDEPTH int rdmult = 0 ;
switch ( cpi -> common . bit_depth ) {
case VPX_BITS_8 : rdmult = 88 * q * q / 24 ;
break ;
case VPX_BITS_10 : rdmult = ROUND_POWER_OF_TWO ( 88 * q * q / 24 , 4 ) ;
break ;
case VPX_BITS_12 : rdmult = ROUND_POWER_OF_TWO ( 88 * q * q / 24 , 8 ) ;
break ;
default : assert ( 0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12" ) ;
return - 1 ;
}
# else int rdmult = 88 * q * q / 24 ;
# endif if ( cpi -> oxcf . pass == 2 && ( cpi -> common . frame_type != KEY_FRAME ) ) {
const GF_GROUP * const gf_group = & cpi -> twopass . gf_group ;
const FRAME_UPDATE_TYPE frame_type = gf_group -> update_type [ gf_group -> index ] ;
const int boost_index = MIN ( 15 , ( cpi -> rc . gfu_boost / 100 ) ) ;
rdmult = ( rdmult * rd_frame_type_factor [ frame_type ] ) >> 7 ;
rdmult += ( ( rdmult * rd_boost_factor [ boost_index ] ) >> 7 ) ;
}
return rdmult ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_fht8x8_c ( const int16_t * input , int16_t * output , int stride , int tx_type ) {
if ( tx_type == DCT_DCT ) {
vp9_fdct8x8_c ( input , output , stride ) ;
}
else {
int16_t out [ 64 ] ;
int16_t * outptr = & out [ 0 ] ;
int i , j ;
int16_t temp_in [ 8 ] , temp_out [ 8 ] ;
const transform_2d ht = FHT_8 [ tx_type ] ;
for ( i = 0 ;
i < 8 ;
++ i ) {
for ( j = 0 ;
j < 8 ;
++ j ) temp_in [ j ] = input [ j * stride + i ] * 4 ;
ht . cols ( temp_in , temp_out ) ;
for ( j = 0 ;
j < 8 ;
++ j ) outptr [ j * 8 + i ] = temp_out [ j ] ;
}
for ( i = 0 ;
i < 8 ;
++ i ) {
for ( j = 0 ;
j < 8 ;
++ j ) temp_in [ j ] = out [ j + i * 8 ] ;
ht . rows ( temp_in , temp_out ) ;
for ( j = 0 ;
j < 8 ;
++ j ) output [ j + i * 8 ] = ( temp_out [ j ] + ( temp_out [ j ] < 0 ) ) >> 1 ;
}
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void unset_trap ( struct recvbuf * rbufp , int restrict_mask ) {
int traptype ;
traptype = TRAP_TYPE_PRIO ;
if ( restrict_mask & RES_LPTRAP ) traptype = TRAP_TYPE_NONPRIO ;
if ( ! ctlclrtrap ( & rbufp -> recv_srcadr , rbufp -> dstadr , traptype ) ) ctl_error ( CERR_BADASSOC ) ;
ctl_flushpkt ( 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int task_has_system ( struct task_struct * tsk , u32 perms ) {
u32 sid = task_sid ( tsk ) ;
return avc_has_perm ( sid , SECINITSID_KERNEL , SECCLASS_SYSTEM , perms , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pitch_sharpening ( AMRContext * p , int subframe , enum Mode mode , AMRFixed * fixed_sparse ) {
if ( mode == MODE_12k2 ) p -> beta = FFMIN ( p -> pitch_gain [ 4 ] , 1.0 ) ;
fixed_sparse -> pitch_lag = p -> pitch_lag_int ;
fixed_sparse -> pitch_fac = p -> beta ;
if ( mode != MODE_4k75 || subframe & 1 ) p -> beta = av_clipf ( p -> pitch_gain [ 4 ] , 0.0 , SHARP_MAX ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void var_free ( void * v ) {
VAR * var = ( VAR * ) v ;
my_free ( var -> str_val ) ;
if ( var -> alloced ) my_free ( var ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void config_auth ( config_tree * ptree ) {
attr_val * my_val ;
int first ;
int last ;
int i ;
# ifdef AUTOKEY int item ;
# endif # ifdef AUTOKEY item = - 1 ;
my_val = HEAD_PFIFO ( ptree -> auth . crypto_cmd_list ) ;
for ( ;
my_val != NULL ;
my_val = my_val -> link ) {
switch ( my_val -> attr ) {
default : NTP_INSIST ( 0 ) ;
break ;
case T_Host : item = CRYPTO_CONF_PRIV ;
break ;
case T_Ident : item = CRYPTO_CONF_IDENT ;
break ;
case T_Pw : item = CRYPTO_CONF_PW ;
break ;
case T_Randfile : item = CRYPTO_CONF_RAND ;
break ;
case T_Digest : item = CRYPTO_CONF_NID ;
break ;
}
crypto_config ( item , my_val -> value . s ) ;
}
# endif if ( ptree -> auth . keysdir ) {
if ( keysdir != default_keysdir ) free ( keysdir ) ;
keysdir = estrdup ( ptree -> auth . keysdir ) ;
}
if ( ptree -> auth . ntp_signd_socket ) {
if ( ntp_signd_socket != default_ntp_signd_socket ) free ( ntp_signd_socket ) ;
ntp_signd_socket = estrdup ( ptree -> auth . ntp_signd_socket ) ;
}
# ifdef AUTOKEY if ( ptree -> auth . cryptosw && ! cryptosw ) {
crypto_setup ( ) ;
cryptosw = 1 ;
}
# endif if ( ptree -> auth . keys ) getauthkeys ( ptree -> auth . keys ) ;
if ( ptree -> auth . control_key ) ctl_auth_keyid = ( keyid_t ) ptree -> auth . control_key ;
if ( ptree -> auth . request_key ) {
DPRINTF ( 4 , ( "set info_auth_keyid to %08lx\n" , ( u_long ) ptree -> auth . request_key ) ) ;
info_auth_keyid = ( keyid_t ) ptree -> auth . request_key ;
}
my_val = HEAD_PFIFO ( ptree -> auth . trusted_key_list ) ;
for ( ;
my_val != NULL ;
my_val = my_val -> link ) {
if ( T_Integer == my_val -> type ) authtrust ( my_val -> value . i , 1 ) ;
else if ( T_Intrange == my_val -> type ) {
first = my_val -> value . r . first ;
last = my_val -> value . r . last ;
if ( first > last || first < 1 || last > 65534 ) msyslog ( LOG_NOTICE , "Ignoring invalid trustedkey range %d ... %d, min 1 max 65534." , first , last ) ;
else for ( i = first ;
i <= last ;
i ++ ) authtrust ( ( keyid_t ) i , 1 ) ;
}
}
# ifdef AUTOKEY if ( ptree -> auth . revoke ) sys_revoke = 1 << ptree -> auth . revoke ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void fill_vaapi_plain_pred_weight_table ( H264Context * h , int list , unsigned char * luma_weight_flag , short luma_weight [ 32 ] , short luma_offset [ 32 ] , unsigned char * chroma_weight_flag , short chroma_weight [ 32 ] [ 2 ] , short chroma_offset [ 32 ] [ 2 ] ) {
unsigned int i , j ;
* luma_weight_flag = h -> luma_weight_flag [ list ] ;
* chroma_weight_flag = h -> chroma_weight_flag [ list ] ;
for ( i = 0 ;
i < h -> ref_count [ list ] ;
i ++ ) {
if ( h -> luma_weight_flag [ list ] ) {
luma_weight [ i ] = h -> luma_weight [ i ] [ list ] [ 0 ] ;
luma_offset [ i ] = h -> luma_weight [ i ] [ list ] [ 1 ] ;
}
else {
luma_weight [ i ] = 1 << h -> luma_log2_weight_denom ;
luma_offset [ i ] = 0 ;
}
for ( j = 0 ;
j < 2 ;
j ++ ) {
if ( h -> chroma_weight_flag [ list ] ) {
chroma_weight [ i ] [ j ] = h -> chroma_weight [ i ] [ list ] [ j ] [ 0 ] ;
chroma_offset [ i ] [ j ] = h -> chroma_weight [ i ] [ list ] [ j ] [ 1 ] ;
}
else {
chroma_weight [ i ] [ j ] = 1 << h -> chroma_log2_weight_denom ;
chroma_offset [ i ] [ j ] = 0 ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void RECORD_LAYER_reset_write_sequence ( RECORD_LAYER * rl ) {
memset ( rl -> write_sequence , 0 , sizeof ( rl -> write_sequence ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int do_execstack ( i_ctx_t * i_ctx_p , bool include_marks , os_ptr op1 ) {
os_ptr op = osp ;
ref * arefs = op1 -> value . refs ;
uint asize = r_size ( op1 ) ;
uint i ;
ref * rq ;
for ( i = 0 , rq = arefs + asize ;
rq != arefs ;
++ i ) {
const ref * rp = ref_stack_index ( & e_stack , ( long ) i ) ;
if ( r_has_type_attrs ( rp , t_null , a_executable ) && ! include_marks ) continue ;
-- rq ;
ref_assign_old ( op1 , rq , rp , "execstack" ) ;
switch ( r_type ( rq ) ) {
case t_operator : {
uint opidx = op_index ( rq ) ;
if ( opidx == 0 || op_def_is_internal ( op_index_def ( opidx ) ) ) r_clear_attrs ( rq , a_executable ) ;
break ;
}
case t_struct : case t_astruct : {
const char * tname = rq -> value . pstruct ? gs_struct_type_name_string ( gs_object_type ( imemory , rq -> value . pstruct ) ) : "NULL" ;
make_const_string ( rq , a_readonly | avm_foreign , strlen ( tname ) , ( const byte * ) tname ) ;
break ;
}
default : ;
}
}
pop ( op - op1 ) ;
return 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int cred_has_perm ( const struct cred * actor , const struct cred * target , u32 perms ) {
u32 asid = cred_sid ( actor ) , tsid = cred_sid ( target ) ;
return avc_has_perm ( asid , tsid , SECCLASS_PROCESS , perms , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_FECdata_mode ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_FECdata_mode , FECdata_mode_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_ ## type ## _predictor_ ## size ## x ## size ## _c ( uint8_t * dst , ptrdiff_t stride , const uint8_t * above , const uint8_t * left ) {
type ## _predictor ( dst , stride , size , above , left ) ;
}
# define intra_pred_allsizes ( type ) intra_pred_sized ( type , 4 ) intra_pred_sized ( type , 8 ) intra_pred_sized ( type , 16 ) intra_pred_sized ( type , 32 ) static INLINE void d207_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
( void ) above ;
for ( r = 0 ;
r < bs - 1 ;
++ r ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r ] + left [ r + 1 ] , 1 ) ;
dst [ ( bs - 1 ) * stride ] = left [ bs - 1 ] ;
dst ++ ;
for ( r = 0 ;
r < bs - 2 ;
++ r ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r ] + left [ r + 1 ] * 2 + left [ r + 2 ] , 2 ) ;
dst [ ( bs - 2 ) * stride ] = ROUND_POWER_OF_TWO ( left [ bs - 2 ] + left [ bs - 1 ] * 3 , 2 ) ;
dst [ ( bs - 1 ) * stride ] = left [ bs - 1 ] ;
dst ++ ;
for ( c = 0 ;
c < bs - 2 ;
++ c ) dst [ ( bs - 1 ) * stride + c ] = left [ bs - 1 ] ;
for ( r = bs - 2 ;
r >= 0 ;
-- r ) for ( c = 0 ;
c < bs - 2 ;
++ c ) dst [ r * stride + c ] = dst [ ( r + 1 ) * stride + c - 2 ] ;
}
intra_pred_allsizes ( d207 ) static INLINE void d63_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
( void ) left ;
for ( r = 0 ;
r < bs ;
++ r ) {
for ( c = 0 ;
c < bs ;
++ c ) dst [ c ] = r & 1 ? ROUND_POWER_OF_TWO ( above [ r / 2 + c ] + above [ r / 2 + c + 1 ] * 2 + above [ r / 2 + c + 2 ] , 2 ) : ROUND_POWER_OF_TWO ( above [ r / 2 + c ] + above [ r / 2 + c + 1 ] , 1 ) ;
dst += stride ;
}
}
intra_pred_allsizes ( d63 ) static INLINE void d45_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
( void ) left ;
for ( r = 0 ;
r < bs ;
++ r ) {
for ( c = 0 ;
c < bs ;
++ c ) dst [ c ] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO ( above [ r + c ] + above [ r + c + 1 ] * 2 + above [ r + c + 2 ] , 2 ) : above [ bs * 2 - 1 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d45 ) static INLINE void d117_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
for ( c = 0 ;
c < bs ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 1 ] + above [ c ] , 1 ) ;
dst += stride ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( left [ 0 ] + above [ - 1 ] * 2 + above [ 0 ] , 2 ) ;
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 2 ] + above [ c - 1 ] * 2 + above [ c ] , 2 ) ;
dst += stride ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] * 2 + left [ 1 ] , 2 ) ;
for ( r = 3 ;
r < bs ;
++ r ) dst [ ( r - 2 ) * stride ] = ROUND_POWER_OF_TWO ( left [ r - 3 ] + left [ r - 2 ] * 2 + left [ r - 1 ] , 2 ) ;
for ( r = 2 ;
r < bs ;
++ r ) {
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = dst [ - 2 * stride + c - 1 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d117 ) static INLINE void d135_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( left [ 0 ] + above [ - 1 ] * 2 + above [ 0 ] , 2 ) ;
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 2 ] + above [ c - 1 ] * 2 + above [ c ] , 2 ) ;
dst [ stride ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] * 2 + left [ 1 ] , 2 ) ;
for ( r = 2 ;
r < bs ;
++ r ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r - 2 ] + left [ r - 1 ] * 2 + left [ r ] , 2 ) ;
dst += stride ;
for ( r = 1 ;
r < bs ;
++ r ) {
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = dst [ - stride + c - 1 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d135 ) static INLINE void d153_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] , 1 ) ;
for ( r = 1 ;
r < bs ;
r ++ ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r - 1 ] + left [ r ] , 1 ) ;
dst ++ ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( left [ 0 ] + above [ - 1 ] * 2 + above [ 0 ] , 2 ) ;
dst [ stride ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] * 2 + left [ 1 ] , 2 ) ;
for ( r = 2 ;
r < bs ;
r ++ ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r - 2 ] + left [ r - 1 ] * 2 + left [ r ] , 2 ) ;
dst ++ ;
for ( c = 0 ;
c < bs - 2 ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 1 ] + above [ c ] * 2 + above [ c + 1 ] , 2 ) ;
dst += stride ;
for ( r = 1 ;
r < bs ;
++ r ) {
for ( c = 0 ;
c < bs - 2 ;
c ++ ) dst [ c ] = dst [ - stride + c - 2 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d153 ) static INLINE void v_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r ;
( void ) left ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memcpy ( dst , above , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( v ) static INLINE void h_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r ;
( void ) above ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset ( dst , left [ r ] , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( h ) static INLINE void tm_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
int ytop_left = above [ - 1 ] ;
for ( r = 0 ;
r < bs ;
r ++ ) {
for ( c = 0 ;
c < bs ;
c ++ ) dst [ c ] = clip_pixel ( left [ r ] + above [ c ] - ytop_left ) ;
dst += stride ;
}
}
intra_pred_allsizes ( tm ) static INLINE void dc_128_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r ;
( void ) above ;
( void ) left ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset ( dst , 128 , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( dc_128 ) static INLINE void dc_left_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int i , r , expected_dc , sum = 0 ;
( void ) above ;
for ( i = 0 ;
i < bs ;
i ++ ) sum += left [ i ] ;
expected_dc = ( sum + ( bs >> 1 ) ) / bs ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset ( dst , expected_dc , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( dc_left ) static INLINE void dc_top_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int i , r , expected_dc , sum = 0 ;
( void ) left ;
for ( i = 0 ;
i < bs ;
i ++ ) sum += above [ i ] ;
expected_dc = ( sum + ( bs >> 1 ) ) / bs ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset ( dst , expected_dc , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( dc_top )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp9_is_upper_layer_key_frame ( const VP9_COMP * const cpi ) {
return is_two_pass_svc ( cpi ) && cpi -> svc . spatial_layer_id > 0 && cpi -> svc . layer_context [ cpi -> svc . spatial_layer_id ] . is_key_frame ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const uint8_t * decode_tiles ( VP9Decoder * pbi , const uint8_t * data , const uint8_t * data_end ) {
VP9_COMMON * const cm = & pbi -> common ;
const VP9WorkerInterface * const winterface = vp9_get_worker_interface ( ) ;
const int aligned_cols = mi_cols_aligned_to_sb ( cm -> mi_cols ) ;
const int tile_cols = 1 << cm -> log2_tile_cols ;
const int tile_rows = 1 << cm -> log2_tile_rows ;
TileBuffer tile_buffers [ 4 ] [ 1 << 6 ] ;
int tile_row , tile_col ;
int mi_row , mi_col ;
TileData * tile_data = NULL ;
if ( cm -> lf . filter_level && pbi -> lf_worker . data1 == NULL ) {
CHECK_MEM_ERROR ( cm , pbi -> lf_worker . data1 , vpx_memalign ( 32 , sizeof ( LFWorkerData ) ) ) ;
pbi -> lf_worker . hook = ( VP9WorkerHook ) vp9_loop_filter_worker ;
if ( pbi -> max_threads > 1 && ! winterface -> reset ( & pbi -> lf_worker ) ) {
vpx_internal_error ( & cm -> error , VPX_CODEC_ERROR , "Loop filter thread creation failed" ) ;
}
}
if ( cm -> lf . filter_level ) {
LFWorkerData * const lf_data = ( LFWorkerData * ) pbi -> lf_worker . data1 ;
lf_data -> frame_buffer = get_frame_new_buffer ( cm ) ;
lf_data -> cm = cm ;
vp9_copy ( lf_data -> planes , pbi -> mb . plane ) ;
lf_data -> stop = 0 ;
lf_data -> y_only = 0 ;
vp9_loop_filter_frame_init ( cm , cm -> lf . filter_level ) ;
}
assert ( tile_rows <= 4 ) ;
assert ( tile_cols <= ( 1 << 6 ) ) ;
vpx_memset ( cm -> above_context , 0 , sizeof ( * cm -> above_context ) * MAX_MB_PLANE * 2 * aligned_cols ) ;
vpx_memset ( cm -> above_seg_context , 0 , sizeof ( * cm -> above_seg_context ) * aligned_cols ) ;
get_tile_buffers ( pbi , data , data_end , tile_cols , tile_rows , tile_buffers ) ;
if ( pbi -> tile_data == NULL || ( tile_cols * tile_rows ) != pbi -> total_tiles ) {
vpx_free ( pbi -> tile_data ) ;
CHECK_MEM_ERROR ( cm , pbi -> tile_data , vpx_memalign ( 32 , tile_cols * tile_rows * ( sizeof ( * pbi -> tile_data ) ) ) ) ;
pbi -> total_tiles = tile_rows * tile_cols ;
}
for ( tile_row = 0 ;
tile_row < tile_rows ;
++ tile_row ) {
for ( tile_col = 0 ;
tile_col < tile_cols ;
++ tile_col ) {
TileInfo tile ;
const TileBuffer * const buf = & tile_buffers [ tile_row ] [ tile_col ] ;
tile_data = pbi -> tile_data + tile_cols * tile_row + tile_col ;
tile_data -> cm = cm ;
tile_data -> xd = pbi -> mb ;
tile_data -> xd . corrupted = 0 ;
vp9_tile_init ( & tile , tile_data -> cm , tile_row , tile_col ) ;
setup_token_decoder ( buf -> data , data_end , buf -> size , & cm -> error , & tile_data -> bit_reader , pbi -> decrypt_cb , pbi -> decrypt_state ) ;
init_macroblockd ( cm , & tile_data -> xd ) ;
vp9_zero ( tile_data -> xd . dqcoeff ) ;
}
}
for ( tile_row = 0 ;
tile_row < tile_rows ;
++ tile_row ) {
TileInfo tile ;
vp9_tile_set_row ( & tile , cm , tile_row ) ;
for ( mi_row = tile . mi_row_start ;
mi_row < tile . mi_row_end ;
mi_row += MI_BLOCK_SIZE ) {
for ( tile_col = 0 ;
tile_col < tile_cols ;
++ tile_col ) {
const int col = pbi -> inv_tile_order ? tile_cols - tile_col - 1 : tile_col ;
tile_data = pbi -> tile_data + tile_cols * tile_row + col ;
vp9_tile_set_col ( & tile , tile_data -> cm , col ) ;
vp9_zero ( tile_data -> xd . left_context ) ;
vp9_zero ( tile_data -> xd . left_seg_context ) ;
for ( mi_col = tile . mi_col_start ;
mi_col < tile . mi_col_end ;
mi_col += MI_BLOCK_SIZE ) {
decode_partition ( tile_data -> cm , & tile_data -> xd , & tile , mi_row , mi_col , & tile_data -> bit_reader , BLOCK_64X64 ) ;
}
pbi -> mb . corrupted |= tile_data -> xd . corrupted ;
}
if ( cm -> lf . filter_level ) {
const int lf_start = mi_row - MI_BLOCK_SIZE ;
LFWorkerData * const lf_data = ( LFWorkerData * ) pbi -> lf_worker . data1 ;
if ( lf_start < 0 ) continue ;
if ( mi_row + MI_BLOCK_SIZE >= cm -> mi_rows ) continue ;
winterface -> sync ( & pbi -> lf_worker ) ;
lf_data -> start = lf_start ;
lf_data -> stop = mi_row ;
if ( pbi -> max_threads > 1 ) {
winterface -> launch ( & pbi -> lf_worker ) ;
}
else {
winterface -> execute ( & pbi -> lf_worker ) ;
}
}
}
}
if ( cm -> lf . filter_level ) {
LFWorkerData * const lf_data = ( LFWorkerData * ) pbi -> lf_worker . data1 ;
winterface -> sync ( & pbi -> lf_worker ) ;
lf_data -> start = lf_data -> stop ;
lf_data -> stop = cm -> mi_rows ;
winterface -> execute ( & pbi -> lf_worker ) ;
}
tile_data = pbi -> tile_data + tile_cols * tile_rows - 1 ;
return vp9_reader_find_end ( & tile_data -> bit_reader ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_pvfs2_mgmt_dspace_info ( tvbuff_t * tvb , proto_tree * tree , int offset , packet_info * pinfo ) {
offset = dissect_pvfs2_error ( tvb , tree , offset , pinfo ) ;
offset = dissect_pvfs_fh ( tvb , offset , pinfo , tree , "handle" , NULL ) ;
offset = dissect_pvfs2_ds_type ( tvb , tree , offset , NULL ) ;
offset = dissect_pvfs_uint64 ( tvb , tree , offset , hf_pvfs_b_size , NULL ) ;
offset = dissect_pvfs_uint64 ( tvb , tree , offset , hf_pvfs_k_size , NULL ) ;
offset = dissect_pvfs_fh ( tvb , offset , pinfo , tree , "handle" , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ffmpeg_GetFrameBuf ( struct AVCodecContext * p_context , AVFrame * p_ff_pic ) {
decoder_t * p_dec = ( decoder_t * ) p_context -> opaque ;
decoder_sys_t * p_sys = p_dec -> p_sys ;
p_ff_pic -> opaque = NULL ;
# if ! LIBAVCODEC_VERSION_CHECK ( 54 , 34 , 0 , 79 , 101 ) p_ff_pic -> pkt_pts = p_context -> pkt ? p_context -> pkt -> pts : AV_NOPTS_VALUE ;
# endif # if LIBAVCODEC_VERSION_MAJOR < 54 p_ff_pic -> age = 256 * 256 * 256 * 64 ;
# endif if ( p_sys -> p_va ) return ffmpeg_va_GetFrameBuf ( p_context , p_ff_pic ) ;
if ( ! p_sys -> b_direct_rendering ) return avcodec_default_get_buffer ( p_context , p_ff_pic ) ;
wait_mt ( p_sys ) ;
picture_t * p_pic = ffmpeg_dr_GetFrameBuf ( p_context ) ;
if ( ! p_pic ) {
if ( p_sys -> i_direct_rendering_used != 0 ) {
msg_Warn ( p_dec , "disabling direct rendering" ) ;
p_sys -> i_direct_rendering_used = 0 ;
}
post_mt ( p_sys ) ;
return avcodec_default_get_buffer ( p_context , p_ff_pic ) ;
}
if ( p_sys -> i_direct_rendering_used != 1 ) {
msg_Dbg ( p_dec , "using direct rendering" ) ;
p_sys -> i_direct_rendering_used = 1 ;
}
p_context -> draw_horiz_band = NULL ;
post_mt ( p_sys ) ;
p_ff_pic -> opaque = ( void * ) p_pic ;
p_ff_pic -> type = FF_BUFFER_TYPE_USER ;
p_ff_pic -> data [ 0 ] = p_pic -> p [ 0 ] . p_pixels ;
p_ff_pic -> data [ 1 ] = p_pic -> p [ 1 ] . p_pixels ;
p_ff_pic -> data [ 2 ] = p_pic -> p [ 2 ] . p_pixels ;
p_ff_pic -> data [ 3 ] = NULL ;
p_ff_pic -> linesize [ 0 ] = p_pic -> p [ 0 ] . i_pitch ;
p_ff_pic -> linesize [ 1 ] = p_pic -> p [ 1 ] . i_pitch ;
p_ff_pic -> linesize [ 2 ] = p_pic -> p [ 2 ] . i_pitch ;
p_ff_pic -> linesize [ 3 ] = 0 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * read_into_buffer ( FILE * fp , size_t * r_length ) {
char * buffer ;
size_t buflen ;
size_t nread , bufsize = 0 ;
* r_length = 0 ;
# define NCHUNK 8192 # ifdef HAVE_W32_SYSTEM setmode ( fileno ( fp ) , O_BINARY ) ;
# endif buffer = NULL ;
buflen = 0 ;
do {
bufsize += NCHUNK ;
buffer = realloc ( buffer , bufsize ) ;
if ( ! buffer ) {
perror ( "realloc failed" ) ;
exit ( 1 ) ;
}
nread = fread ( buffer + buflen , 1 , NCHUNK , fp ) ;
if ( nread < NCHUNK && ferror ( fp ) ) {
perror ( "fread failed" ) ;
exit ( 1 ) ;
}
buflen += nread ;
}
while ( nread == NCHUNK ) ;
# undef NCHUNK * r_length = buflen ;
return buffer ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_run_gs_CA ( fz_context * ctx , pdf_processor * proc , float alpha ) {
pdf_run_processor * pr = ( pdf_run_processor * ) proc ;
pdf_gstate * gstate = pdf_flush_text ( ctx , pr ) ;
gstate -> stroke . alpha = fz_clamp ( alpha , 0 , 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void gic_do_cpu_write ( void * opaque , hwaddr addr , uint64_t value , unsigned size ) {
GICState * * backref = ( GICState * * ) opaque ;
GICState * s = * backref ;
int id = ( backref - s -> backref ) ;
gic_cpu_write ( s , id , addr , value ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_INTEGER_23_66 ( 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 , 23U , 66U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int __key_instantiate_and_link ( struct key * key , struct key_preparsed_payload * prep , struct key * keyring , struct key * authkey , struct assoc_array_edit * * _edit ) {
int ret , awaken ;
key_check ( key ) ;
key_check ( keyring ) ;
awaken = 0 ;
ret = - EBUSY ;
mutex_lock ( & key_construction_mutex ) ;
if ( ! test_bit ( KEY_FLAG_INSTANTIATED , & key -> flags ) ) {
ret = key -> type -> instantiate ( key , prep ) ;
if ( ret == 0 ) {
atomic_inc ( & key -> user -> nikeys ) ;
set_bit ( KEY_FLAG_INSTANTIATED , & key -> flags ) ;
if ( test_and_clear_bit ( KEY_FLAG_USER_CONSTRUCT , & key -> flags ) ) awaken = 1 ;
if ( keyring ) {
if ( test_bit ( KEY_FLAG_KEEP , & keyring -> flags ) ) set_bit ( KEY_FLAG_KEEP , & key -> flags ) ;
__key_link ( key , _edit ) ;
}
if ( authkey ) key_revoke ( authkey ) ;
if ( prep -> expiry != TIME_T_MAX ) {
key -> expiry = prep -> expiry ;
key_schedule_gc ( prep -> expiry + key_gc_delay ) ;
}
}
}
mutex_unlock ( & key_construction_mutex ) ;
if ( awaken ) wake_up_bit ( & key -> flags , KEY_FLAG_USER_CONSTRUCT ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
afs_int32 SPR_DumpEntry ( struct rx_call * call , afs_int32 apos , struct prdebugentry * aentry ) {
afs_int32 code ;
afs_int32 cid = ANONYMOUSID ;
code = dumpEntry ( call , apos , aentry , & cid ) ;
osi_auditU ( call , PTS_DmpEntEvent , code , AUD_LONG , apos , AUD_END ) ;
ViceLog ( 125 , ( "PTS_DumpEntry: code %d cid %d apos %d\n" , code , cid , apos ) ) ;
return code ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void U_CALLCONV _LMBCSOpen ## n ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err ) \ {
_LMBCSOpenWorker ( _this , pArgs , err , n ) ;
}
static void _LMBCSOpenWorker ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err , ulmbcs_byte_t OptGroup ) {
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) uprv_malloc ( sizeof ( UConverterDataLMBCS ) ) ;
_this -> extraInfo = extraInfo ;
if ( extraInfo != NULL ) {
UConverterNamePieces stackPieces ;
UConverterLoadArgs stackArgs = UCNV_LOAD_ARGS_INITIALIZER ;
ulmbcs_byte_t i ;
uprv_memset ( extraInfo , 0 , sizeof ( UConverterDataLMBCS ) ) ;
stackArgs . onlyTestIsLoadable = pArgs -> onlyTestIsLoadable ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST && U_SUCCESS ( * err ) ;
i ++ ) {
if ( OptGroupByteToCPName [ i ] != NULL ) {
extraInfo -> OptGrpConverter [ i ] = ucnv_loadSharedData ( OptGroupByteToCPName [ i ] , & stackPieces , & stackArgs , err ) ;
}
}
if ( U_FAILURE ( * err ) || pArgs -> onlyTestIsLoadable ) {
_LMBCSClose ( _this ) ;
return ;
}
extraInfo -> OptGroup = OptGroup ;
extraInfo -> localeConverterIndex = FindLMBCSLocale ( pArgs -> locale ) ;
}
else {
* err = U_MEMORY_ALLOCATION_ERROR ;
}
}
U_CDECL_BEGIN static void U_CALLCONV _LMBCSClose ( UConverter * _this ) {
if ( _this -> extraInfo != NULL ) {
ulmbcs_byte_t Ix ;
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) _this -> extraInfo ;
for ( Ix = 0 ;
Ix <= ULMBCS_GRP_LAST ;
Ix ++ ) {
if ( extraInfo -> OptGrpConverter [ Ix ] != NULL ) ucnv_unloadSharedDataIfReady ( extraInfo -> OptGrpConverter [ Ix ] ) ;
}
if ( ! _this -> isExtraLocal ) {
uprv_free ( _this -> extraInfo ) ;
_this -> extraInfo = NULL ;
}
}
}
typedef struct LMBCSClone {
UConverter cnv ;
UConverterDataLMBCS lmbcs ;
}
LMBCSClone ;
static UConverter * U_CALLCONV _LMBCSSafeClone ( const UConverter * cnv , void * stackBuffer , int32_t * pBufferSize , UErrorCode * status ) {
( void ) status ;
LMBCSClone * newLMBCS ;
UConverterDataLMBCS * extraInfo ;
int32_t i ;
if ( * pBufferSize <= 0 ) {
* pBufferSize = ( int32_t ) sizeof ( LMBCSClone ) ;
return NULL ;
}
extraInfo = ( UConverterDataLMBCS * ) cnv -> extraInfo ;
newLMBCS = ( LMBCSClone * ) stackBuffer ;
uprv_memcpy ( & newLMBCS -> lmbcs , extraInfo , sizeof ( UConverterDataLMBCS ) ) ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST ;
++ i ) {
if ( extraInfo -> OptGrpConverter [ i ] != NULL ) {
ucnv_incrementRefCount ( extraInfo -> OptGrpConverter [ i ] ) ;
}
}
newLMBCS -> cnv . extraInfo = & newLMBCS -> lmbcs ;
newLMBCS -> cnv . isExtraLocal = TRUE ;
return & newLMBCS -> cnv ;
}
static size_t LMBCSConversionWorker ( UConverterDataLMBCS * extraInfo , ulmbcs_byte_t group , ulmbcs_byte_t * pStartLMBCS , UChar * pUniChar , ulmbcs_byte_t * lastConverterIndex , UBool * groups_tried ) {
ulmbcs_byte_t * pLMBCS = pStartLMBCS ;
UConverterSharedData * xcnv = extraInfo -> OptGrpConverter [ group ] ;
int bytesConverted ;
uint32_t value ;
ulmbcs_byte_t firstByte ;
U_ASSERT ( xcnv ) ;
U_ASSERT ( group < ULMBCS_GRP_UNICODE ) ;
bytesConverted = ucnv_MBCSFromUChar32 ( xcnv , * pUniChar , & value , FALSE ) ;
if ( bytesConverted > 0 ) {
firstByte = ( ulmbcs_byte_t ) ( value >> ( ( bytesConverted - 1 ) * 8 ) ) ;
}
else {
groups_tried [ group ] = TRUE ;
return 0 ;
}
* lastConverterIndex = group ;
U_ASSERT ( ( firstByte <= ULMBCS_C0END ) || ( firstByte >= ULMBCS_C1START ) || ( group == ULMBCS_GRP_EXCEPT ) ) ;
if ( group != ULMBCS_GRP_EXCEPT && extraInfo -> OptGroup != group ) {
* pLMBCS ++ = group ;
if ( bytesConverted == 1 && group >= ULMBCS_DOUBLEOPTGROUP_START ) {
* pLMBCS ++ = group ;
}
}
if ( bytesConverted == 1 && firstByte < 0x20 ) return 0 ;
switch ( bytesConverted ) {
case 4 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 24 ) ;
U_FALLTHROUGH ;
case 3 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 16 ) ;
U_FALLTHROUGH ;
case 2 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 8 ) ;
U_FALLTHROUGH ;
case 1 : * pLMBCS ++ = ( ulmbcs_byte_t ) value ;
U_FALLTHROUGH ;
default : break ;
}
return ( pLMBCS - pStartLMBCS ) ;
}
static size_t LMBCSConvertUni ( ulmbcs_byte_t * pLMBCS , UChar uniChar ) {
uint8_t LowCh = ( uint8_t ) ( uniChar & 0x00FF ) ;
uint8_t HighCh = ( uint8_t ) ( uniChar >> 8 ) ;
* pLMBCS ++ = ULMBCS_GRP_UNICODE ;
if ( LowCh == 0 ) {
* pLMBCS ++ = ULMBCS_UNICOMPATZERO ;
* pLMBCS ++ = HighCh ;
}
else {
* pLMBCS ++ = HighCh ;
* pLMBCS ++ = LowCh ;
}
return ULMBCS_UNICODE_SIZE ;
}
static void U_CALLCONV _LMBCSFromUnicode ( UConverterFromUnicodeArgs * args , UErrorCode * err ) {
ulmbcs_byte_t lastConverterIndex = 0 ;
UChar uniChar ;
ulmbcs_byte_t LMBCS [ ULMBCS_CHARSIZE_MAX ] ;
ulmbcs_byte_t * pLMBCS ;
int32_t bytes_written ;
UBool groups_tried [ ULMBCS_GRP_LAST + 1 ] ;
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
int sourceIndex = 0 ;
ulmbcs_byte_t OldConverterIndex = 0 ;
while ( args -> source < args -> sourceLimit && ! U_FAILURE ( * err ) ) {
OldConverterIndex = extraInfo -> localeConverterIndex ;
if ( args -> target >= args -> targetLimit ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
break ;
}
uniChar = * ( args -> source ) ;
bytes_written = 0 ;
pLMBCS = LMBCS ;
if ( ( uniChar >= 0x80 ) && ( uniChar <= 0xff ) && ( uniChar != 0xB1 ) && ( uniChar != 0xD7 ) && ( uniChar != 0xF7 ) && ( uniChar != 0xB0 ) && ( uniChar != 0xB4 ) && ( uniChar != 0xB6 ) && ( uniChar != 0xA7 ) && ( uniChar != 0xA8 ) ) {
extraInfo -> localeConverterIndex = ULMBCS_GRP_L1 ;
}
if ( ( ( uniChar > ULMBCS_C0END ) && ( uniChar < ULMBCS_C1START ) ) || uniChar == 0 || uniChar == ULMBCS_HT || uniChar == ULMBCS_CR || uniChar == ULMBCS_LF || uniChar == ULMBCS_123SYSTEMRANGE ) {
* pLMBCS ++ = ( ulmbcs_byte_t ) uniChar ;
bytes_written = 1 ;
}
if ( ! bytes_written ) {
ulmbcs_byte_t group = FindLMBCSUniRange ( uniChar ) ;
if ( group == ULMBCS_GRP_UNICODE ) {
pLMBCS += LMBCSConvertUni ( pLMBCS , uniChar ) ;
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
else if ( group == ULMBCS_GRP_CTRL ) {
if ( uniChar <= ULMBCS_C0END ) {
* pLMBCS ++ = ULMBCS_GRP_CTRL ;
* pLMBCS ++ = ( ulmbcs_byte_t ) ( ULMBCS_CTRLOFFSET + uniChar ) ;
}
else if ( uniChar >= ULMBCS_C1START && uniChar <= ULMBCS_C1START + ULMBCS_CTRLOFFSET ) {
* pLMBCS ++ = ULMBCS_GRP_CTRL ;
* pLMBCS ++ = ( ulmbcs_byte_t ) ( uniChar & 0x00FF ) ;
}
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
else if ( group < ULMBCS_GRP_UNICODE ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , group , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
uprv_memset ( groups_tried , 0 , sizeof ( groups_tried ) ) ;
if ( ( extraInfo -> OptGroup != 1 ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , extraInfo -> OptGroup ) ) ) {
if ( extraInfo -> localeConverterIndex < ULMBCS_DOUBLEOPTGROUP_START ) {
bytes_written = LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_L1 , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
if ( ! bytes_written ) {
bytes_written = LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_EXCEPT , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
bytes_written = LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
else {
bytes_written = LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written && ( extraInfo -> localeConverterIndex ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , extraInfo -> localeConverterIndex ) ) ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written && ( lastConverterIndex ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , lastConverterIndex ) ) ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , lastConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
ulmbcs_byte_t grp_start ;
ulmbcs_byte_t grp_end ;
ulmbcs_byte_t grp_ix ;
grp_start = ( ulmbcs_byte_t ) ( ( group == ULMBCS_AMBIGUOUS_MBCS ) ? ULMBCS_DOUBLEOPTGROUP_START : ULMBCS_GRP_L1 ) ;
grp_end = ( ulmbcs_byte_t ) ( ( group == ULMBCS_AMBIGUOUS_MBCS ) ? ULMBCS_GRP_LAST : ULMBCS_GRP_TH ) ;
if ( group == ULMBCS_AMBIGUOUS_ALL ) {
grp_start = ULMBCS_GRP_L1 ;
grp_end = ULMBCS_GRP_LAST ;
}
for ( grp_ix = grp_start ;
grp_ix <= grp_end && ! bytes_written ;
grp_ix ++ ) {
if ( extraInfo -> OptGrpConverter [ grp_ix ] && ! groups_tried [ grp_ix ] ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , grp_ix , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written && grp_start == ULMBCS_GRP_L1 ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_EXCEPT , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written ) {
pLMBCS += LMBCSConvertUni ( pLMBCS , uniChar ) ;
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
}
}
args -> source ++ ;
pLMBCS = LMBCS ;
while ( args -> target < args -> targetLimit && bytes_written -- ) {
* ( args -> target ) ++ = * pLMBCS ++ ;
if ( args -> offsets ) {
* ( args -> offsets ) ++ = sourceIndex ;
}
}
sourceIndex ++ ;
if ( bytes_written > 0 ) {
uint8_t * pErrorBuffer = args -> converter -> charErrorBuffer ;
* err = U_BUFFER_OVERFLOW_ERROR ;
args -> converter -> charErrorBufferLength = ( int8_t ) bytes_written ;
while ( bytes_written -- ) {
* pErrorBuffer ++ = * pLMBCS ++ ;
}
}
extraInfo -> localeConverterIndex = OldConverterIndex ;
}
}
static UChar GetUniFromLMBCSUni ( char const * * ppLMBCSin ) {
uint8_t HighCh = * ( * ppLMBCSin ) ++ ;
uint8_t LowCh = * ( * ppLMBCSin ) ++ ;
if ( HighCh == ULMBCS_UNICOMPATZERO ) {
HighCh = LowCh ;
LowCh = 0 ;
}
return ( UChar ) ( ( HighCh << 8 ) | LowCh ) ;
}
# define CHECK_SOURCE_LIMIT ( index ) if ( args -> source + index > args -> sourceLimit ) {
* err = U_TRUNCATED_CHAR_FOUND ;
args -> source = args -> sourceLimit ;
return 0xffff ;
}
static UChar32 U_CALLCONV _LMBCSGetNextUCharWorker ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
UChar32 uniChar = 0 ;
ulmbcs_byte_t CurByte ;
if ( args -> source >= args -> sourceLimit ) {
* err = U_ILLEGAL_ARGUMENT_ERROR ;
return 0xffff ;
}
CurByte = * ( ( ulmbcs_byte_t * ) ( args -> source ++ ) ) ;
if ( ( ( CurByte > ULMBCS_C0END ) && ( CurByte < ULMBCS_C1START ) ) || ( CurByte == 0 ) || CurByte == ULMBCS_HT || CurByte == ULMBCS_CR || CurByte == ULMBCS_LF || CurByte == ULMBCS_123SYSTEMRANGE ) {
uniChar = CurByte ;
}
else {
UConverterDataLMBCS * extraInfo ;
ulmbcs_byte_t group ;
UConverterSharedData * cnv ;
if ( CurByte == ULMBCS_GRP_CTRL ) {
ulmbcs_byte_t C0C1byte ;
CHECK_SOURCE_LIMIT ( 1 ) ;
C0C1byte = * ( args -> source ) ++ ;
uniChar = ( C0C1byte < ULMBCS_C1START ) ? C0C1byte - ULMBCS_CTRLOFFSET : C0C1byte ;
}
else if ( CurByte == ULMBCS_GRP_UNICODE ) {
CHECK_SOURCE_LIMIT ( 2 ) ;
return GetUniFromLMBCSUni ( & ( args -> source ) ) ;
}
else if ( CurByte <= ULMBCS_CTRLOFFSET ) {
group = CurByte ;
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
if ( group > ULMBCS_GRP_LAST || ( cnv = extraInfo -> OptGrpConverter [ group ] ) == NULL ) {
* err = U_INVALID_CHAR_FOUND ;
}
else if ( group >= ULMBCS_DOUBLEOPTGROUP_START ) {
CHECK_SOURCE_LIMIT ( 2 ) ;
if ( * args -> source == group ) {
++ args -> source ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source , 1 , FALSE ) ;
++ args -> source ;
}
else {
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source , 2 , FALSE ) ;
args -> source += 2 ;
}
}
else {
CHECK_SOURCE_LIMIT ( 1 ) ;
CurByte = * ( args -> source ) ++ ;
if ( CurByte >= ULMBCS_C1START ) {
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP ( cnv , CurByte ) ;
}
else {
char bytes [ 2 ] ;
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
cnv = extraInfo -> OptGrpConverter [ ULMBCS_GRP_EXCEPT ] ;
bytes [ 0 ] = group ;
bytes [ 1 ] = CurByte ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , bytes , 2 , FALSE ) ;
}
}
}
else if ( CurByte >= ULMBCS_C1START ) {
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
group = extraInfo -> OptGroup ;
cnv = extraInfo -> OptGrpConverter [ group ] ;
if ( group >= ULMBCS_DOUBLEOPTGROUP_START ) {
if ( ! ucnv_MBCSIsLeadByte ( cnv , CurByte ) ) {
CHECK_SOURCE_LIMIT ( 0 ) ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source - 1 , 1 , FALSE ) ;
}
else {
CHECK_SOURCE_LIMIT ( 1 ) ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source - 1 , 2 , FALSE ) ;
++ args -> source ;
}
}
else {
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP ( cnv , CurByte ) ;
}
}
}
return uniChar ;
}
static void U_CALLCONV _LMBCSToUnicodeWithOffsets ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
char LMBCS [ ULMBCS_CHARSIZE_MAX ] ;
UChar uniChar ;
const char * saveSource ;
const char * pStartLMBCS = args -> source ;
const char * errSource = NULL ;
int8_t savebytes = 0 ;
while ( U_SUCCESS ( * err ) && args -> sourceLimit > args -> source && args -> targetLimit > args -> target ) {
saveSource = args -> source ;
if ( args -> converter -> toULength ) {
const char * saveSourceLimit ;
size_t size_old = args -> converter -> toULength ;
size_t size_new_maybe_1 = sizeof ( LMBCS ) - size_old ;
size_t size_new_maybe_2 = args -> sourceLimit - args -> source ;
size_t size_new = ( size_new_maybe_1 < size_new_maybe_2 ) ? size_new_maybe_1 : size_new_maybe_2 ;
uprv_memcpy ( LMBCS , args -> converter -> toUBytes , size_old ) ;
uprv_memcpy ( LMBCS + size_old , args -> source , size_new ) ;
saveSourceLimit = args -> sourceLimit ;
args -> source = errSource = LMBCS ;
args -> sourceLimit = LMBCS + size_old + size_new ;
savebytes = ( int8_t ) ( size_old + size_new ) ;
uniChar = ( UChar ) _LMBCSGetNextUCharWorker ( args , err ) ;
args -> source = saveSource + ( ( args -> source - LMBCS ) - size_old ) ;
args -> sourceLimit = saveSourceLimit ;
if ( * err == U_TRUNCATED_CHAR_FOUND ) {
args -> converter -> toULength = savebytes ;
uprv_memcpy ( args -> converter -> toUBytes , LMBCS , savebytes ) ;
args -> source = args -> sourceLimit ;
* err = U_ZERO_ERROR ;
return ;
}
else {
args -> converter -> toULength = 0 ;
}
}
else {
errSource = saveSource ;
uniChar = ( UChar ) _LMBCSGetNextUCharWorker ( args , err ) ;
savebytes = ( int8_t ) ( args -> source - saveSource ) ;
}
if ( U_SUCCESS ( * err ) ) {
if ( uniChar < 0xfffe ) {
* ( args -> target ) ++ = uniChar ;
if ( args -> offsets ) {
* ( args -> offsets ) ++ = ( int32_t ) ( saveSource - pStartLMBCS ) ;
}
}
else if ( uniChar == 0xfffe ) {
* err = U_INVALID_CHAR_FOUND ;
}
else {
* err = U_ILLEGAL_CHAR_FOUND ;
}
}
}
if ( U_SUCCESS ( * err ) && args -> sourceLimit > args -> source && args -> targetLimit <= args -> target ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
}
else if ( U_FAILURE ( * err ) ) {
args -> converter -> toULength = savebytes ;
if ( savebytes > 0 ) {
uprv_memcpy ( args -> converter -> toUBytes , errSource , savebytes ) ;
}
if ( * err == U_TRUNCATED_CHAR_FOUND ) {
* err = U_ZERO_ERROR ;
}
}
}
DEFINE_LMBCS_OPEN ( 1 ) DEFINE_LMBCS_OPEN ( 2 ) DEFINE_LMBCS_OPEN ( 3 ) DEFINE_LMBCS_OPEN ( 4 ) DEFINE_LMBCS_OPEN ( 5 ) DEFINE_LMBCS_OPEN ( 6 ) DEFINE_LMBCS_OPEN ( 8 ) DEFINE_LMBCS_OPEN ( 11 ) DEFINE_LMBCS_OPEN ( 16 ) DEFINE_LMBCS_OPEN ( 17 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int load_input_picture ( MpegEncContext * s , const AVFrame * pic_arg ) {
Picture * pic = NULL ;
int64_t pts ;
int i , display_picture_number = 0 , ret ;
const int encoding_delay = s -> max_b_frames ? s -> max_b_frames : ( s -> low_delay ? 0 : 1 ) ;
int direct = 1 ;
if ( pic_arg ) {
pts = pic_arg -> pts ;
display_picture_number = s -> input_picture_number ++ ;
if ( pts != AV_NOPTS_VALUE ) {
if ( s -> user_specified_pts != AV_NOPTS_VALUE ) {
int64_t time = pts ;
int64_t last = s -> user_specified_pts ;
if ( time <= last ) {
av_log ( s -> avctx , AV_LOG_ERROR , "Error, Invalid timestamp=%" PRId64 ", " "last=%" PRId64 "\n" , pts , s -> user_specified_pts ) ;
return - 1 ;
}
if ( ! s -> low_delay && display_picture_number == 1 ) s -> dts_delta = time - last ;
}
s -> user_specified_pts = pts ;
}
else {
if ( s -> user_specified_pts != AV_NOPTS_VALUE ) {
s -> user_specified_pts = pts = s -> user_specified_pts + 1 ;
av_log ( s -> avctx , AV_LOG_INFO , "Warning: AVFrame.pts=? trying to guess (%" PRId64 ")\n" , pts ) ;
}
else {
pts = display_picture_number ;
}
}
}
if ( pic_arg ) {
if ( ! pic_arg -> buf [ 0 ] ) ;
direct = 0 ;
if ( pic_arg -> linesize [ 0 ] != s -> linesize ) direct = 0 ;
if ( pic_arg -> linesize [ 1 ] != s -> uvlinesize ) direct = 0 ;
if ( pic_arg -> linesize [ 2 ] != s -> uvlinesize ) direct = 0 ;
av_dlog ( s -> avctx , "%d %d %d %d\n" , pic_arg -> linesize [ 0 ] , pic_arg -> linesize [ 1 ] , s -> linesize , s -> uvlinesize ) ;
if ( direct ) {
i = ff_find_unused_picture ( s , 1 ) ;
if ( i < 0 ) return i ;
pic = & s -> picture [ i ] ;
pic -> reference = 3 ;
if ( ( ret = av_frame_ref ( & pic -> f , pic_arg ) ) < 0 ) return ret ;
if ( ff_alloc_picture ( s , pic , 1 ) < 0 ) {
return - 1 ;
}
}
else {
i = ff_find_unused_picture ( s , 0 ) ;
if ( i < 0 ) return i ;
pic = & s -> picture [ i ] ;
pic -> reference = 3 ;
if ( ff_alloc_picture ( s , pic , 0 ) < 0 ) {
return - 1 ;
}
if ( pic -> f . data [ 0 ] + INPLACE_OFFSET == pic_arg -> data [ 0 ] && pic -> f . data [ 1 ] + INPLACE_OFFSET == pic_arg -> data [ 1 ] && pic -> f . data [ 2 ] + INPLACE_OFFSET == pic_arg -> data [ 2 ] ) {
}
else {
int h_chroma_shift , v_chroma_shift ;
av_pix_fmt_get_chroma_sub_sample ( s -> avctx -> pix_fmt , & h_chroma_shift , & v_chroma_shift ) ;
for ( i = 0 ;
i < 3 ;
i ++ ) {
int src_stride = pic_arg -> linesize [ i ] ;
int dst_stride = i ? s -> uvlinesize : s -> linesize ;
int h_shift = i ? h_chroma_shift : 0 ;
int v_shift = i ? v_chroma_shift : 0 ;
int w = s -> width >> h_shift ;
int h = s -> height >> v_shift ;
uint8_t * src = pic_arg -> data [ i ] ;
uint8_t * dst = pic -> f . data [ i ] ;
if ( ! s -> avctx -> rc_buffer_size ) dst += INPLACE_OFFSET ;
if ( src_stride == dst_stride ) memcpy ( dst , src , src_stride * h ) ;
else {
while ( h -- ) {
memcpy ( dst , src , w ) ;
dst += dst_stride ;
src += src_stride ;
}
}
}
}
}
copy_picture_attributes ( s , & pic -> f , pic_arg ) ;
pic -> f . display_picture_number = display_picture_number ;
pic -> f . pts = pts ;
}
for ( i = 1 ;
i < MAX_PICTURE_COUNT ;
i ++ ) s -> input_picture [ i - 1 ] = s -> input_picture [ i ] ;
s -> input_picture [ encoding_delay ] = ( Picture * ) pic ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_AL1HeaderFEC ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_AL1HeaderFEC , AL1HeaderFEC_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ngx_int_t process_header ( ngx_http_request_t * r ) {
ngx_str_t * status_line ;
ngx_int_t rc , status ;
ngx_table_elt_t * h ;
ngx_http_upstream_t * u ;
ngx_http_upstream_header_t * hh ;
ngx_http_upstream_main_conf_t * umcf ;
ngx_http_core_loc_conf_t * clcf ;
passenger_loc_conf_t * slcf ;
umcf = ngx_http_get_module_main_conf ( r , ngx_http_upstream_module ) ;
clcf = ngx_http_get_module_loc_conf ( r , ngx_http_core_module ) ;
slcf = ngx_http_get_module_loc_conf ( r , ngx_http_passenger_module ) ;
for ( ;
;
) {
rc = ngx_http_parse_header_line ( r , & r -> upstream -> buffer , 1 ) ;
if ( rc == NGX_OK ) {
h = ngx_list_push ( & r -> upstream -> headers_in . headers ) ;
if ( h == NULL ) {
return NGX_ERROR ;
}
h -> hash = r -> header_hash ;
h -> key . len = r -> header_name_end - r -> header_name_start ;
h -> value . len = r -> header_end - r -> header_start ;
h -> key . data = ngx_pnalloc ( r -> pool , h -> key . len + 1 + h -> value . len + 1 + h -> key . len ) ;
if ( h -> key . data == NULL ) {
return NGX_ERROR ;
}
h -> value . data = h -> key . data + h -> key . len + 1 ;
h -> lowcase_key = h -> key . data + h -> key . len + 1 + h -> value . len + 1 ;
ngx_memcpy ( h -> key . data , r -> header_name_start , h -> key . len ) ;
h -> key . data [ h -> key . len ] = '\0' ;
ngx_memcpy ( h -> value . data , r -> header_start , h -> value . len ) ;
h -> value . data [ h -> value . len ] = '\0' ;
if ( h -> key . len == r -> lowcase_index ) {
ngx_memcpy ( h -> lowcase_key , r -> lowcase_header , h -> key . len ) ;
}
else {
ngx_strlow ( h -> lowcase_key , h -> key . data , h -> key . len ) ;
}
hh = ngx_hash_find ( & umcf -> headers_in_hash , h -> hash , h -> lowcase_key , h -> key . len ) ;
if ( hh && hh -> handler ( r , h , hh -> offset ) != NGX_OK ) {
return NGX_ERROR ;
}
ngx_log_debug2 ( NGX_LOG_DEBUG_HTTP , r -> connection -> log , 0 , "http scgi header: \"%V: %V\"" , & h -> key , & h -> value ) ;
continue ;
}
if ( rc == NGX_HTTP_PARSE_HEADER_DONE ) {
ngx_log_debug0 ( NGX_LOG_DEBUG_HTTP , r -> connection -> log , 0 , "http scgi header done" ) ;
if ( r -> upstream -> headers_in . server == NULL ) {
h = ngx_list_push ( & r -> upstream -> headers_in . headers ) ;
if ( h == NULL ) {
return NGX_HTTP_INTERNAL_SERVER_ERROR ;
}
h -> hash = ngx_hash ( ngx_hash ( ngx_hash ( ngx_hash ( ngx_hash ( 's' , 'e' ) , 'r' ) , 'v' ) , 'e' ) , 'r' ) ;
h -> key . len = sizeof ( "Server" ) - 1 ;
h -> key . data = ( u_char * ) "Server" ;
if ( slcf -> show_version_in_header == 0 ) {
if ( clcf -> server_tokens ) {
h -> value . data = ( u_char * ) ( NGINX_VER " + Phusion Passenger" ) ;
}
else {
h -> value . data = ( u_char * ) ( "nginx + Phusion Passenger" ) ;
}
}
else {
if ( clcf -> server_tokens ) {
h -> value . data = ( u_char * ) ( NGINX_VER " + Phusion Passenger " PASSENGER_VERSION ) ;
}
else {
h -> value . data = ( u_char * ) ( "nginx + Phusion Passenger " PASSENGER_VERSION ) ;
}
}
h -> value . len = ngx_strlen ( h -> value . data ) ;
h -> lowcase_key = ( u_char * ) "server" ;
}
if ( r -> upstream -> headers_in . date == NULL ) {
h = ngx_list_push ( & r -> upstream -> headers_in . headers ) ;
if ( h == NULL ) {
return NGX_HTTP_INTERNAL_SERVER_ERROR ;
}
h -> hash = ngx_hash ( ngx_hash ( ngx_hash ( 'd' , 'a' ) , 't' ) , 'e' ) ;
h -> key . len = sizeof ( "Date" ) - 1 ;
h -> key . data = ( u_char * ) "Date" ;
h -> value . len = 0 ;
h -> value . data = NULL ;
h -> lowcase_key = ( u_char * ) "date" ;
}
u = r -> upstream ;
if ( u -> headers_in . status_n ) {
goto done ;
}
if ( u -> headers_in . status ) {
status_line = & u -> headers_in . status -> value ;
status = ngx_atoi ( status_line -> data , 3 ) ;
if ( status == NGX_ERROR ) {
ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "upstream sent invalid status \"%V\"" , status_line ) ;
return NGX_HTTP_UPSTREAM_INVALID_HEADER ;
}
u -> headers_in . status_n = status ;
u -> headers_in . status_line = * status_line ;
}
else if ( u -> headers_in . location ) {
u -> headers_in . status_n = 302 ;
ngx_str_set ( & u -> headers_in . status_line , "302 Moved Temporarily" ) ;
}
else {
u -> headers_in . status_n = 200 ;
ngx_str_set ( & u -> headers_in . status_line , "200 OK" ) ;
}
if ( u -> state ) {
u -> state -> status = u -> headers_in . status_n ;
}
done : # ifdef NGX_HTTP_SWITCHING_PROTOCOLS if ( u -> headers_in . status_n == NGX_HTTP_SWITCHING_PROTOCOLS && r -> headers_in . upgrade ) {
u -> upgrade = 1 ;
}
# endif return NGX_OK ;
}
if ( rc == NGX_AGAIN ) {
return NGX_AGAIN ;
}
ngx_log_error ( NGX_LOG_ERR , r -> connection -> log , 0 , "upstream sent invalid header" ) ;
return NGX_HTTP_UPSTREAM_INVALID_HEADER ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int archive_read_format_cpio_cleanup ( struct archive_read * a ) {
struct cpio * cpio ;
cpio = ( struct cpio * ) ( a -> format -> data ) ;
while ( cpio -> links_head != NULL ) {
struct links_entry * lp = cpio -> links_head -> next ;
if ( cpio -> links_head -> name ) free ( cpio -> links_head -> name ) ;
free ( cpio -> links_head ) ;
cpio -> links_head = lp ;
}
free ( cpio ) ;
( a -> format -> data ) = NULL ;
return ( ARCHIVE_OK ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_mem_overun ( ) {
char buffer [ 10000 ] , field [ 10 ] ;
MYSQL_STMT * stmt ;
MYSQL_RES * field_res ;
int rc , i , length ;
myheader ( "test_mem_overun" ) ;
rc = mysql_query ( mysql , "drop table if exists t_mem_overun" ) ;
myquery ( rc ) ;
strxmov ( buffer , "create table t_mem_overun(" , NullS ) ;
for ( i = 0 ;
i < 1000 ;
i ++ ) {
sprintf ( field , "c%d int" , i ) ;
strxmov ( buffer , buffer , field , ", " , NullS ) ;
}
length = strlen ( buffer ) ;
buffer [ length - 2 ] = ')' ;
buffer [ -- length ] = '\0' ;
rc = mysql_real_query ( mysql , buffer , length ) ;
myquery ( rc ) ;
strxmov ( buffer , "insert into t_mem_overun values(" , NullS ) ;
for ( i = 0 ;
i < 1000 ;
i ++ ) {
strxmov ( buffer , buffer , "1, " , NullS ) ;
}
length = strlen ( buffer ) ;
buffer [ length - 2 ] = ')' ;
buffer [ -- length ] = '\0' ;
rc = mysql_real_query ( mysql , buffer , length ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "select * from t_mem_overun" ) ;
myquery ( rc ) ;
rc = my_process_result ( mysql ) ;
DIE_UNLESS ( rc == 1 ) ;
stmt = mysql_simple_prepare ( mysql , "select * from t_mem_overun" ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
field_res = mysql_stmt_result_metadata ( stmt ) ;
mytest ( field_res ) ;
if ( ! opt_silent ) fprintf ( stdout , "\n total fields : %d" , mysql_num_fields ( field_res ) ) ;
DIE_UNLESS ( 1000 == mysql_num_fields ( field_res ) ) ;
rc = mysql_stmt_store_result ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_fetch ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_fetch ( stmt ) ;
DIE_UNLESS ( rc == MYSQL_NO_DATA ) ;
mysql_free_result ( field_res ) ;
mysql_stmt_close ( stmt ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void psf_set_file ( SF_PRIVATE * psf , int fd ) {
psf -> file . filedes = fd ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( TemplateURLTest , GetURLOnlyOneURL ) {
TemplateURLData data ;
data . SetURL ( "http://www.google.co.uk/" ) ;
TemplateURL url ( data ) ;
const std : : vector < TemplateURLRef > & url_refs = url . url_refs ( ) ;
ASSERT_EQ ( 1U , url_refs . size ( ) ) ;
EXPECT_EQ ( "http://www.google.co.uk/" , url_refs [ 0 ] . GetURL ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int read_line ( char * buf , int size ) {
char c , UNINIT_VAR ( last_quote ) , last_char = 0 ;
char * p = buf , * buf_end = buf + size - 1 ;
int skip_char = 0 ;
my_bool have_slash = FALSE ;
enum {
R_NORMAL , R_Q , R_SLASH_IN_Q , R_COMMENT , R_LINE_START }
state = R_LINE_START ;
DBUG_ENTER ( "read_line" ) ;
start_lineno = cur_file -> lineno ;
DBUG_PRINT ( "info" , ( "Starting to read at lineno: %d" , start_lineno ) ) ;
for ( ;
p < buf_end ;
) {
skip_char = 0 ;
c = my_getc ( cur_file -> file ) ;
if ( feof ( cur_file -> file ) ) {
found_eof : if ( cur_file -> file != stdin ) {
fclose ( cur_file -> file ) ;
cur_file -> file = 0 ;
}
my_free ( cur_file -> file_name ) ;
cur_file -> file_name = 0 ;
if ( cur_file == file_stack ) {
if ( cur_block != block_stack ) die ( "Missing end of block" ) ;
* p = 0 ;
DBUG_PRINT ( "info" , ( "end of file at line %d" , cur_file -> lineno ) ) ;
DBUG_RETURN ( 1 ) ;
}
cur_file -- ;
start_lineno = cur_file -> lineno ;
continue ;
}
if ( c == '\n' ) {
cur_file -> lineno ++ ;
if ( p != buf && * ( p - 1 ) == '\r' ) p -- ;
}
switch ( state ) {
case R_NORMAL : if ( end_of_query ( c ) ) {
* p = 0 ;
DBUG_PRINT ( "exit" , ( "Found delimiter '%s' at line %d" , delimiter , cur_file -> lineno ) ) ;
DBUG_RETURN ( 0 ) ;
}
else if ( ( c == '{
' && ( ! my_strnncoll_simple ( charset_info , ( const uchar * ) "while" , 5 , ( uchar * ) buf , min ( 5 , p - buf ) , 0 ) || ! my_strnncoll_simple ( charset_info , ( const uchar * ) "if" , 2 , ( uchar * ) buf , min ( 2 , p - buf ) , 0 ) ) ) ) {
* p ++ = c ;
* p = 0 ;
DBUG_PRINT ( "exit" , ( "Found '{
' indicating start of block at line %d" , cur_file -> lineno ) ) ;
DBUG_RETURN ( 0 ) ;
}
else if ( c == '\'' || c == '"' || c == '`' ) {
if ( ! have_slash ) {
last_quote = c ;
state = R_Q ;
}
}
have_slash = ( c == '\\' ) ;
break ;
case R_COMMENT : if ( c == '\n' ) {
* p = 0 ;
DBUG_PRINT ( "exit" , ( "Found newline in comment at line: %d" , cur_file -> lineno ) ) ;
DBUG_RETURN ( 0 ) ;
}
break ;
case R_LINE_START : if ( c == '#' || c == '-' ) {
state = R_COMMENT ;
}
else if ( my_isspace ( charset_info , c ) ) {
if ( c == '\n' ) {
if ( last_char == '\n' ) {
DBUG_PRINT ( "info" , ( "Found two new lines in a row" ) ) ;
* p ++ = c ;
* p = 0 ;
DBUG_RETURN ( 0 ) ;
}
start_lineno = cur_file -> lineno ;
DBUG_PRINT ( "info" , ( "Query hasn't started yet, start_lineno: %d" , start_lineno ) ) ;
}
skip_char = 1 ;
}
else if ( end_of_query ( c ) ) {
* p = 0 ;
DBUG_PRINT ( "exit" , ( "Found delimiter '%s' at line: %d" , delimiter , cur_file -> lineno ) ) ;
DBUG_RETURN ( 0 ) ;
}
else if ( c == '}
' ) {
* p ++ = c ;
* p = 0 ;
DBUG_PRINT ( "exit" , ( "Found '}
' in begining of a line at line: %d" , cur_file -> lineno ) ) ;
DBUG_RETURN ( 0 ) ;
}
else if ( c == '\'' || c == '"' || c == '`' ) {
last_quote = c ;
state = R_Q ;
}
else state = R_NORMAL ;
break ;
case R_Q : if ( c == last_quote ) state = R_NORMAL ;
else if ( c == '\\' ) state = R_SLASH_IN_Q ;
break ;
case R_SLASH_IN_Q : state = R_Q ;
break ;
}
last_char = c ;
if ( ! skip_char ) {
# ifdef USE_MB int charlen = my_mbcharlen ( charset_info , ( unsigned char ) c ) ;
if ( ( charlen > 1 ) && ( p + charlen ) <= buf_end ) {
int i ;
char * mb_start = p ;
* p ++ = c ;
for ( i = 1 ;
i < charlen ;
i ++ ) {
c = my_getc ( cur_file -> file ) ;
if ( feof ( cur_file -> file ) ) goto found_eof ;
* p ++ = c ;
}
if ( ! my_ismbchar ( charset_info , mb_start , p ) ) {
while ( p - 1 > mb_start ) my_ungetc ( * -- p ) ;
}
}
else # endif * p ++ = c ;
}
}
die ( "The input buffer is too small for this query.x\n" "check your query or increase MAX_QUERY and recompile" ) ;
DBUG_RETURN ( 0 ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.