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
Oid getBaseType ( Oid typid ) { int32 typmod = - 1 ; return getBaseTypeAndTypmod ( typid , & typmod ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
TEST_F ( SyncBookmarkDataTypeControllerTest , StartFirstRun ) { CreateBookmarkModel ( LOAD_MODEL ) ; SetStartExpectations ( ) ; SetAssociateExpectations ( ) ; EXPECT_CALL ( * model_associator_ , SyncModelHasUserCreatedNodes ( _ ) ) . WillRepeatedly ( DoAll ( SetArgumentPointee < 0 > ( false ) , Return ( true ) ) ) ; EXPECT_CALL ( start_callback_ , Run ( DataTypeController : : OK_FIRST_RUN , _ , _ ) ) ; Start ( ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static xmlLinkPtr xmlListLowerSearch ( xmlListPtr l , void * data ) { xmlLinkPtr lk ; if ( l == NULL ) return ( NULL ) ; for ( lk = l -> sentinel -> next ; lk != l -> sentinel && l -> linkCompare ( lk -> data , data ) < 0 ; lk = lk -> next ) ; return lk ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static const char * c_escape_str ( AVBPrint * dst , const char * src , const char sep , void * log_ctx ) { const char * p ; for ( p = src ; * p ; p ++ ) { switch ( * p ) { case '\b' : av_bprintf ( dst , "%s" , "\\b" ) ; break ; case '\f' : av_bprintf ( dst , "%s" , "\\f" ) ; break ; case '\n' : av_bprintf ( dst , "%s" , "\\n" ) ; break ; case '\r' : av_bprintf ( dst , "%s" , "\\r" ) ; break ; case '\\' : av_bprintf ( dst , "%s" , "\\\\" ) ; break ; default : if ( * p == sep ) av_bprint_chars ( dst , '\\' , 1 ) ; av_bprint_chars ( dst , * p , 1 ) ; } } return dst -> str ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int64_t le4 ( const unsigned char * p ) { return ( ( p [ 0 ] << 16 ) + ( ( ( int64_t ) p [ 1 ] ) << 24 ) + ( p [ 2 ] << 0 ) + ( p [ 3 ] << 8 ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static bool MakeTempFile ( const base : : FilePath & dir , const base : : FilePath & file_name , base : : FilePath * full_path ) { * full_path = dir . Append ( file_name ) ; return base : : WriteFile ( * full_path , "" , 0 ) == 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void interpolate ( float * out , float v1 , float v2 , int size ) { int i ; float step = ( v1 - v2 ) / ( size + 1 ) ; for ( i = 0 ; i < size ; i ++ ) { v2 += step ; out [ i ] = v2 ; } }
0False
Categorize the following code snippet as vulnerable or not. True or False
static char * _catkey ( char * buffer , int32_t set_num , int32_t msg_num ) { int32_t i = 0 ; i = T_CString_integerToString ( buffer , set_num , 10 ) ; buffer [ i ++ ] = SEPARATOR ; T_CString_integerToString ( buffer + i , msg_num , 10 ) ; return buffer ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_h245_IV16 ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_octet_string ( tvb , offset , actx , tree , hf_index , 16 , 16 , FALSE , NULL ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void update_offset_hash_table_from_kb ( OffsetHashTable tbl , KBNODE node , off_t off ) { for ( ; node ; node = node -> next ) { if ( node -> pkt -> pkttype == PKT_PUBLIC_KEY || node -> pkt -> pkttype == PKT_PUBLIC_SUBKEY ) { u32 aki [ 2 ] ; keyid_from_pk ( node -> pkt -> pkt . public_key , aki ) ; update_offset_hash_table ( tbl , aki , off ) ; } } }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void _UTF7Reset ( UConverter * cnv , UConverterResetChoice choice ) { if ( choice <= UCNV_RESET_TO_UNICODE ) { cnv -> toUnicodeStatus = 0x1000000 ; cnv -> toULength = 0 ; } if ( choice != UCNV_RESET_TO_UNICODE ) { cnv -> fromUnicodeStatus = ( cnv -> fromUnicodeStatus & 0xf0000000 ) | 0x1000000 ; } }
1True
Categorize the following code snippet as vulnerable or not. True or False
static void vdpau_h264_set_rf ( VdpReferenceFrameH264 * rf , Picture * pic , int pic_structure ) { VdpVideoSurface surface = ff_vdpau_get_surface_id ( pic ) ; if ( pic_structure == 0 ) pic_structure = pic -> reference ; rf -> surface = surface ; rf -> is_long_term = pic -> reference && pic -> long_ref ; rf -> top_is_reference = ( pic_structure & PICT_TOP_FIELD ) != 0 ; rf -> bottom_is_reference = ( pic_structure & PICT_BOTTOM_FIELD ) != 0 ; rf -> field_order_cnt [ 0 ] = h264_foc ( pic -> field_poc [ 0 ] ) ; rf -> field_order_cnt [ 1 ] = h264_foc ( pic -> field_poc [ 1 ] ) ; rf -> frame_idx = pic -> long_ref ? pic -> pic_id : pic -> frame_num ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
SPL_METHOD ( DirectoryIterator , key ) { spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ; if ( zend_parse_parameters_none ( ) == FAILURE ) { return ; } if ( intern -> u . dir . dirp ) { RETURN_LONG ( intern -> u . dir . index ) ; } else { RETURN_FALSE ; } }
1True
Categorize the following code snippet as vulnerable or not. True or False
static FILE * checkdupstoredtable ( SplineFont * sf , uint32 tag , int * len , struct alltabs * all , int me ) { int i ; struct ttf_table * tab = SFFindTable ( sf , tag ) , * test ; if ( tab == NULL ) { * len = 0 ; return ( NULL ) ; } for ( i = 0 ; i < me ; ++ i ) { test = SFFindTable ( all [ i ] . sf , tag ) ; if ( test != NULL && test -> len == tab -> len && memcmp ( test -> data , tab -> data , tab -> len ) == 0 ) { * len = i ; return ( ( FILE * ) ( intpt ) - 1 ) ; } } return ( dumpstoredtable ( sf , tag , len ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
int compare_key_tok_id ( const void * a1 , const void * a2 ) { const struct key_tok * p1 = a1 ; const struct key_tok * p2 = a2 ; if ( p1 -> token == p2 -> token ) return 0 ; if ( p1 -> token < p2 -> token ) return - 1 ; else return 1 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void vp9_reset_segment_features ( struct segmentation * seg ) { seg -> enabled = 0 ; seg -> update_map = 0 ; seg -> update_data = 0 ; vpx_memset ( seg -> tree_probs , 255 , sizeof ( seg -> tree_probs ) ) ; vp9_clearall_segfeatures ( seg ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void sig_window_print_info ( WINDOW_REC * win ) { GUI_WINDOW_REC * gui ; gui = WINDOW_GUI ( win ) ; if ( gui -> use_scroll ) { printformat_window ( win , MSGLEVEL_CLIENTCRAP , TXT_WINDOW_INFO_SCROLL , gui -> scroll ? "yes" : "no" ) ; } if ( WINDOW_MAIN ( win ) -> sticky_windows ) windows_print_sticky ( win ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static bool tsc_adjust_needed ( void * opaque ) { X86CPU * cpu = opaque ; CPUX86State * env = & cpu -> env ; return env -> tsc_adjust != 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void decode_ppc ( TwinContext * tctx , int period_coef , const float * shape , float ppc_gain , float * speech ) { const ModeTab * mtab = tctx -> mtab ; int isampf = tctx -> avctx -> sample_rate / 1000 ; int ibps = tctx -> avctx -> bit_rate / ( 1000 * tctx -> avctx -> channels ) ; int min_period = ROUNDED_DIV ( 40 * 2 * mtab -> size , isampf ) ; int max_period = ROUNDED_DIV ( 6 * 40 * 2 * mtab -> size , isampf ) ; int period_range = max_period - min_period ; int period = min_period + ROUNDED_DIV ( period_coef * period_range , ( 1 << mtab -> ppc_period_bit ) - 1 ) ; int width ; if ( isampf == 22 && ibps == 32 ) { width = ROUNDED_DIV ( ( period + 800 ) * mtab -> peak_per2wid , 400 * mtab -> size ) ; } else width = ( period ) * mtab -> peak_per2wid / ( 400 * mtab -> size ) ; add_peak ( period , width , shape , ppc_gain , speech , mtab -> ppc_shape_len ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
png_uint_32 PNGAPI png_permit_mng_features ( png_structp png_ptr , png_uint_32 mng_features ) { png_debug ( 1 , "in png_permit_mng_features" ) ; if ( png_ptr == NULL ) return ( png_uint_32 ) 0 ; png_ptr -> mng_features_permitted = ( png_byte ) ( mng_features & PNG_ALL_MNG_FEATURES ) ; return ( png_uint_32 ) png_ptr -> mng_features_permitted ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
Node * make_and_qual ( Node * qual1 , Node * qual2 ) { if ( qual1 == NULL ) return qual2 ; if ( qual2 == NULL ) return qual1 ; return ( Node * ) make_andclause ( list_make2 ( qual1 , qual2 ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
kadm5_ret_t kadm5_get_principal_keys ( void * server_handle , krb5_principal principal , krb5_keyblock * * keyblocks , int * n_keys ) { krb5_db_entry * kdb ; osa_princ_ent_rec adb ; kadm5_ret_t ret ; kadm5_server_handle_t handle = server_handle ; if ( keyblocks ) * keyblocks = NULL ; CHECK_HANDLE ( server_handle ) ; if ( principal == NULL ) return EINVAL ; if ( ( ret = kdb_get_entry ( handle , principal , & kdb , & adb ) ) ) return ( ret ) ; if ( keyblocks ) { ret = decrypt_key_data ( handle -> context , kdb -> n_key_data , kdb -> key_data , keyblocks , n_keys ) ; if ( ret ) goto done ; } ret = KADM5_OK ; done : kdb_free_entry ( handle , kdb , & adb ) ; return ret ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int __attribute_noinline__ link_exists2_p ( const char * dir , size_t dirlen , const char * fname , glob_t * pglob # ifndef _LIBC , int flags # endif ) { size_t fnamelen = strlen ( fname ) ; char * fullname = ( char * ) __alloca ( dirlen + 1 + fnamelen + 1 ) ; struct stat st ; # ifndef _LIBC struct_stat64 st64 ; # endif mempcpy ( mempcpy ( mempcpy ( fullname , dir , dirlen ) , "/" , 1 ) , fname , fnamelen + 1 ) ; # ifdef _LIBC return ( * pglob -> gl_stat ) ( fullname , & st ) == 0 ; # else return ( ( __builtin_expect ( flags & GLOB_ALTDIRFUNC , 0 ) ? ( * pglob -> gl_stat ) ( fullname , & st ) : __stat64 ( fullname , & st64 ) ) == 0 ) ; # endif }
0False
Categorize the following code snippet as vulnerable or not. True or False
void vp9_cyclic_refresh_setup ( VP9_COMP * const cpi ) { VP9_COMMON * const cm = & cpi -> common ; const RATE_CONTROL * const rc = & cpi -> rc ; CYCLIC_REFRESH * const cr = cpi -> cyclic_refresh ; struct segmentation * const seg = & cm -> seg ; unsigned char * const seg_map = cpi -> segmentation_map ; const int apply_cyclic_refresh = apply_cyclic_refresh_bitrate ( cm , rc ) ; if ( ! apply_cyclic_refresh || ( cm -> frame_type == KEY_FRAME ) || ( cpi -> svc . temporal_layer_id > 0 ) ) { vpx_memset ( seg_map , 0 , cm -> mi_rows * cm -> mi_cols ) ; vp9_disable_segmentation ( & cm -> seg ) ; if ( cm -> frame_type == KEY_FRAME ) cr -> sb_index = 0 ; return ; } else { int qindex_delta = 0 ; int i , block_count , bl_index , sb_rows , sb_cols , sbs_in_frame ; int xmis , ymis , x , y , qindex2 ; const float rate_ratio_qdelta = 2.0 ; const double q = vp9_convert_qindex_to_q ( cm -> base_qindex , cm -> bit_depth ) ; vp9_clear_system_state ( ) ; cr -> max_sbs_perframe = 10 ; cr -> max_qdelta_perc = 50 ; cr -> min_block_size = BLOCK_8X8 ; cr -> time_for_refresh = 1 ; cr -> thresh_rate_sb = ( rc -> sb64_target_rate * 256 ) >> 2 ; cr -> thresh_dist_sb = 8 * ( int ) ( q * q ) ; if ( cpi -> sf . use_nonrd_pick_mode ) { cr -> thresh_rate_sb = ( rc -> sb64_target_rate * 256 ) >> 3 ; cr -> thresh_dist_sb = 4 * ( int ) ( q * q ) ; } cr -> num_seg_blocks = 0 ; vpx_memset ( seg_map , 0 , cm -> mi_rows * cm -> mi_cols ) ; vp9_enable_segmentation ( & cm -> seg ) ; vp9_clearall_segfeatures ( seg ) ; seg -> abs_delta = SEGMENT_DELTADATA ; vp9_disable_segfeature ( seg , 0 , SEG_LVL_ALT_Q ) ; vp9_enable_segfeature ( seg , 1 , SEG_LVL_ALT_Q ) ; qindex_delta = vp9_compute_qdelta_by_rate ( rc , cm -> frame_type , cm -> base_qindex , rate_ratio_qdelta , cm -> bit_depth ) ; if ( - qindex_delta > cr -> max_qdelta_perc * cm -> base_qindex / 100 ) qindex_delta = - cr -> max_qdelta_perc * cm -> base_qindex / 100 ; qindex2 = clamp ( cm -> base_qindex + cm -> y_dc_delta_q + qindex_delta , 0 , MAXQ ) ; cr -> rdmult = vp9_compute_rd_mult ( cpi , qindex2 ) ; vp9_set_segdata ( seg , 1 , SEG_LVL_ALT_Q , qindex_delta ) ; sb_cols = ( cm -> mi_cols + MI_BLOCK_SIZE - 1 ) / MI_BLOCK_SIZE ; sb_rows = ( cm -> mi_rows + MI_BLOCK_SIZE - 1 ) / MI_BLOCK_SIZE ; sbs_in_frame = sb_cols * sb_rows ; block_count = cr -> max_sbs_perframe * sbs_in_frame / 100 ; assert ( cr -> sb_index < sbs_in_frame ) ; i = cr -> sb_index ; do { int sum_map = 0 ; int sb_row_index = ( i / sb_cols ) ; int sb_col_index = i - sb_row_index * sb_cols ; int mi_row = sb_row_index * MI_BLOCK_SIZE ; int mi_col = sb_col_index * MI_BLOCK_SIZE ; assert ( mi_row >= 0 && mi_row < cm -> mi_rows ) ; assert ( mi_col >= 0 && mi_col < cm -> mi_cols ) ; bl_index = mi_row * cm -> mi_cols + mi_col ; xmis = MIN ( cm -> mi_cols - mi_col , num_8x8_blocks_wide_lookup [ BLOCK_64X64 ] ) ; ymis = MIN ( cm -> mi_rows - mi_row , num_8x8_blocks_high_lookup [ BLOCK_64X64 ] ) ; for ( y = 0 ; y < ymis ; y ++ ) { for ( x = 0 ; x < xmis ; x ++ ) { const int bl_index2 = bl_index + y * cm -> mi_cols + x ; if ( cr -> map [ bl_index2 ] == 0 ) { seg_map [ bl_index2 ] = 1 ; sum_map ++ ; } else if ( cr -> map [ bl_index2 ] < 0 ) { cr -> map [ bl_index2 ] ++ ; } } } if ( sum_map > 0 && sum_map < xmis * ymis ) { const int new_value = ( sum_map >= xmis * ymis / 2 ) ; for ( y = 0 ; y < ymis ; y ++ ) for ( x = 0 ; x < xmis ; x ++ ) seg_map [ bl_index + y * cm -> mi_cols + x ] = new_value ; } i ++ ; if ( i == sbs_in_frame ) { i = 0 ; } if ( sum_map >= xmis * ymis / 2 ) block_count -- ; } while ( block_count && i != cr -> sb_index ) ; cr -> sb_index = i ; } }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void decode_band_structure ( GetBitContext * gbc , int blk , int eac3 , int ecpl , int start_subband , int end_subband , const uint8_t * default_band_struct , int * num_bands , uint8_t * band_sizes ) { int subbnd , bnd , n_subbands , n_bands = 0 ; uint8_t bnd_sz [ 22 ] ; uint8_t coded_band_struct [ 22 ] ; const uint8_t * band_struct ; n_subbands = end_subband - start_subband ; if ( ! eac3 || get_bits1 ( gbc ) ) { for ( subbnd = 0 ; subbnd < n_subbands - 1 ; subbnd ++ ) { coded_band_struct [ subbnd ] = get_bits1 ( gbc ) ; } band_struct = coded_band_struct ; } else if ( ! blk ) { band_struct = & default_band_struct [ start_subband + 1 ] ; } else { return ; } if ( num_bands || band_sizes ) { n_bands = n_subbands ; bnd_sz [ 0 ] = ecpl ? 6 : 12 ; for ( bnd = 0 , subbnd = 1 ; subbnd < n_subbands ; subbnd ++ ) { int subbnd_size = ( ecpl && subbnd < 4 ) ? 6 : 12 ; if ( band_struct [ subbnd - 1 ] ) { n_bands -- ; bnd_sz [ bnd ] += subbnd_size ; } else { bnd_sz [ ++ bnd ] = subbnd_size ; } } } if ( num_bands ) * num_bands = n_bands ; if ( band_sizes ) memcpy ( band_sizes , bnd_sz , n_bands ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void vp9_rc_postencode_update_drop_frame ( VP9_COMP * cpi ) { update_buffer_level ( cpi , 0 ) ; cpi -> common . last_frame_type = cpi -> common . frame_type ; cpi -> rc . frames_since_key ++ ; cpi -> rc . frames_to_key -- ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int find_odc_header ( struct archive_read * a ) { const void * h ; const char * p , * q ; size_t skip , skipped = 0 ; ssize_t bytes ; for ( ; ; ) { h = __archive_read_ahead ( a , odc_header_size , & bytes ) ; if ( h == NULL ) return ( ARCHIVE_FATAL ) ; p = h ; q = p + bytes ; if ( memcmp ( "070707" , p , 6 ) == 0 && is_octal ( p , odc_header_size ) ) return ( ARCHIVE_OK ) ; if ( memcmp ( "070727" , p , 6 ) == 0 && is_afio_large ( p , bytes ) ) { a -> archive . archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE ; return ( ARCHIVE_OK ) ; } while ( p + odc_header_size <= q ) { switch ( p [ 5 ] ) { case '7' : if ( ( memcmp ( "070707" , p , 6 ) == 0 && is_octal ( p , odc_header_size ) ) || ( memcmp ( "070727" , p , 6 ) == 0 && is_afio_large ( p , q - p ) ) ) { skip = p - ( const char * ) h ; __archive_read_consume ( a , skip ) ; skipped += skip ; if ( p [ 4 ] == '2' ) a -> archive . archive_format = ARCHIVE_FORMAT_CPIO_AFIO_LARGE ; if ( skipped > 0 ) { archive_set_error ( & a -> archive , 0 , "Skipped %d bytes before " "finding valid header" , ( int ) skipped ) ; return ( ARCHIVE_WARN ) ; } return ( ARCHIVE_OK ) ; } p += 2 ; break ; case '0' : p ++ ; break ; default : p += 6 ; break ; } } skip = p - ( const char * ) h ; __archive_read_consume ( a , skip ) ; skipped += skip ; } }
0False
Categorize the following code snippet as vulnerable or not. True or False
void hmp_hostfwd_add ( Monitor * mon , const QDict * qdict ) { const char * redir_str ; SlirpState * s ; const char * arg1 = qdict_get_str ( qdict , "arg1" ) ; const char * arg2 = qdict_get_try_str ( qdict , "arg2" ) ; const char * arg3 = qdict_get_try_str ( qdict , "arg3" ) ; if ( arg2 ) { s = slirp_lookup ( mon , arg1 , arg2 ) ; redir_str = arg3 ; } else { s = slirp_lookup ( mon , NULL , NULL ) ; redir_str = arg1 ; } if ( s ) { slirp_hostfwd ( s , redir_str , 0 ) ; } }
0False
Categorize the following code snippet as vulnerable or not. True or False
static gint dissect_ac_if_input_terminal ( tvbuff_t * tvb , gint offset , packet_info * pinfo _U_ , proto_tree * tree , usb_conv_info_t * usb_conv_info _U_ ) { gint offset_start ; offset_start = offset ; proto_tree_add_item ( tree , hf_ac_if_input_terminalid , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_ac_if_input_terminaltype , tvb , offset , 2 , ENC_LITTLE_ENDIAN ) ; offset += 2 ; proto_tree_add_item ( tree , hf_ac_if_input_assocterminal , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_ac_if_input_nrchannels , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_ac_if_input_channelconfig , tvb , offset , 2 , ENC_LITTLE_ENDIAN ) ; offset += 2 ; proto_tree_add_item ( tree , hf_ac_if_input_channelnames , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_ac_if_input_terminal , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; return offset - offset_start ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void e1000e_set_fcrth ( E1000ECore * core , int index , uint32_t val ) { core -> mac [ FCRTH ] = val & 0xFFF8 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void SortTocFromFile ( Archive * AHX ) { ArchiveHandle * AH = ( ArchiveHandle * ) AHX ; RestoreOptions * ropt = AH -> public . ropt ; FILE * fh ; char buf [ 100 ] ; bool incomplete_line ; ropt -> idWanted = ( bool * ) pg_malloc ( sizeof ( bool ) * AH -> maxDumpId ) ; memset ( ropt -> idWanted , 0 , sizeof ( bool ) * AH -> maxDumpId ) ; fh = fopen ( ropt -> tocFile , PG_BINARY_R ) ; if ( ! fh ) exit_horribly ( modulename , "could not open TOC file \"%s\": %s\n" , ropt -> tocFile , strerror ( errno ) ) ; incomplete_line = false ; while ( fgets ( buf , sizeof ( buf ) , fh ) != NULL ) { bool prev_incomplete_line = incomplete_line ; int buflen ; char * cmnt ; char * endptr ; DumpId id ; TocEntry * te ; buflen = strlen ( buf ) ; if ( buflen > 0 && buf [ buflen - 1 ] == '\n' ) incomplete_line = false ; else incomplete_line = true ; if ( prev_incomplete_line ) continue ; cmnt = strchr ( buf , '; ' ) ; if ( cmnt != NULL ) cmnt [ 0 ] = '\0' ; if ( strspn ( buf , " \t\r\n" ) == strlen ( buf ) ) continue ; id = strtol ( buf , & endptr , 10 ) ; if ( endptr == buf || id <= 0 || id > AH -> maxDumpId || ropt -> idWanted [ id - 1 ] ) { write_msg ( modulename , "WARNING: line ignored: %s\n" , buf ) ; continue ; } te = getTocEntryByDumpId ( AH , id ) ; if ( ! te ) exit_horribly ( modulename , "could not find entry for ID %d\n" , id ) ; ropt -> idWanted [ id - 1 ] = true ; _moveBefore ( AH , AH -> toc , te ) ; } if ( fclose ( fh ) != 0 ) exit_horribly ( modulename , "could not close TOC file: %s\n" , strerror ( errno ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static vpx_codec_err_t ctrl_use_reference ( vpx_codec_alg_priv_t * ctx , va_list args ) { const int reference_flag = va_arg ( args , int ) ; vp9_use_as_reference ( ctx -> cpi , reference_flag ) ; return VPX_CODEC_OK ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static inline int handle_cpu_signal ( uintptr_t pc , unsigned long address , int is_write , sigset_t * old_set , void * puc ) { int ret ; # if defined ( DEBUG_SIGNAL ) qemu_printf ( "qemu: SIGSEGV pc=0x%08lx address=%08lx w=%d oldset=0x%08lx\n" , pc , address , is_write , * ( unsigned long * ) old_set ) ; # endif if ( is_write && h2g_valid ( address ) && page_unprotect ( h2g ( address ) , pc , puc ) ) { return 1 ; } ret = cpu_handle_mmu_fault ( cpu_single_env , address , is_write , MMU_USER_IDX ) ; if ( ret < 0 ) { return 0 ; } if ( ret == 0 ) { return 1 ; } cpu_restore_state ( cpu_single_env , pc ) ; sigprocmask ( SIG_SETMASK , old_set , NULL ) ; exception_action ( cpu_single_env ) ; return 1 ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_h225_BOOLEAN ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_boolean ( tvb , offset , actx , tree , hf_index , NULL ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void vp9_init_second_pass_spatial_svc ( VP9_COMP * cpi ) { SVC * const svc = & cpi -> svc ; int i ; for ( i = 0 ; i < svc -> number_spatial_layers ; ++ i ) { TWO_PASS * const twopass = & svc -> layer_context [ i ] . twopass ; svc -> spatial_layer_id = i ; vp9_init_second_pass ( cpi ) ; twopass -> total_stats . spatial_layer_id = i ; twopass -> total_left_stats . spatial_layer_id = i ; } svc -> spatial_layer_id = 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static const char * rsvp_host_get_filter_type ( hostlist_talker_t * host _U_ , conv_filter_type_e filter ) { if ( ( filter == CONV_FT_ANY_ADDRESS ) && ( host -> myaddress . type == AT_IPv4 ) ) return "ip.addr" ; return CONV_FILTER_INVALID ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void aacsbr_func_ptr_init ( AACSBRContext * c ) { c -> sbr_lf_gen = sbr_lf_gen ; c -> sbr_hf_assemble = sbr_hf_assemble ; c -> sbr_x_gen = sbr_x_gen ; c -> sbr_hf_inverse_filter = sbr_hf_inverse_filter ; if ( ARCH_MIPS ) ff_aacsbr_func_ptr_init_mips ( c ) ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static void SvcEncode ( VP9_COMP * cpi , size_t * size , uint8_t * dest , unsigned int * frame_flags ) { vp9_rc_get_svc_params ( cpi ) ; encode_frame_to_data_rate ( cpi , size , dest , frame_flags ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int dump_all_tablespaces ( ) { return dump_tablespaces ( NULL ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
int vp8_denoiser_filter_c ( unsigned char * mc_running_avg_y , int mc_avg_y_stride , unsigned char * running_avg_y , int avg_y_stride , unsigned char * sig , int sig_stride , unsigned int motion_magnitude , int increase_denoising ) { unsigned char * running_avg_y_start = running_avg_y ; unsigned char * sig_start = sig ; int sum_diff_thresh ; int r , c ; int sum_diff = 0 ; int adj_val [ 3 ] = { 3 , 4 , 6 } ; int shift_inc1 = 0 ; int shift_inc2 = 1 ; int col_sum [ 16 ] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ; if ( motion_magnitude <= MOTION_MAGNITUDE_THRESHOLD ) { if ( increase_denoising ) { shift_inc1 = 1 ; shift_inc2 = 2 ; } adj_val [ 0 ] += shift_inc2 ; adj_val [ 1 ] += shift_inc2 ; adj_val [ 2 ] += shift_inc2 ; } for ( r = 0 ; r < 16 ; ++ r ) { for ( c = 0 ; c < 16 ; ++ c ) { int diff = 0 ; int adjustment = 0 ; int absdiff = 0 ; diff = mc_running_avg_y [ c ] - sig [ c ] ; absdiff = abs ( diff ) ; if ( absdiff <= 3 + shift_inc1 ) { running_avg_y [ c ] = mc_running_avg_y [ c ] ; col_sum [ c ] += diff ; } else { if ( absdiff >= 4 + shift_inc1 && absdiff <= 7 ) adjustment = adj_val [ 0 ] ; else if ( absdiff >= 8 && absdiff <= 15 ) adjustment = adj_val [ 1 ] ; else adjustment = adj_val [ 2 ] ; if ( diff > 0 ) { if ( ( sig [ c ] + adjustment ) > 255 ) running_avg_y [ c ] = 255 ; else running_avg_y [ c ] = sig [ c ] + adjustment ; col_sum [ c ] += adjustment ; } else { if ( ( sig [ c ] - adjustment ) < 0 ) running_avg_y [ c ] = 0 ; else running_avg_y [ c ] = sig [ c ] - adjustment ; col_sum [ c ] -= adjustment ; } } } sig += sig_stride ; mc_running_avg_y += mc_avg_y_stride ; running_avg_y += avg_y_stride ; } for ( c = 0 ; c < 16 ; ++ c ) { if ( col_sum [ c ] >= 128 ) { col_sum [ c ] = 127 ; } sum_diff += col_sum [ c ] ; } sum_diff_thresh = SUM_DIFF_THRESHOLD ; if ( increase_denoising ) sum_diff_thresh = SUM_DIFF_THRESHOLD_HIGH ; if ( abs ( sum_diff ) > sum_diff_thresh ) { int delta = ( ( abs ( sum_diff ) - sum_diff_thresh ) >> 8 ) + 1 ; if ( delta < 4 ) { sig -= sig_stride * 16 ; mc_running_avg_y -= mc_avg_y_stride * 16 ; running_avg_y -= avg_y_stride * 16 ; for ( r = 0 ; r < 16 ; ++ r ) { for ( c = 0 ; c < 16 ; ++ c ) { int diff = mc_running_avg_y [ c ] - sig [ c ] ; int adjustment = abs ( diff ) ; if ( adjustment > delta ) adjustment = delta ; if ( diff > 0 ) { if ( running_avg_y [ c ] - adjustment < 0 ) running_avg_y [ c ] = 0 ; else running_avg_y [ c ] = running_avg_y [ c ] - adjustment ; col_sum [ c ] -= adjustment ; } else if ( diff < 0 ) { if ( running_avg_y [ c ] + adjustment > 255 ) running_avg_y [ c ] = 255 ; else running_avg_y [ c ] = running_avg_y [ c ] + adjustment ; col_sum [ c ] += adjustment ; } } sig += sig_stride ; mc_running_avg_y += mc_avg_y_stride ; running_avg_y += avg_y_stride ; } sum_diff = 0 ; for ( c = 0 ; c < 16 ; ++ c ) { if ( col_sum [ c ] >= 128 ) { col_sum [ c ] = 127 ; } sum_diff += col_sum [ c ] ; } if ( abs ( sum_diff ) > sum_diff_thresh ) return COPY_BLOCK ; } else { return COPY_BLOCK ; } } vp8_copy_mem16x16 ( running_avg_y_start , avg_y_stride , sig_start , sig_stride ) ; return FILTER_BLOCK ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
struct event_base * event_init ( void ) { struct event_base * base = event_base_new ( ) ; if ( base != NULL ) current_base = base ; return ( base ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static guint32 dissect_netb_receive_continue ( tvbuff_t * tvb , packet_info * pinfo _U_ , int offset , proto_tree * tree ) { nb_xmit_corrl ( tvb , offset , tree ) ; nb_remote_session ( tvb , offset , tree ) ; nb_local_session ( tvb , offset , tree ) ; return 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void lsf2lsp_3 ( AMRContext * p ) { const uint16_t * lsf_param = p -> frame . lsf ; int16_t lsf_r [ LP_FILTER_ORDER ] ; float lsf_q [ LP_FILTER_ORDER ] ; const int16_t * lsf_quantizer ; int i , j ; lsf_quantizer = ( p -> cur_frame_mode == MODE_7k95 ? lsf_3_1_MODE_7k95 : lsf_3_1 ) [ lsf_param [ 0 ] ] ; memcpy ( lsf_r , lsf_quantizer , 3 * sizeof ( * lsf_r ) ) ; lsf_quantizer = lsf_3_2 [ lsf_param [ 1 ] << ( p -> cur_frame_mode <= MODE_5k15 ) ] ; memcpy ( lsf_r + 3 , lsf_quantizer , 3 * sizeof ( * lsf_r ) ) ; lsf_quantizer = ( p -> cur_frame_mode <= MODE_5k15 ? lsf_3_3_MODE_5k15 : lsf_3_3 ) [ lsf_param [ 2 ] ] ; memcpy ( lsf_r + 6 , lsf_quantizer , 4 * sizeof ( * lsf_r ) ) ; for ( i = 0 ; i < LP_FILTER_ORDER ; i ++ ) lsf_q [ i ] = ( lsf_r [ i ] + p -> prev_lsf_r [ i ] * pred_fac [ i ] ) * ( LSF_R_FAC / 8000.0 ) + lsf_3_mean [ i ] * ( 1.0 / 8000.0 ) ; ff_set_min_dist_lsf ( lsf_q , MIN_LSF_SPACING , LP_FILTER_ORDER ) ; interpolate_lsf ( p -> lsf_q , lsf_q ) ; memcpy ( p -> prev_lsf_r , lsf_r , LP_FILTER_ORDER * sizeof ( * lsf_r ) ) ; ff_acelp_lsf2lspd ( p -> lsp [ 3 ] , lsf_q , LP_FILTER_ORDER ) ; for ( i = 1 ; i <= 3 ; i ++ ) for ( j = 0 ; j < LP_FILTER_ORDER ; j ++ ) p -> lsp [ i - 1 ] [ j ] = p -> prev_lsp_sub4 [ j ] + ( p -> lsp [ 3 ] [ j ] - p -> prev_lsp_sub4 [ j ] ) * 0.25 * i ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static ASN1_STRING * obj_to_asn1derstr ( VALUE obj ) { ASN1_STRING * a1str ; VALUE str ; str = ossl_to_der ( obj ) ; if ( ! ( a1str = ASN1_STRING_new ( ) ) ) ossl_raise ( eASN1Error , NULL ) ; ASN1_STRING_set ( a1str , RSTRING_PTR ( str ) , RSTRING_LENINT ( str ) ) ; return a1str ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void pdf_set_shade ( fz_context * ctx , pdf_run_processor * pr , int what , fz_shade * shade ) { pdf_gstate * gs ; pdf_material * mat ; gs = pdf_flush_text ( ctx , pr ) ; mat = what == PDF_FILL ? & gs -> fill : & gs -> stroke ; fz_drop_shade ( ctx , mat -> shade ) ; mat -> kind = PDF_MAT_SHADE ; mat -> shade = fz_keep_shade ( ctx , shade ) ; mat -> gstate_num = pr -> gparent ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void _HZOpen ( UConverter * cnv , UConverterLoadArgs * pArgs , UErrorCode * errorCode ) { UConverter * gbConverter ; if ( pArgs -> onlyTestIsLoadable ) { ucnv_canCreateConverter ( "GBK" , errorCode ) ; return ; } gbConverter = ucnv_open ( "GBK" , errorCode ) ; if ( U_FAILURE ( * errorCode ) ) { return ; } cnv -> toUnicodeStatus = 0 ; cnv -> fromUnicodeStatus = 0 ; cnv -> mode = 0 ; cnv -> fromUChar32 = 0x0000 ; cnv -> extraInfo = uprv_calloc ( 1 , sizeof ( UConverterDataHZ ) ) ; if ( cnv -> extraInfo != NULL ) { ( ( UConverterDataHZ * ) cnv -> extraInfo ) -> gbConverter = gbConverter ; } else { ucnv_close ( gbConverter ) ; * errorCode = U_MEMORY_ALLOCATION_ERROR ; return ; } }
1True
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_cipsafety ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data _U_ ) { proto_item * ti ; proto_tree * safety_tree ; ti = proto_tree_add_item ( tree , proto_cipsafety , tvb , 0 , - 1 , ENC_NA ) ; safety_tree = proto_item_add_subtree ( ti , ett_cip_safety ) ; dissect_cip_safety_data ( safety_tree , ti , tvb , tvb_reported_length ( tvb ) , pinfo ) ; return tvb_captured_length ( tvb ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void vp9_remove_common ( VP9_COMMON * cm ) { vp9_free_ref_frame_buffers ( cm ) ; vp9_free_context_buffers ( cm ) ; vp9_free_internal_frame_buffers ( & cm -> int_frame_buffers ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
TEST_F ( ExtensionWelcomeNotificationTest , DismissWelcomeNotification ) { StartPreferenceSyncing ( ) ; EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ; EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ; EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ; ShowChromeNowNotification ( ) ; message_center ( ) -> CloseCurrentNotification ( ) ; FlushMessageLoop ( ) ; EXPECT_EQ ( message_center ( ) -> add_notification_calls ( ) , 1 ) ; EXPECT_EQ ( message_center ( ) -> remove_notification_calls ( ) , 1 ) ; EXPECT_EQ ( message_center ( ) -> notifications_with_shown_as_popup ( ) , 0 ) ; EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ; EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ; EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int encode_slices ( VC2EncContext * s ) { uint8_t * buf ; int slice_x , slice_y , skip = 0 ; SliceArgs * enc_args = s -> slice_args ; avpriv_align_put_bits ( & s -> pb ) ; flush_put_bits ( & s -> pb ) ; buf = put_bits_ptr ( & s -> pb ) ; for ( slice_y = 0 ; slice_y < s -> num_y ; slice_y ++ ) { for ( slice_x = 0 ; slice_x < s -> num_x ; slice_x ++ ) { SliceArgs * args = & enc_args [ s -> num_x * slice_y + slice_x ] ; init_put_bits ( & args -> pb , buf + skip , args -> bytes + s -> prefix_bytes ) ; skip += args -> bytes ; } } s -> avctx -> execute ( s -> avctx , encode_hq_slice , enc_args , NULL , s -> num_x * s -> num_y , sizeof ( SliceArgs ) ) ; skip_put_bytes ( & s -> pb , skip ) ; return 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
int i2d_ ## name ( const type * a , unsigned char * * out ) ; DECLARE_ASN1_ITEM ( name ) # define DECLARE_ASN1_NDEF_FUNCTION ( name ) int i2d_ ## name ## _NDEF ( name * a , unsigned char * * out ) ; # define DECLARE_ASN1_FUNCTIONS_const ( name ) DECLARE_ASN1_ALLOC_FUNCTIONS ( name ) DECLARE_ASN1_ENCODE_FUNCTIONS_const ( name , name ) # define DECLARE_ASN1_ALLOC_FUNCTIONS_name ( type , name ) type * name ## _new ( void ) ; void name ## _free ( type * a ) ; # define DECLARE_ASN1_PRINT_FUNCTION ( stname ) DECLARE_ASN1_PRINT_FUNCTION_fname ( stname , stname ) # define DECLARE_ASN1_PRINT_FUNCTION_fname ( stname , fname ) int fname ## _print_ctx ( BIO * out , stname * x , int indent , const ASN1_PCTX * pctx ) ; # define D2I_OF ( type ) type * ( * ) ( type * * , const unsigned char * * , long ) # define I2D_OF ( type ) int ( * ) ( type * , unsigned char * * ) # define I2D_OF_const ( type ) int ( * ) ( const type * , unsigned char * * ) # define CHECKED_D2I_OF ( type , d2i ) ( ( d2i_of_void * ) ( 1 ? d2i : ( ( D2I_OF ( type ) ) 0 ) ) ) # define CHECKED_I2D_OF ( type , i2d ) ( ( i2d_of_void * ) ( 1 ? i2d : ( ( I2D_OF ( type ) ) 0 ) ) ) # define CHECKED_NEW_OF ( type , xnew ) ( ( void * ( * ) ( void ) ) ( 1 ? xnew : ( ( type * ( * ) ( void ) ) 0 ) ) ) # define CHECKED_PTR_OF ( type , p ) ( ( void * ) ( 1 ? p : ( type * ) 0 ) ) # define CHECKED_PPTR_OF ( type , p ) ( ( void * * ) ( 1 ? p : ( type * * ) 0 ) ) # define TYPEDEF_D2I_OF ( type ) typedef type * d2i_of_ ## type ( type * * , const unsigned char * * , long ) # define TYPEDEF_I2D_OF ( type ) typedef int i2d_of_ ## type ( type * , unsigned char * * ) # define TYPEDEF_D2I2D_OF ( type ) TYPEDEF_D2I_OF ( type ) ; TYPEDEF_I2D_OF ( type ) TYPEDEF_D2I2D_OF ( void ) ; # ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION typedef const ASN1_ITEM ASN1_ITEM_EXP ; # define ASN1_ITEM_ptr ( iptr ) ( iptr ) # define ASN1_ITEM_ref ( iptr ) ( & ( iptr ## _it ) ) # define ASN1_ITEM_rptr ( ref ) ( & ( ref ## _it ) ) # define DECLARE_ASN1_ITEM ( name ) OPENSSL_EXTERN const ASN1_ITEM name ## _it ; # else typedef const ASN1_ITEM * ASN1_ITEM_EXP ( void ) ; # define ASN1_ITEM_ptr ( iptr ) ( iptr ( ) ) # define ASN1_ITEM_ref ( iptr ) ( iptr ## _it ) # define ASN1_ITEM_rptr ( ref ) ( ref ## _it ( ) ) # define DECLARE_ASN1_ITEM ( name ) const ASN1_ITEM * name ## _it ( void ) ; # endif # define ASN1_STRFLGS_ESC_2253 1 # define ASN1_STRFLGS_ESC_CTRL 2 # define ASN1_STRFLGS_ESC_MSB 4 # define ASN1_STRFLGS_ESC_QUOTE 8 # define CHARTYPE_PRINTABLESTRING 0x10 # define CHARTYPE_FIRST_ESC_2253 0x20 # define CHARTYPE_LAST_ESC_2253 0x40 # define ASN1_STRFLGS_UTF8_CONVERT 0x10 # define ASN1_STRFLGS_IGNORE_TYPE 0x20 # define ASN1_STRFLGS_SHOW_TYPE 0x40 # define ASN1_STRFLGS_DUMP_ALL 0x80 # define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 # define ASN1_STRFLGS_DUMP_DER 0x200 # define ASN1_STRFLGS_ESC_2254 0x400 # define ASN1_STRFLGS_RFC2253 ( ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | ASN1_STRFLGS_UTF8_CONVERT | ASN1_STRFLGS_DUMP_UNKNOWN | ASN1_STRFLGS_DUMP_DER ) DEFINE_STACK_OF ( ASN1_INTEGER ) DEFINE_STACK_OF ( ASN1_GENERALSTRING ) DEFINE_STACK_OF ( ASN1_UTF8STRING ) typedef struct asn1_type_st { int type ; union { char * ptr ; ASN1_BOOLEAN boolean ; ASN1_STRING * asn1_string ; ASN1_OBJECT * object ; ASN1_INTEGER * integer ; ASN1_ENUMERATED * enumerated ; ASN1_BIT_STRING * bit_string ; ASN1_OCTET_STRING * octet_string ; ASN1_PRINTABLESTRING * printablestring ; ASN1_T61STRING * t61string ; ASN1_IA5STRING * ia5string ; ASN1_GENERALSTRING * generalstring ; ASN1_BMPSTRING * bmpstring ; ASN1_UNIVERSALSTRING * universalstring ; ASN1_UTCTIME * utctime ; ASN1_GENERALIZEDTIME * generalizedtime ; ASN1_VISIBLESTRING * visiblestring ; ASN1_UTF8STRING * utf8string ; ASN1_STRING * set ; ASN1_STRING * sequence ; ASN1_VALUE * asn1_value ; } value ; } ASN1_TYPE ; DEFINE_STACK_OF ( ASN1_TYPE ) typedef STACK_OF ( ASN1_TYPE ) ASN1_SEQUENCE_ANY ; DECLARE_ASN1_ENCODE_FUNCTIONS_const ( ASN1_SEQUENCE_ANY , ASN1_SEQUENCE_ANY ) DECLARE_ASN1_ENCODE_FUNCTIONS_const ( ASN1_SEQUENCE_ANY , ASN1_SET_ANY )
0False
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_h225_RasUsageInfoTypes ( 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_h225_RasUsageInfoTypes , RasUsageInfoTypes_sequence ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
struct st_replace_regex * init_replace_regex ( char * expr ) { struct st_replace_regex * res ; char * buf , * expr_end ; char * p ; char * buf_p ; uint expr_len = strlen ( expr ) ; char last_c = 0 ; struct st_regex reg ; res = ( struct st_replace_regex * ) my_malloc ( sizeof ( * res ) + expr_len , MYF ( MY_FAE + MY_WME ) ) ; my_init_dynamic_array ( & res -> regex_arr , sizeof ( struct st_regex ) , 128 , 128 ) ; buf = ( char * ) res + sizeof ( * res ) ; expr_end = expr + expr_len ; p = expr ; buf_p = buf ; while ( p < expr_end ) { bzero ( & reg , sizeof ( reg ) ) ; while ( p < expr_end ) { if ( * p == '/' ) break ; p ++ ; } if ( p == expr_end || ++ p == expr_end ) { if ( res -> regex_arr . elements ) break ; else goto err ; } reg . pattern = buf_p ; PARSE_REGEX_ARG if ( p == expr_end || ++ p == expr_end ) goto err ; reg . replace = buf_p ; PARSE_REGEX_ARG if ( p == expr_end ) goto err ; p ++ ; if ( p < expr_end && * p == 'i' ) reg . icase = 1 ; if ( insert_dynamic ( & res -> regex_arr , ( uchar * ) & reg ) ) die ( "Out of memory" ) ; } res -> odd_buf_len = res -> even_buf_len = 8192 ; res -> even_buf = ( char * ) my_malloc ( res -> even_buf_len , MYF ( MY_WME + MY_FAE ) ) ; res -> odd_buf = ( char * ) my_malloc ( res -> odd_buf_len , MYF ( MY_WME + MY_FAE ) ) ; res -> buf = res -> even_buf ; return res ; err : my_free ( res ) ; die ( "Error parsing replace_regex \"%s\"" , expr ) ; return 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int decode_packet ( AVCodecContext * avctx , void * data , int * got_frame_ptr , AVPacket * avpkt ) { WMAProDecodeCtx * s = avctx -> priv_data ; GetBitContext * gb = & s -> pgb ; const uint8_t * buf = avpkt -> data ; int buf_size = avpkt -> size ; int num_bits_prev_frame ; int packet_sequence_number ; * got_frame_ptr = 0 ; if ( s -> packet_done || s -> packet_loss ) { s -> packet_done = 0 ; if ( buf_size < avctx -> block_align ) return 0 ; s -> next_packet_start = buf_size - avctx -> block_align ; buf_size = avctx -> block_align ; s -> buf_bit_size = buf_size << 3 ; init_get_bits ( gb , buf , s -> buf_bit_size ) ; packet_sequence_number = get_bits ( gb , 4 ) ; skip_bits ( gb , 2 ) ; num_bits_prev_frame = get_bits ( gb , s -> log2_frame_size ) ; av_dlog ( avctx , "packet[%d]: nbpf %x\n" , avctx -> frame_number , num_bits_prev_frame ) ; if ( ! s -> packet_loss && ( ( s -> packet_sequence_number + 1 ) & 0xF ) != packet_sequence_number ) { s -> packet_loss = 1 ; av_log ( avctx , AV_LOG_ERROR , "Packet loss detected! seq %x vs %x\n" , s -> packet_sequence_number , packet_sequence_number ) ; } s -> packet_sequence_number = packet_sequence_number ; if ( num_bits_prev_frame > 0 ) { int remaining_packet_bits = s -> buf_bit_size - get_bits_count ( gb ) ; if ( num_bits_prev_frame >= remaining_packet_bits ) { num_bits_prev_frame = remaining_packet_bits ; s -> packet_done = 1 ; } save_bits ( s , gb , num_bits_prev_frame , 1 ) ; av_dlog ( avctx , "accumulated %x bits of frame data\n" , s -> num_saved_bits - s -> frame_offset ) ; if ( ! s -> packet_loss ) decode_frame ( s , data , got_frame_ptr ) ; } else if ( s -> num_saved_bits - s -> frame_offset ) { av_dlog ( avctx , "ignoring %x previously saved bits\n" , s -> num_saved_bits - s -> frame_offset ) ; } if ( s -> packet_loss ) { s -> num_saved_bits = 0 ; s -> packet_loss = 0 ; } } else { int frame_size ; s -> buf_bit_size = ( avpkt -> size - s -> next_packet_start ) << 3 ; init_get_bits ( gb , avpkt -> data , s -> buf_bit_size ) ; skip_bits ( gb , s -> packet_offset ) ; if ( s -> len_prefix && remaining_bits ( s , gb ) > s -> log2_frame_size && ( frame_size = show_bits ( gb , s -> log2_frame_size ) ) && frame_size <= remaining_bits ( s , gb ) ) { save_bits ( s , gb , frame_size , 0 ) ; s -> packet_done = ! decode_frame ( s , data , got_frame_ptr ) ; } else if ( ! s -> len_prefix && s -> num_saved_bits > get_bits_count ( & s -> gb ) ) { s -> packet_done = ! decode_frame ( s , data , got_frame_ptr ) ; } else s -> packet_done = 1 ; } if ( s -> packet_done && ! s -> packet_loss && remaining_bits ( s , gb ) > 0 ) { save_bits ( s , gb , remaining_bits ( s , gb ) , 0 ) ; } s -> packet_offset = get_bits_count ( gb ) & 7 ; if ( s -> packet_loss ) return AVERROR_INVALIDDATA ; return get_bits_count ( gb ) >> 3 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void * xmlListReverseSearch ( xmlListPtr l , void * data ) { xmlLinkPtr lk ; if ( l == NULL ) return ( NULL ) ; lk = xmlListLinkReverseSearch ( l , data ) ; if ( lk ) return ( lk -> data ) ; return NULL ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_h245_Cmd_aal1 ( 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_Cmd_aal1 , Cmd_aal1_sequence ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int roq_encode_init ( AVCodecContext * avctx ) { RoqContext * enc = avctx -> priv_data ; av_lfg_init ( & enc -> randctx , 1 ) ; enc -> framesSinceKeyframe = 0 ; if ( ( avctx -> width & 0xf ) || ( avctx -> height & 0xf ) ) { av_log ( avctx , AV_LOG_ERROR , "Dimensions must be divisible by 16\n" ) ; return - 1 ; } if ( ( ( avctx -> width ) & ( avctx -> width - 1 ) ) || ( ( avctx -> height ) & ( avctx -> height - 1 ) ) ) av_log ( avctx , AV_LOG_ERROR , "Warning: dimensions not power of two\n" ) ; enc -> width = avctx -> width ; enc -> height = avctx -> height ; enc -> framesSinceKeyframe = 0 ; enc -> first_frame = 1 ; enc -> last_frame = av_frame_alloc ( ) ; enc -> current_frame = av_frame_alloc ( ) ; if ( ! enc -> last_frame || ! enc -> current_frame ) { roq_encode_end ( avctx ) ; return AVERROR ( ENOMEM ) ; } enc -> tmpData = av_malloc ( sizeof ( RoqTempdata ) ) ; enc -> this_motion4 = av_mallocz ( ( enc -> width * enc -> height / 16 ) * sizeof ( motion_vect ) ) ; enc -> last_motion4 = av_malloc ( ( enc -> width * enc -> height / 16 ) * sizeof ( motion_vect ) ) ; enc -> this_motion8 = av_mallocz ( ( enc -> width * enc -> height / 64 ) * sizeof ( motion_vect ) ) ; enc -> last_motion8 = av_malloc ( ( enc -> width * enc -> height / 64 ) * sizeof ( motion_vect ) ) ; return 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static gboolean should_get_directory_count_now ( NautilusFile * file ) { return lacks_directory_count ( file ) && ! file -> details -> loading_directory ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void decApplyRound ( decNumber * dn , decContext * set , Int residue , uInt * status ) { Int bump ; if ( residue == 0 ) return ; bump = 0 ; switch ( set -> round ) { case DEC_ROUND_05UP : { Int lsd5 = * dn -> lsu % 5 ; if ( residue < 0 && lsd5 != 1 ) bump = - 1 ; else if ( residue > 0 && lsd5 == 0 ) bump = 1 ; break ; } case DEC_ROUND_DOWN : { if ( residue < 0 ) bump = - 1 ; break ; } case DEC_ROUND_HALF_DOWN : { if ( residue > 5 ) bump = 1 ; break ; } case DEC_ROUND_HALF_EVEN : { if ( residue > 5 ) bump = 1 ; else if ( residue == 5 ) { if ( * dn -> lsu & 0x01 ) bump = 1 ; } break ; } case DEC_ROUND_HALF_UP : { if ( residue >= 5 ) bump = 1 ; break ; } case DEC_ROUND_UP : { if ( residue > 0 ) bump = 1 ; break ; } case DEC_ROUND_CEILING : { if ( decNumberIsNegative ( dn ) ) { if ( residue < 0 ) bump = - 1 ; } else { if ( residue > 0 ) bump = 1 ; } break ; } case DEC_ROUND_FLOOR : { if ( ! decNumberIsNegative ( dn ) ) { if ( residue < 0 ) bump = - 1 ; } else { if ( residue > 0 ) bump = 1 ; } break ; } default : { * status |= DEC_Invalid_context ; # if DECTRACE || ( DECCHECK && DECVERB ) printf ( "Unknown rounding mode: %d\n" , set -> round ) ; # endif break ; } } if ( bump == 0 ) return ; if ( bump > 0 ) { Unit * up ; uInt count = dn -> digits ; for ( up = dn -> lsu ; ; up ++ ) { if ( count <= DECDPUN ) { if ( * up != powers [ count ] - 1 ) break ; * up = ( Unit ) powers [ count - 1 ] ; for ( up = up - 1 ; up >= dn -> lsu ; up -- ) * up = 0 ; dn -> exponent ++ ; if ( ( dn -> exponent + dn -> digits ) > set -> emax + 1 ) { decSetOverflow ( dn , set , status ) ; } return ; } if ( * up != DECDPUNMAX ) break ; count -= DECDPUN ; } } else { Unit * up , * sup ; uInt count = dn -> digits ; for ( up = dn -> lsu ; ; up ++ ) { if ( count <= DECDPUN ) { if ( * up != powers [ count - 1 ] ) break ; sup = up ; * up = ( Unit ) powers [ count ] - 1 ; for ( up = up - 1 ; up >= dn -> lsu ; up -- ) * up = ( Unit ) powers [ DECDPUN ] - 1 ; dn -> exponent -- ; if ( dn -> exponent + 1 == set -> emin - set -> digits + 1 ) { if ( count == 1 && dn -> digits == 1 ) * sup = 0 ; else { * sup = ( Unit ) powers [ count - 1 ] - 1 ; dn -> digits -- ; } dn -> exponent ++ ; * status |= DEC_Underflow | DEC_Subnormal | DEC_Inexact | DEC_Rounded ; } return ; } if ( * up != 0 ) break ; count -= DECDPUN ; } } decUnitAddSub ( dn -> lsu , D2U ( dn -> digits ) , uarrone , 1 , 0 , dn -> lsu , bump ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static gs_memory_type_ptr_t i_object_type ( const gs_memory_t * mem , const void * obj ) { return ( ( const obj_header_t * ) obj - 1 ) -> o_type ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int znoaccess ( i_ctx_t * i_ctx_p ) { os_ptr op = osp ; check_op ( 1 ) ; if ( r_has_type ( op , t_dictionary ) ) { ref * aop = dict_access_ref ( op ) ; if ( ! r_has_attrs ( aop , a_write ) ) { if ( ! r_has_attrs ( aop , a_read ) && ! r_has_attrs ( aop , a_execute ) ) { return 0 ; } return_error ( gs_error_invalidaccess ) ; } if ( dict_is_permanent_on_dstack ( op ) ) return_error ( gs_error_invalidaccess ) ; } return access_check ( i_ctx_p , 0 , true ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
int file_is_raw ( struct VpxInputContext * input ) { uint8_t buf [ 32 ] ; int is_raw = 0 ; vpx_codec_stream_info_t si ; si . sz = sizeof ( si ) ; if ( fread ( buf , 1 , 32 , input -> file ) == 32 ) { int i ; if ( mem_get_le32 ( buf ) < 256 * 1024 * 1024 ) { for ( i = 0 ; i < get_vpx_decoder_count ( ) ; ++ i ) { const VpxInterface * const decoder = get_vpx_decoder_by_index ( i ) ; if ( ! vpx_codec_peek_stream_info ( decoder -> codec_interface ( ) , buf + 4 , 32 - 4 , & si ) ) { is_raw = 1 ; input -> fourcc = decoder -> fourcc ; input -> width = si . w ; input -> height = si . h ; input -> framerate . numerator = 30 ; input -> framerate . denominator = 1 ; break ; } } } } rewind ( input -> file ) ; return is_raw ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static struct row_pairs * gtkui_connections_add ( struct conn_object * co , void * conn , struct row_pairs * * list ) { GtkTreeIter iter ; char flags [ 2 ] , src [ MAX_ASCII_ADDR_LEN ] , dst [ MAX_ASCII_ADDR_LEN ] ; char proto [ 4 ] , status [ 8 ] , ccodes [ 8 ] ; unsigned int src_port = 0 , dst_port = 0 , tx = 0 , rx = 0 ; struct row_pairs * row = NULL ; if ( ! list ) return ( NULL ) ; memset ( & flags , 0 , sizeof ( flags ) ) ; memset ( & proto , 0 , sizeof ( proto ) ) ; memset ( & src , 0 , sizeof ( src ) ) ; memset ( & dst , 0 , sizeof ( dst ) ) ; memset ( & status , 0 , sizeof ( status ) ) ; memset ( & ccodes , 0 , sizeof ( ccodes ) ) ; conntrack_flagstr ( co , flags , sizeof ( flags ) ) ; conntrack_statusstr ( co , status , sizeof ( status ) ) ; conntrack_protostr ( co , proto , sizeof ( proto ) ) ; conntrack_countrystr ( co , ccodes , sizeof ( ccodes ) ) ; ip_addr_ntoa ( & co -> L3_addr1 , src ) ; ip_addr_ntoa ( & co -> L3_addr2 , dst ) ; src_port = ntohs ( co -> L4_addr1 ) ; dst_port = ntohs ( co -> L4_addr2 ) ; tx = co -> tx ; rx = co -> rx ; gtk_list_store_append ( ls_conns , & iter ) ; gtk_list_store_set ( ls_conns , & iter , 0 , flags , 1 , src , 2 , src_port , 3 , "-" , 4 , dst , 5 , dst_port , 6 , proto , 7 , status , 8 , tx , 9 , rx , 10 , ccodes , 11 , conn , - 1 ) ; if ( ! * list ) { row = malloc ( sizeof ( struct row_pairs ) ) ; if ( row == NULL ) { USER_MSG ( "Failed create new connection row\n" ) ; DEBUG_MSG ( "gktui_connections_add: failed to allocate memory for a new row" ) ; } row -> prev = NULL ; } else { for ( row = * list ; row && row -> next ; row = row -> next ) ; row -> next = malloc ( sizeof ( struct row_pairs ) ) ; if ( row -> next == NULL ) { USER_MSG ( "Failed create new connection row\n" ) ; DEBUG_MSG ( "gktui_connections_add: failed to allocate memory for a new row" ) ; } row -> next -> prev = row ; row = row -> next ; } row -> conn = conn ; row -> iter = iter ; row -> next = NULL ; if ( ! * list ) * list = row ; return ( row ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int mem_resize ( jas_stream_memobj_t * m , int bufsize ) { unsigned char * buf ; assert ( m -> buf_ ) ; assert ( bufsize >= 0 ) ; if ( ! ( buf = jas_realloc2 ( m -> buf_ , bufsize , sizeof ( unsigned char ) ) ) ) { return - 1 ; } m -> buf_ = buf ; m -> bufsize_ = bufsize ; return 0 ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static void virtio_net_handle_rx ( VirtIODevice * vdev , VirtQueue * vq ) { VirtIONet * n = to_virtio_net ( vdev ) ; qemu_flush_queued_packets ( & n -> nic -> nc ) ; qemu_notify_event ( ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
int x_catch_free_colors ( Display * dpy , XErrorEvent * err ) { if ( err -> request_code == X_FreeColors || x_error_handler . orighandler == x_catch_free_colors ) return 0 ; return x_error_handler . orighandler ( dpy , err ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void write_sync_code ( struct vp9_write_bit_buffer * wb ) { vp9_wb_write_literal ( wb , VP9_SYNC_CODE_0 , 8 ) ; vp9_wb_write_literal ( wb , VP9_SYNC_CODE_1 , 8 ) ; vp9_wb_write_literal ( wb , VP9_SYNC_CODE_2 , 8 ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static bool e1000e_do_ps ( E1000ECore * core , struct NetRxPkt * pkt , size_t * hdr_len ) { bool isip4 , isip6 , isudp , istcp ; bool fragment ; if ( ! e1000e_rx_use_ps_descriptor ( core ) ) { return false ; } net_rx_pkt_get_protocols ( pkt , & isip4 , & isip6 , & isudp , & istcp ) ; if ( isip4 ) { fragment = net_rx_pkt_get_ip4_info ( pkt ) -> fragment ; } else if ( isip6 ) { fragment = net_rx_pkt_get_ip6_info ( pkt ) -> fragment ; } else { return false ; } if ( fragment && ( core -> mac [ RFCTL ] & E1000_RFCTL_IPFRSP_DIS ) ) { return false ; } if ( ! fragment && ( isudp || istcp ) ) { * hdr_len = net_rx_pkt_get_l5_hdr_offset ( pkt ) ; } else { * hdr_len = net_rx_pkt_get_l4_hdr_offset ( pkt ) ; } if ( ( * hdr_len > core -> rxbuf_sizes [ 0 ] ) || ( * hdr_len > net_rx_pkt_get_total_len ( pkt ) ) ) { return false ; } return true ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void mime_scanner_append ( MIMEScanner * scanner , const char * data , int data_size ) { int free_size = scanner -> m_line_size - scanner -> m_line_length ; if ( data_size > free_size ) { if ( scanner -> m_line_size == 0 ) { scanner -> m_line_size = 128 ; } while ( free_size < data_size ) { scanner -> m_line_size *= 2 ; free_size = scanner -> m_line_size - scanner -> m_line_length ; } if ( scanner -> m_line == nullptr ) { scanner -> m_line = ( char * ) ats_malloc ( scanner -> m_line_size ) ; } else { scanner -> m_line = ( char * ) ats_realloc ( scanner -> m_line , scanner -> m_line_size ) ; } } memcpy ( & ( scanner -> m_line [ scanner -> m_line_length ] ) , data , data_size ) ; scanner -> m_line_length += data_size ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
REGRESSION_TEST ( SDK_API_TSCache ) ( RegressionTest * test , int , int * pstatus ) { * pstatus = REGRESSION_TEST_INPROGRESS ; SDK_Cache_test = test ; SDK_Cache_pstatus = pstatus ; int is_ready = 0 ; TSCacheReady ( & is_ready ) ; if ( ! is_ready ) { SDK_RPRINT ( test , "TSCacheReady" , "TestCase1" , TC_FAIL , "cache is not ready" ) ; * pstatus = REGRESSION_TEST_FAILED ; return ; } else { SDK_RPRINT ( test , "TSCacheReady" , "TestCase1" , TC_PASS , "ok" ) ; } char key_name [ ] = "key_for_regression_test" ; TSCacheKey key = TSCacheKeyCreate ( ) ; TSCacheKey key_cmp = TSCacheKeyCreate ( ) ; SDK_RPRINT ( test , "TSCacheKeyCreate" , "TestCase1" , TC_PASS , "ok" ) ; TSCacheKeyDigestSet ( key , key_name , strlen ( key_name ) ) ; TSCacheKeyDigestSet ( key_cmp , key_name , strlen ( key_name ) ) ; # if 0 if ( memcmp ( key , key_cmp , sizeof ( TSCacheKey ) ) != 0 ) { SDK_RPRINT ( test , "TSCacheKeySetDigest" , "TestCase1" , TC_FAIL , "digest is wrong" ) ; * pstatus = REGRESSION_TEST_FAILED ; TSCacheKeyDestroy ( key ) ; TSCacheKeyDestroy ( key_cmp ) ; return ; } else { SDK_RPRINT ( test , "TSCacheKeySetDigest" , "TestCase1" , TC_PASS , "ok" ) ; TSCacheKeyDestroy ( key_cmp ) ; } # endif for ( int i = 0 ; i < ( OBJECT_SIZE - 1 ) ; i ++ ) { content [ i ] = 'a' ; } content [ OBJECT_SIZE - 1 ] = '\0' ; TSCont contp = TSContCreate ( cache_handler , TSMutexCreate ( ) ) ; CacheVConnStruct * cache_vconn = ( CacheVConnStruct * ) TSmalloc ( sizeof ( CacheVConnStruct ) ) ; cache_vconn -> key = key ; TSContDataSet ( contp , cache_vconn ) ; TSCacheWrite ( contp , key ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_h245_OCTET_STRING_SIZE_1_256 ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_octet_string ( tvb , offset , actx , tree , hf_index , 1 , 256 , FALSE , NULL ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
Oid get_ordering_op_for_equality_op ( Oid opno , bool use_lhs_type ) { Oid result = InvalidOid ; CatCList * catlist ; int i ; catlist = SearchSysCacheList1 ( AMOPOPID , ObjectIdGetDatum ( opno ) ) ; for ( i = 0 ; i < catlist -> n_members ; i ++ ) { HeapTuple tuple = & catlist -> members [ i ] -> tuple ; Form_pg_amop aform = ( Form_pg_amop ) GETSTRUCT ( tuple ) ; if ( aform -> amopmethod != BTREE_AM_OID ) continue ; if ( aform -> amopstrategy == BTEqualStrategyNumber ) { Oid typid ; typid = use_lhs_type ? aform -> amoplefttype : aform -> amoprighttype ; result = get_opfamily_member ( aform -> amopfamily , typid , typid , BTLessStrategyNumber ) ; if ( OidIsValid ( result ) ) break ; } } ReleaseSysCacheList ( catlist ) ; return result ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void vp9_iht8x8_add ( TX_TYPE tx_type , const int16_t * input , uint8_t * dest , int stride , int eob ) { if ( tx_type == DCT_DCT ) { vp9_idct8x8_add ( input , dest , stride , eob ) ; } else { vp9_iht8x8_64_add ( input , dest , stride , tx_type ) ; } }
1True
Categorize the following code snippet as vulnerable or not. True or False
static void raw ( struct parse * pcmd , FILE * fp ) { rawmode = 1 ; ( void ) fprintf ( fp , "Output set to raw\n" ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
TSReturnCode TSUrlClone ( TSMBuffer dest_bufp , TSMBuffer src_bufp , TSMLoc src_url , TSMLoc * locp ) { sdk_assert ( sdk_sanity_check_mbuffer ( src_bufp ) == TS_SUCCESS ) ; sdk_assert ( sdk_sanity_check_mbuffer ( dest_bufp ) == TS_SUCCESS ) ; sdk_assert ( sdk_sanity_check_url_handle ( src_url ) == TS_SUCCESS ) ; sdk_assert ( sdk_sanity_check_null_ptr ( locp ) == TS_SUCCESS ) ; if ( ! isWriteable ( dest_bufp ) ) { return TS_ERROR ; } HdrHeap * s_heap , * d_heap ; URLImpl * s_url , * d_url ; s_heap = ( ( HdrHeapSDKHandle * ) src_bufp ) -> m_heap ; d_heap = ( ( HdrHeapSDKHandle * ) dest_bufp ) -> m_heap ; s_url = ( URLImpl * ) src_url ; d_url = url_copy ( s_url , s_heap , d_heap , ( s_heap != d_heap ) ) ; * locp = ( TSMLoc ) d_url ; return TS_SUCCESS ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
METHOD ( x509_t , create_subjectAltName_enumerator , enumerator_t * , private_x509_cert_t * this ) { return this -> subjectAltNames -> create_enumerator ( this -> subjectAltNames ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void deep_count_callback ( GObject * source_object , GAsyncResult * res , gpointer user_data ) { DeepCountState * state ; GFileEnumerator * enumerator ; NautilusFile * file ; state = user_data ; if ( state -> directory == NULL ) { deep_count_state_free ( state ) ; return ; } file = state -> directory -> details -> deep_count_file ; enumerator = g_file_enumerate_children_finish ( G_FILE ( source_object ) , res , NULL ) ; if ( enumerator == NULL ) { file -> details -> deep_unreadable_count += 1 ; deep_count_next_dir ( state ) ; } else { state -> enumerator = enumerator ; g_file_enumerator_next_files_async ( state -> enumerator , DIRECTORY_LOAD_ITEMS_PER_CALLBACK , G_PRIORITY_LOW , state -> cancellable , deep_count_more_files_callback , state ) ; } }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int parse_CInGroupSortAggregSets ( tvbuff_t * tvb , packet_info * pinfo , int offset , proto_tree * parent_tree , proto_tree * pad_tree , const char * fmt , ... ) { guint32 cCount , i ; proto_item * item ; proto_tree * tree ; const char * txt ; va_list ap ; 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_CInGroupSortAggregSets , & item , txt ) ; cCount = tvb_get_letohl ( tvb , offset ) ; proto_tree_add_uint ( tree , hf_mswsp_cingroupsortaggregsets_count , tvb , offset , 4 , cCount ) ; offset += 4 ; for ( i = 0 ; i < cCount ; i ++ ) { offset = parse_CInGroupSortAggregSet ( tvb , pinfo , offset , tree , pad_tree , "SortSets[%u]" , i ) ; } proto_item_set_end ( item , tvb , offset ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int show_object_fast ( const unsigned char * sha1 , enum object_type type , int exclude , uint32_t name_hash , struct packed_git * found_pack , off_t found_offset ) { fprintf ( stdout , "%s\n" , sha1_to_hex ( sha1 ) ) ; return 1 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
void key_type_put ( struct key_type * ktype ) { up_read ( & key_types_sem ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void proto_tree_set_ether ( field_info * fi , const guint8 * value ) { fvalue_set_bytes ( & fi -> value , value ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void jas_image_cmpt_destroy ( jas_image_cmpt_t * cmpt ) { if ( cmpt -> stream_ ) { jas_stream_close ( cmpt -> stream_ ) ; } jas_free ( cmpt ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static gint handle_message_sasl ( tvbuff_t * tvb , packet_info * pinfo , gint offset , proto_tree * message_tree ) { gint return_value = offset ; const sasl_cmd * command ; command = find_sasl_command ( tvb , offset ) ; if ( command ) { gint newline_offset = tvb_find_guint8 ( tvb , offset + command -> length , - 1 , '\n' ) + 1 ; if ( 0 == newline_offset ) { if ( ( guint ) tvb_captured_length_remaining ( tvb , offset ) < MAX_SASL_PACKET_LENGTH && set_pinfo_desegment ( pinfo , offset , DESEGMENT_ONE_MORE_SEGMENT ) ) { return_value = offset + command -> length ; } else { return_value = 0 ; } return return_value ; } if ( newline_offset > 0 ) { gint length = command -> length ; col_add_fstr ( pinfo -> cinfo , COL_INFO , "SASL-%s" , command -> text ) ; proto_tree_add_item ( message_tree , hf_alljoyn_sasl_command , tvb , offset , length , ENC_ASCII | ENC_NA ) ; offset += length ; length = newline_offset - offset ; proto_tree_add_item ( message_tree , hf_alljoyn_sasl_parameter , tvb , offset , length , ENC_ASCII | ENC_NA ) ; return_value = newline_offset ; } } return return_value ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int64_t rm_read_dts ( AVFormatContext * s , int stream_index , int64_t * ppos , int64_t pos_limit ) { RMDemuxContext * rm = s -> priv_data ; int64_t pos , dts ; int stream_index2 , flags , len , h ; pos = * ppos ; if ( rm -> old_format ) return AV_NOPTS_VALUE ; if ( avio_seek ( s -> pb , pos , SEEK_SET ) < 0 ) return AV_NOPTS_VALUE ; rm -> remaining_len = 0 ; for ( ; ; ) { int seq = 1 ; AVStream * st ; len = rm_sync ( s , & dts , & flags , & stream_index2 , & pos ) ; if ( len < 0 ) return AV_NOPTS_VALUE ; st = s -> streams [ stream_index2 ] ; if ( st -> codecpar -> codec_type == AVMEDIA_TYPE_VIDEO ) { h = avio_r8 ( s -> pb ) ; len -- ; if ( ! ( h & 0x40 ) ) { seq = avio_r8 ( s -> pb ) ; len -- ; } } if ( ( flags & 2 ) && ( seq & 0x7F ) == 1 ) { av_log ( s , AV_LOG_TRACE , "%d %d-%d %" PRId64 " %d\n" , flags , stream_index2 , stream_index , dts , seq ) ; av_add_index_entry ( st , pos , dts , 0 , 0 , AVINDEX_KEYFRAME ) ; if ( stream_index2 == stream_index ) break ; } avio_skip ( s -> pb , len ) ; } * ppos = pos ; return dts ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
int jas_stream_isseekable ( jas_stream_t * stream ) { if ( stream -> ops_ == & jas_stream_memops ) { return 1 ; } else if ( stream -> ops_ == & jas_stream_fileops ) { if ( ( * stream -> ops_ -> seek_ ) ( stream -> obj_ , 0 , SEEK_CUR ) < 0 ) { return 0 ; } return 1 ; } else { return 0 ; } }
0False
Categorize the following code snippet as vulnerable or not. True or False
TEST_F ( ExternalProtocolHandlerTest , TestGetBlockStateDefaultBlock ) { ExternalProtocolHandler : : BlockState block_state = ExternalProtocolHandler : : GetBlockState ( "afp" , profile_ . get ( ) ) ; EXPECT_EQ ( ExternalProtocolHandler : : BLOCK , block_state ) ; EXPECT_TRUE ( local_state_ -> GetDictionary ( prefs : : kExcludedSchemes ) -> empty ( ) ) ; EXPECT_TRUE ( profile_ -> GetPrefs ( ) -> GetDictionary ( prefs : : kExcludedSchemes ) -> empty ( ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void render_slice ( Vp3DecodeContext * s , int slice ) { int x , y , i , j , fragment ; int16_t * block = s -> block ; int motion_x = 0xdeadbeef , motion_y = 0xdeadbeef ; int motion_halfpel_index ; uint8_t * motion_source ; int plane , first_pixel ; if ( slice >= s -> c_superblock_height ) return ; for ( plane = 0 ; plane < 3 ; plane ++ ) { uint8_t * output_plane = s -> current_frame . data [ plane ] + s -> data_offset [ plane ] ; uint8_t * last_plane = s -> last_frame . data [ plane ] + s -> data_offset [ plane ] ; uint8_t * golden_plane = s -> golden_frame . data [ plane ] + s -> data_offset [ plane ] ; int stride = s -> current_frame . linesize [ plane ] ; int plane_width = s -> width >> ( plane && s -> chroma_x_shift ) ; int plane_height = s -> height >> ( plane && s -> chroma_y_shift ) ; int8_t ( * motion_val ) [ 2 ] = s -> motion_val [ ! ! plane ] ; int sb_x , sb_y = slice << ( ! plane && s -> chroma_y_shift ) ; int slice_height = sb_y + 1 + ( ! plane && s -> chroma_y_shift ) ; int slice_width = plane ? s -> c_superblock_width : s -> y_superblock_width ; int fragment_width = s -> fragment_width [ ! ! plane ] ; int fragment_height = s -> fragment_height [ ! ! plane ] ; int fragment_start = s -> fragment_start [ plane ] ; int do_await = ! plane && HAVE_THREADS && ( s -> avctx -> active_thread_type & FF_THREAD_FRAME ) ; if ( ! s -> flipped_image ) stride = - stride ; if ( CONFIG_GRAY && plane && ( s -> avctx -> flags & CODEC_FLAG_GRAY ) ) continue ; for ( ; sb_y < slice_height ; sb_y ++ ) { for ( sb_x = 0 ; sb_x < slice_width ; sb_x ++ ) { for ( j = 0 ; j < 16 ; j ++ ) { x = 4 * sb_x + hilbert_offset [ j ] [ 0 ] ; y = 4 * sb_y + hilbert_offset [ j ] [ 1 ] ; fragment = y * fragment_width + x ; i = fragment_start + fragment ; if ( x >= fragment_width || y >= fragment_height ) continue ; first_pixel = 8 * y * stride + 8 * x ; if ( do_await && s -> all_fragments [ i ] . coding_method != MODE_INTRA ) await_reference_row ( s , & s -> all_fragments [ i ] , motion_val [ fragment ] [ 1 ] , ( 16 * y ) >> s -> chroma_y_shift ) ; if ( s -> all_fragments [ i ] . coding_method != MODE_COPY ) { if ( ( s -> all_fragments [ i ] . coding_method == MODE_USING_GOLDEN ) || ( s -> all_fragments [ i ] . coding_method == MODE_GOLDEN_MV ) ) motion_source = golden_plane ; else motion_source = last_plane ; motion_source += first_pixel ; motion_halfpel_index = 0 ; if ( ( s -> all_fragments [ i ] . coding_method > MODE_INTRA ) && ( s -> all_fragments [ i ] . coding_method != MODE_USING_GOLDEN ) ) { int src_x , src_y ; motion_x = motion_val [ fragment ] [ 0 ] ; motion_y = motion_val [ fragment ] [ 1 ] ; src_x = ( motion_x >> 1 ) + 8 * x ; src_y = ( motion_y >> 1 ) + 8 * y ; motion_halfpel_index = motion_x & 0x01 ; motion_source += ( motion_x >> 1 ) ; motion_halfpel_index |= ( motion_y & 0x01 ) << 1 ; motion_source += ( ( motion_y >> 1 ) * stride ) ; if ( src_x < 0 || src_y < 0 || src_x + 9 >= plane_width || src_y + 9 >= plane_height ) { uint8_t * temp = s -> edge_emu_buffer ; if ( stride < 0 ) temp -= 8 * stride ; s -> vdsp . emulated_edge_mc ( temp , motion_source , stride , 9 , 9 , src_x , src_y , plane_width , plane_height ) ; motion_source = temp ; } } if ( s -> all_fragments [ i ] . coding_method != MODE_INTRA ) { if ( motion_halfpel_index != 3 ) { s -> dsp . put_no_rnd_pixels_tab [ 1 ] [ motion_halfpel_index ] ( output_plane + first_pixel , motion_source , stride , 8 ) ; } else { int d = ( motion_x ^ motion_y ) >> 31 ; s -> vp3dsp . put_no_rnd_pixels_l2 ( output_plane + first_pixel , motion_source - d , motion_source + stride + 1 + d , stride , 8 ) ; } } if ( s -> all_fragments [ i ] . coding_method == MODE_INTRA ) { int index ; index = vp3_dequant ( s , s -> all_fragments + i , plane , 0 , block ) ; if ( index > 63 ) continue ; s -> vp3dsp . idct_put ( output_plane + first_pixel , stride , block ) ; } else { int index = vp3_dequant ( s , s -> all_fragments + i , plane , 1 , block ) ; if ( index > 63 ) continue ; if ( index > 0 ) { s -> vp3dsp . idct_add ( output_plane + first_pixel , stride , block ) ; } else { s -> vp3dsp . idct_dc_add ( output_plane + first_pixel , stride , block ) ; } } } else { s -> dsp . put_pixels_tab [ 1 ] [ 0 ] ( output_plane + first_pixel , last_plane + first_pixel , stride , 8 ) ; } } } if ( ! s -> skip_loop_filter ) apply_loop_filter ( s , plane , 4 * sb_y - ! ! sb_y , FFMIN ( 4 * sb_y + 3 , fragment_height - 1 ) ) ; } } vp3_draw_horiz_band ( s , FFMIN ( ( 32 << s -> chroma_y_shift ) * ( slice + 1 ) - 16 , s -> height - 16 ) ) ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static int mp_decode_layer3 ( MPADecodeContext * s ) { int nb_granules , main_data_begin ; int gr , ch , blocksplit_flag , i , j , k , n , bits_pos ; GranuleDef * g ; int16_t exponents [ 576 ] ; if ( s -> lsf ) { main_data_begin = get_bits ( & s -> gb , 8 ) ; skip_bits ( & s -> gb , s -> nb_channels ) ; nb_granules = 1 ; } else { main_data_begin = get_bits ( & s -> gb , 9 ) ; if ( s -> nb_channels == 2 ) skip_bits ( & s -> gb , 3 ) ; else skip_bits ( & s -> gb , 5 ) ; nb_granules = 2 ; for ( ch = 0 ; ch < s -> nb_channels ; ch ++ ) { s -> granules [ ch ] [ 0 ] . scfsi = 0 ; s -> granules [ ch ] [ 1 ] . scfsi = get_bits ( & s -> gb , 4 ) ; } } for ( gr = 0 ; gr < nb_granules ; gr ++ ) { for ( ch = 0 ; ch < s -> nb_channels ; ch ++ ) { av_dlog ( s -> avctx , "gr=%d ch=%d: side_info\n" , gr , ch ) ; g = & s -> granules [ ch ] [ gr ] ; g -> part2_3_length = get_bits ( & s -> gb , 12 ) ; g -> big_values = get_bits ( & s -> gb , 9 ) ; if ( g -> big_values > 288 ) { av_log ( s -> avctx , AV_LOG_ERROR , "big_values too big\n" ) ; return AVERROR_INVALIDDATA ; } g -> global_gain = get_bits ( & s -> gb , 8 ) ; if ( ( s -> mode_ext & ( MODE_EXT_MS_STEREO | MODE_EXT_I_STEREO ) ) == MODE_EXT_MS_STEREO ) g -> global_gain -= 2 ; if ( s -> lsf ) g -> scalefac_compress = get_bits ( & s -> gb , 9 ) ; else g -> scalefac_compress = get_bits ( & s -> gb , 4 ) ; blocksplit_flag = get_bits1 ( & s -> gb ) ; if ( blocksplit_flag ) { g -> block_type = get_bits ( & s -> gb , 2 ) ; if ( g -> block_type == 0 ) { av_log ( s -> avctx , AV_LOG_ERROR , "invalid block type\n" ) ; return AVERROR_INVALIDDATA ; } g -> switch_point = get_bits1 ( & s -> gb ) ; for ( i = 0 ; i < 2 ; i ++ ) g -> table_select [ i ] = get_bits ( & s -> gb , 5 ) ; for ( i = 0 ; i < 3 ; i ++ ) g -> subblock_gain [ i ] = get_bits ( & s -> gb , 3 ) ; ff_init_short_region ( s , g ) ; } else { int region_address1 , region_address2 ; g -> block_type = 0 ; g -> switch_point = 0 ; for ( i = 0 ; i < 3 ; i ++ ) g -> table_select [ i ] = get_bits ( & s -> gb , 5 ) ; region_address1 = get_bits ( & s -> gb , 4 ) ; region_address2 = get_bits ( & s -> gb , 3 ) ; av_dlog ( s -> avctx , "region1=%d region2=%d\n" , region_address1 , region_address2 ) ; ff_init_long_region ( s , g , region_address1 , region_address2 ) ; } ff_region_offset2size ( g ) ; ff_compute_band_indexes ( s , g ) ; g -> preflag = 0 ; if ( ! s -> lsf ) g -> preflag = get_bits1 ( & s -> gb ) ; g -> scalefac_scale = get_bits1 ( & s -> gb ) ; g -> count1table_select = get_bits1 ( & s -> gb ) ; av_dlog ( s -> avctx , "block_type=%d switch_point=%d\n" , g -> block_type , g -> switch_point ) ; } } if ( ! s -> adu_mode ) { int skip ; const uint8_t * ptr = s -> gb . buffer + ( get_bits_count ( & s -> gb ) >> 3 ) ; int extrasize = av_clip ( get_bits_left ( & s -> gb ) >> 3 , 0 , FFMAX ( 0 , LAST_BUF_SIZE - s -> last_buf_size ) ) ; assert ( ( get_bits_count ( & s -> gb ) & 7 ) == 0 ) ; av_dlog ( s -> avctx , "seekback:%d, lastbuf:%d\n" , main_data_begin , s -> last_buf_size ) ; memcpy ( s -> last_buf + s -> last_buf_size , ptr , extrasize ) ; s -> in_gb = s -> gb ; init_get_bits ( & s -> gb , s -> last_buf , s -> last_buf_size * 8 ) ; # if ! UNCHECKED_BITSTREAM_READER s -> gb . size_in_bits_plus8 += extrasize * 8 ; # endif s -> last_buf_size <<= 3 ; for ( gr = 0 ; gr < nb_granules && ( s -> last_buf_size >> 3 ) < main_data_begin ; gr ++ ) { for ( ch = 0 ; ch < s -> nb_channels ; ch ++ ) { g = & s -> granules [ ch ] [ gr ] ; s -> last_buf_size += g -> part2_3_length ; memset ( g -> sb_hybrid , 0 , sizeof ( g -> sb_hybrid ) ) ; compute_imdct ( s , g , & s -> sb_samples [ ch ] [ 18 * gr ] [ 0 ] , s -> mdct_buf [ ch ] ) ; } } skip = s -> last_buf_size - 8 * main_data_begin ; if ( skip >= s -> gb . size_in_bits && s -> in_gb . buffer ) { skip_bits_long ( & s -> in_gb , skip - s -> gb . size_in_bits ) ; s -> gb = s -> in_gb ; s -> in_gb . buffer = NULL ; } else { skip_bits_long ( & s -> gb , skip ) ; } } else { gr = 0 ; } for ( ; gr < nb_granules ; gr ++ ) { for ( ch = 0 ; ch < s -> nb_channels ; ch ++ ) { g = & s -> granules [ ch ] [ gr ] ; bits_pos = get_bits_count ( & s -> gb ) ; if ( ! s -> lsf ) { uint8_t * sc ; int slen , slen1 , slen2 ; slen1 = slen_table [ 0 ] [ g -> scalefac_compress ] ; slen2 = slen_table [ 1 ] [ g -> scalefac_compress ] ; av_dlog ( s -> avctx , "slen1=%d slen2=%d\n" , slen1 , slen2 ) ; if ( g -> block_type == 2 ) { n = g -> switch_point ? 17 : 18 ; j = 0 ; if ( slen1 ) { for ( i = 0 ; i < n ; i ++ ) g -> scale_factors [ j ++ ] = get_bits ( & s -> gb , slen1 ) ; } else { for ( i = 0 ; i < n ; i ++ ) g -> scale_factors [ j ++ ] = 0 ; } if ( slen2 ) { for ( i = 0 ; i < 18 ; i ++ ) g -> scale_factors [ j ++ ] = get_bits ( & s -> gb , slen2 ) ; for ( i = 0 ; i < 3 ; i ++ ) g -> scale_factors [ j ++ ] = 0 ; } else { for ( i = 0 ; i < 21 ; i ++ ) g -> scale_factors [ j ++ ] = 0 ; } } else { sc = s -> granules [ ch ] [ 0 ] . scale_factors ; j = 0 ; for ( k = 0 ; k < 4 ; k ++ ) { n = k == 0 ? 6 : 5 ; if ( ( g -> scfsi & ( 0x8 >> k ) ) == 0 ) { slen = ( k < 2 ) ? slen1 : slen2 ; if ( slen ) { for ( i = 0 ; i < n ; i ++ ) g -> scale_factors [ j ++ ] = get_bits ( & s -> gb , slen ) ; } else { for ( i = 0 ; i < n ; i ++ ) g -> scale_factors [ j ++ ] = 0 ; } } else { for ( i = 0 ; i < n ; i ++ ) { g -> scale_factors [ j ] = sc [ j ] ; j ++ ; } } } g -> scale_factors [ j ++ ] = 0 ; } } else { int tindex , tindex2 , slen [ 4 ] , sl , sf ; if ( g -> block_type == 2 ) tindex = g -> switch_point ? 2 : 1 ; else tindex = 0 ; sf = g -> scalefac_compress ; if ( ( s -> mode_ext & MODE_EXT_I_STEREO ) && ch == 1 ) { sf >>= 1 ; if ( sf < 180 ) { lsf_sf_expand ( slen , sf , 6 , 6 , 0 ) ; tindex2 = 3 ; } else if ( sf < 244 ) { lsf_sf_expand ( slen , sf - 180 , 4 , 4 , 0 ) ; tindex2 = 4 ; } else { lsf_sf_expand ( slen , sf - 244 , 3 , 0 , 0 ) ; tindex2 = 5 ; } } else { if ( sf < 400 ) { lsf_sf_expand ( slen , sf , 5 , 4 , 4 ) ; tindex2 = 0 ; } else if ( sf < 500 ) { lsf_sf_expand ( slen , sf - 400 , 5 , 4 , 0 ) ; tindex2 = 1 ; } else { lsf_sf_expand ( slen , sf - 500 , 3 , 0 , 0 ) ; tindex2 = 2 ; g -> preflag = 1 ; } } j = 0 ; for ( k = 0 ; k < 4 ; k ++ ) { n = lsf_nsf_table [ tindex2 ] [ tindex ] [ k ] ; sl = slen [ k ] ; if ( sl ) { for ( i = 0 ; i < n ; i ++ ) g -> scale_factors [ j ++ ] = get_bits ( & s -> gb , sl ) ; } else { for ( i = 0 ; i < n ; i ++ ) g -> scale_factors [ j ++ ] = 0 ; } } for ( ; j < 40 ; j ++ ) g -> scale_factors [ j ] = 0 ; } exponents_from_scale_factors ( s , g , exponents ) ; huffman_decode ( s , g , exponents , bits_pos + g -> part2_3_length ) ; } if ( s -> mode == MPA_JSTEREO ) compute_stereo ( s , & s -> granules [ 0 ] [ gr ] , & s -> granules [ 1 ] [ gr ] ) ; for ( ch = 0 ; ch < s -> nb_channels ; ch ++ ) { g = & s -> granules [ ch ] [ gr ] ; reorder_block ( s , g ) ; compute_antialias ( s , g ) ; compute_imdct ( s , g , & s -> sb_samples [ ch ] [ 18 * gr ] [ 0 ] , s -> mdct_buf [ ch ] ) ; } } if ( get_bits_count ( & s -> gb ) < 0 ) skip_bits_long ( & s -> gb , - get_bits_count ( & s -> gb ) ) ; return nb_granules * 18 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void write_mb_modes_kf ( const VP9_COMMON * cm , const MACROBLOCKD * xd , MODE_INFO * * mi_8x8 , vp9_writer * w ) { const struct segmentation * const seg = & cm -> seg ; const MODE_INFO * const mi = mi_8x8 [ 0 ] ; const MODE_INFO * const above_mi = mi_8x8 [ - xd -> mi_stride ] ; const MODE_INFO * const left_mi = xd -> left_available ? mi_8x8 [ - 1 ] : NULL ; const MB_MODE_INFO * const mbmi = & mi -> mbmi ; const BLOCK_SIZE bsize = mbmi -> sb_type ; if ( seg -> update_map ) write_segment_id ( w , seg , mbmi -> segment_id ) ; write_skip ( cm , xd , mbmi -> segment_id , mi , w ) ; if ( bsize >= BLOCK_8X8 && cm -> tx_mode == TX_MODE_SELECT ) write_selected_tx_size ( cm , xd , mbmi -> tx_size , bsize , w ) ; if ( bsize >= BLOCK_8X8 ) { write_intra_mode ( w , mbmi -> mode , get_y_mode_probs ( mi , above_mi , left_mi , 0 ) ) ; } else { const int num_4x4_w = num_4x4_blocks_wide_lookup [ bsize ] ; const int num_4x4_h = num_4x4_blocks_high_lookup [ bsize ] ; int idx , idy ; for ( idy = 0 ; idy < 2 ; idy += num_4x4_h ) { for ( idx = 0 ; idx < 2 ; idx += num_4x4_w ) { const int block = idy * 2 + idx ; write_intra_mode ( w , mi -> bmi [ block ] . as_mode , get_y_mode_probs ( mi , above_mi , left_mi , block ) ) ; } } } write_intra_mode ( w , mbmi -> uv_mode , vp9_kf_uv_mode_prob [ mbmi -> mode ] ) ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
int xmlHashAddEntry ( xmlHashTablePtr table , const xmlChar * name , void * userdata ) { return ( xmlHashAddEntry3 ( table , name , NULL , NULL , userdata ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void loopfilter_frame ( VP9_COMP * cpi , VP9_COMMON * cm ) { MACROBLOCKD * xd = & cpi -> mb . e_mbd ; struct loopfilter * lf = & cm -> lf ; if ( xd -> lossless ) { lf -> filter_level = 0 ; } else { struct vpx_usec_timer timer ; vp9_clear_system_state ( ) ; vpx_usec_timer_start ( & timer ) ; vp9_pick_filter_level ( cpi -> Source , cpi , cpi -> sf . lpf_pick ) ; vpx_usec_timer_mark ( & timer ) ; cpi -> time_pick_lpf += vpx_usec_timer_elapsed ( & timer ) ; } if ( lf -> filter_level > 0 ) { vp9_loop_filter_frame ( cm -> frame_to_show , cm , xd , lf -> filter_level , 0 , 0 ) ; } vp9_extend_frame_inner_borders ( cm -> frame_to_show ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int dissect_h245_INTEGER_1_16 ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 1U , 16U , NULL , FALSE ) ; return offset ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static void process_rtp_payload ( tvbuff_t * newtvb , packet_info * pinfo , proto_tree * tree , proto_tree * rtp_tree , unsigned int payload_type ) { struct _rtp_conversation_info * p_conv_data = NULL ; gboolean found_match = FALSE ; int payload_len ; struct srtp_info * srtp_info ; int offset = 0 ; payload_len = tvb_length_remaining ( newtvb , offset ) ; p_conv_data = ( struct _rtp_conversation_info * ) p_get_proto_data ( wmem_file_scope ( ) , pinfo , proto_rtp , 0 ) ; if ( p_conv_data && p_conv_data -> srtp_info ) { srtp_info = p_conv_data -> srtp_info ; payload_len -= srtp_info -> mki_len + srtp_info -> auth_tag_len ; # if 0 # error Currently the srtp_info structure contains no cipher data , see packet - sdp . c adding dummy_srtp_info structure if ( p_conv_data -> srtp_info -> encryption_algorithm == SRTP_ENC_ALG_NULL ) { if ( rtp_tree ) proto_tree_add_text ( rtp_tree , newtvb , offset , payload_len , "SRTP Payload with NULL encryption" ) ; } else # endif { if ( rtp_tree ) proto_tree_add_item ( rtp_tree , hf_srtp_encrypted_payload , newtvb , offset , payload_len , ENC_NA ) ; found_match = TRUE ; } offset += payload_len ; if ( srtp_info -> mki_len ) { proto_tree_add_item ( rtp_tree , hf_srtp_mki , newtvb , offset , srtp_info -> mki_len , ENC_NA ) ; offset += srtp_info -> mki_len ; } if ( srtp_info -> auth_tag_len ) { proto_tree_add_item ( rtp_tree , hf_srtp_auth_tag , newtvb , offset , srtp_info -> auth_tag_len , ENC_NA ) ; } } else if ( p_conv_data && ! p_conv_data -> bta2dp_info && ! p_conv_data -> btvdp_info && payload_type >= PT_UNDF_96 && payload_type <= PT_UNDF_127 ) { if ( p_conv_data && p_conv_data -> rtp_dyn_payload ) { gchar * payload_type_str = NULL ; encoding_name_and_rate_t * encoding_name_and_rate_pt = NULL ; encoding_name_and_rate_pt = ( encoding_name_and_rate_t * ) g_hash_table_lookup ( p_conv_data -> rtp_dyn_payload , & payload_type ) ; if ( encoding_name_and_rate_pt ) { payload_type_str = encoding_name_and_rate_pt -> encoding_name ; } if ( payload_type_str ) { found_match = dissector_try_string ( rtp_dyn_pt_dissector_table , payload_type_str , newtvb , pinfo , tree , NULL ) ; if ( found_match == FALSE ) proto_tree_add_item ( rtp_tree , hf_rtp_data , newtvb , 0 , - 1 , ENC_NA ) ; return ; } } } else if ( p_conv_data && p_conv_data -> bta2dp_info ) { tvbuff_t * nexttvb ; gint suboffset = 0 ; found_match = TRUE ; if ( p_conv_data -> bta2dp_info -> content_protection_type == BTAVDTP_CONTENT_PROTECTION_TYPE_SCMS_T ) { nexttvb = tvb_new_subset ( newtvb , 0 , 1 , 1 ) ; call_dissector ( bta2dp_content_protection_header_scms_t , nexttvb , pinfo , tree ) ; suboffset = 1 ; } nexttvb = tvb_new_subset_remaining ( newtvb , suboffset ) ; if ( p_conv_data -> bta2dp_info -> codec_dissector ) call_dissector ( p_conv_data -> bta2dp_info -> codec_dissector , nexttvb , pinfo , tree ) ; else call_dissector ( data_handle , nexttvb , pinfo , tree ) ; } else if ( p_conv_data && p_conv_data -> btvdp_info ) { tvbuff_t * nexttvb ; gint suboffset = 0 ; found_match = TRUE ; if ( p_conv_data -> btvdp_info -> content_protection_type == BTAVDTP_CONTENT_PROTECTION_TYPE_SCMS_T ) { nexttvb = tvb_new_subset ( newtvb , 0 , 1 , 1 ) ; call_dissector ( bta2dp_content_protection_header_scms_t , nexttvb , pinfo , tree ) ; suboffset = 1 ; } nexttvb = tvb_new_subset_remaining ( newtvb , suboffset ) ; if ( p_conv_data -> btvdp_info -> codec_dissector ) call_dissector ( p_conv_data -> btvdp_info -> codec_dissector , nexttvb , pinfo , tree ) ; else call_dissector ( data_handle , nexttvb , pinfo , tree ) ; } if ( ! found_match && ! dissector_try_uint ( rtp_pt_dissector_table , payload_type , newtvb , pinfo , tree ) ) proto_tree_add_item ( rtp_tree , hf_rtp_data , newtvb , 0 , - 1 , ENC_NA ) ; }
1True
Categorize the following code snippet as vulnerable or not. True or False
static cmsBool WriteOffsetArray ( cmsIOHANDLER * io , _cmsDICarray * a , cmsUInt32Number Count , cmsUInt32Number Length ) { cmsUInt32Number i ; for ( i = 0 ; i < Count ; i ++ ) { if ( ! WriteOneElem ( io , & a -> Name , i ) ) return FALSE ; if ( ! WriteOneElem ( io , & a -> Value , i ) ) return FALSE ; if ( Length > 16 ) { if ( ! WriteOneElem ( io , & a -> DisplayName , i ) ) return FALSE ; } if ( Length > 24 ) { if ( ! WriteOneElem ( io , & a -> DisplayValue , i ) ) return FALSE ; } } return TRUE ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
TSReturnCode TSMimeHdrFieldClone ( TSMBuffer dest_bufp , TSMLoc dest_hdr , TSMBuffer src_bufp , TSMLoc src_hdr , TSMLoc src_field , TSMLoc * locp ) { sdk_assert ( sdk_sanity_check_mbuffer ( dest_bufp ) == TS_SUCCESS ) ; sdk_assert ( sdk_sanity_check_mbuffer ( src_bufp ) == TS_SUCCESS ) ; sdk_assert ( ( sdk_sanity_check_mime_hdr_handle ( dest_hdr ) == TS_SUCCESS ) || ( sdk_sanity_check_http_hdr_handle ( dest_hdr ) == TS_SUCCESS ) ) ; sdk_assert ( ( sdk_sanity_check_mime_hdr_handle ( src_hdr ) == TS_SUCCESS ) || ( sdk_sanity_check_http_hdr_handle ( src_hdr ) == TS_SUCCESS ) ) ; sdk_assert ( sdk_sanity_check_field_handle ( src_field , src_hdr ) == TS_SUCCESS ) ; sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) locp ) == TS_SUCCESS ) ; if ( ! isWriteable ( dest_bufp ) ) { return TS_ERROR ; } if ( TSMimeHdrFieldCreate ( dest_bufp , dest_hdr , locp ) == TS_SUCCESS ) { TSMimeHdrFieldCopy ( dest_bufp , dest_hdr , * locp , src_bufp , src_hdr , src_field ) ; return TS_SUCCESS ; } return TS_ERROR ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int validate_raw_date ( const char * src , struct strbuf * result ) { const char * orig_src = src ; char * endp ; unsigned long num ; errno = 0 ; num = strtoul ( src , & endp , 10 ) ; if ( errno || endp == src || * endp != ' ' ) return - 1 ; src = endp + 1 ; if ( * src != '-' && * src != '+' ) return - 1 ; num = strtoul ( src + 1 , & endp , 10 ) ; if ( errno || endp == src + 1 || * endp || 1400 < num ) return - 1 ; strbuf_addstr ( result , orig_src ) ; return 0 ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int next_code ( struct archive_read_filter * self ) { struct private_data * state = ( struct private_data * ) self -> data ; int code , newcode ; static int debug_buff [ 1024 ] ; static unsigned debug_index ; code = newcode = getbits ( self , state -> bits ) ; if ( code < 0 ) return ( code ) ; debug_buff [ debug_index ++ ] = code ; if ( debug_index >= sizeof ( debug_buff ) / sizeof ( debug_buff [ 0 ] ) ) debug_index = 0 ; if ( ( code == 256 ) && state -> use_reset_code ) { int skip_bytes = state -> bits - ( state -> bytes_in_section % state -> bits ) ; skip_bytes %= state -> bits ; state -> bits_avail = 0 ; while ( skip_bytes -- > 0 ) { code = getbits ( self , 8 ) ; if ( code < 0 ) return ( code ) ; } state -> bytes_in_section = 0 ; state -> bits = 9 ; state -> section_end_code = ( 1 << state -> bits ) - 1 ; state -> free_ent = 257 ; state -> oldcode = - 1 ; return ( next_code ( self ) ) ; } if ( code > state -> free_ent || ( code == state -> free_ent && state -> oldcode < 0 ) ) { archive_set_error ( & ( self -> archive -> archive ) , - 1 , "Invalid compressed data" ) ; return ( ARCHIVE_FATAL ) ; } if ( code >= state -> free_ent ) { * state -> stackp ++ = state -> finbyte ; code = state -> oldcode ; } while ( code >= 256 ) { * state -> stackp ++ = state -> suffix [ code ] ; code = state -> prefix [ code ] ; } * state -> stackp ++ = state -> finbyte = code ; code = state -> free_ent ; if ( code < state -> maxcode && state -> oldcode >= 0 ) { state -> prefix [ code ] = state -> oldcode ; state -> suffix [ code ] = state -> finbyte ; ++ state -> free_ent ; } if ( state -> free_ent > state -> section_end_code ) { state -> bits ++ ; state -> bytes_in_section = 0 ; if ( state -> bits == state -> maxcode_bits ) state -> section_end_code = state -> maxcode ; else state -> section_end_code = ( 1 << state -> bits ) - 1 ; } state -> oldcode = newcode ; return ( ARCHIVE_OK ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static int sort_key_read ( MI_SORT_PARAM * sort_param , void * key ) { int error ; SORT_INFO * sort_info = sort_param -> sort_info ; MI_INFO * info = sort_info -> info ; DBUG_ENTER ( "sort_key_read" ) ; if ( ( error = sort_get_next_record ( sort_param ) ) ) DBUG_RETURN ( error ) ; if ( info -> state -> records == sort_info -> max_records ) { mi_check_print_error ( sort_info -> param , "Key %d - Found too many records; Can't continue" , sort_param -> key + 1 ) ; DBUG_RETURN ( 1 ) ; } sort_param -> real_key_length = ( info -> s -> rec_reflength + _mi_make_key ( info , sort_param -> key , ( uchar * ) key , sort_param -> record , sort_param -> filepos ) ) ; # ifdef HAVE_purify bzero ( key + sort_param -> real_key_length , ( sort_param -> key_length - sort_param -> real_key_length ) ) ; # endif DBUG_RETURN ( sort_write_record ( sort_param ) ) ; }
0False
Categorize the following code snippet as vulnerable or not. True or False
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_reserve ( sk_ ## t1 ## _compfunc compare , int n ) { return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_reserve ( ( OPENSSL_sk_compfunc ) compare , n ) ; } static ossl_inline int sk_ ## t1 ## _reserve ( STACK_OF ( t1 ) * sk , int n ) { return OPENSSL_sk_reserve ( ( OPENSSL_STACK * ) sk , n ) ; } static ossl_inline void sk_ ## t1 ## _free ( STACK_OF ( t1 ) * sk ) { OPENSSL_sk_free ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline void sk_ ## t1 ## _zero ( STACK_OF ( t1 ) * sk ) { OPENSSL_sk_zero ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline t2 * sk_ ## t1 ## _delete ( STACK_OF ( t1 ) * sk , int i ) { return ( t2 * ) OPENSSL_sk_delete ( ( OPENSSL_STACK * ) sk , i ) ; } static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) { return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) { return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) { OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ; } static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) { return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ; } static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) { return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ; } static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) { OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) { return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ; } static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) { return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ; } static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) { return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ; } static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) { return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ; } # define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ; typedef const char * OPENSSL_CSTRING ; DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char ) typedef void * OPENSSL_BLOCK ; DEFINE_SPECIAL_STACK_OF ( OPENSSL_BLOCK , void )
0False
Categorize the following code snippet as vulnerable or not. True or False
static gboolean should_skip_readdir_error ( CommonJob * common , GFile * dir ) { if ( common -> skip_readdir_error != NULL ) { return g_hash_table_lookup ( common -> skip_readdir_error , dir ) != NULL ; } return FALSE ; }
0False
README.md exists but content is empty. Use the Edit dataset card button to edit it.
Downloads last month
37
Edit dataset card