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 gboolean logcat_read_packet ( struct logcat_phdr * logcat , FILE_T fh , struct wtap_pkthdr * phdr , Buffer * buf , int * err , gchar * * err_info ) {
gint bytes_read ;
gint packet_size ;
guint16 payload_length ;
guint tmp [ 2 ] ;
guint8 * pd ;
struct logger_entry * log_entry ;
bytes_read = file_read ( & tmp , 2 , fh ) ;
if ( bytes_read != 2 ) {
* err = file_error ( fh , err_info ) ;
if ( * err == 0 && bytes_read != 0 ) * err = WTAP_ERR_SHORT_READ ;
return FALSE ;
}
payload_length = pletoh16 ( tmp ) ;
if ( logcat -> version == 1 ) {
packet_size = sizeof ( struct logger_entry ) + payload_length ;
}
else if ( logcat -> version == 2 ) {
packet_size = sizeof ( struct logger_entry_v2 ) + payload_length ;
}
else {
return FALSE ;
}
buffer_assure_space ( buf , packet_size ) ;
pd = buffer_start_ptr ( buf ) ;
log_entry = ( struct logger_entry * ) pd ;
memcpy ( pd , tmp , 2 ) ;
bytes_read = file_read ( pd + 2 , packet_size - 2 , fh ) ;
if ( bytes_read != packet_size - 2 ) {
* err = file_error ( fh , err_info ) ;
if ( * err == 0 ) * err = WTAP_ERR_SHORT_READ ;
return FALSE ;
}
phdr -> rec_type = REC_TYPE_PACKET ;
phdr -> presence_flags = WTAP_HAS_TS ;
phdr -> ts . secs = ( time_t ) GINT32_FROM_LE ( log_entry -> sec ) ;
phdr -> ts . nsecs = GINT32_FROM_LE ( log_entry -> nsec ) ;
phdr -> caplen = packet_size ;
phdr -> len = packet_size ;
phdr -> pseudo_header . logcat . version = logcat -> version ;
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static zval * row_dim_read ( zval * object , zval * member , int type TSRMLS_DC ) {
return row_prop_read ( object , member , type , NULL TSRMLS_CC ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ipvideo_decode_block_opcode_0x1 ( IpvideoContext * s , AVFrame * frame ) {
return copy_from ( s , s -> second_last_frame , frame , 0 , 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_pick_filter_level ( const YV12_BUFFER_CONFIG * sd , VP9_COMP * cpi , LPF_PICK_METHOD method ) {
VP9_COMMON * const cm = & cpi -> common ;
struct loopfilter * const lf = & cm -> lf ;
lf -> sharpness_level = cm -> frame_type == KEY_FRAME ? 0 : cpi -> oxcf . sharpness ;
if ( method == LPF_PICK_MINIMAL_LPF && lf -> filter_level ) {
lf -> filter_level = 0 ;
}
else if ( method >= LPF_PICK_FROM_Q ) {
const int min_filter_level = 0 ;
const int max_filter_level = get_max_filter_level ( cpi ) ;
const int q = vp9_ac_quant ( cm -> base_qindex , 0 , cm -> bit_depth ) ;
int filt_guess = ROUND_POWER_OF_TWO ( q * 20723 + 1015158 , 18 ) ;
if ( cm -> frame_type == KEY_FRAME ) filt_guess -= 4 ;
lf -> filter_level = clamp ( filt_guess , min_filter_level , max_filter_level ) ;
}
else {
lf -> filter_level = search_filter_level ( sd , cpi , method == LPF_PICK_FROM_SUBIMAGE ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void notef ( struct GlobalConfig * config , const char * fmt , ... ) {
va_list ap ;
va_start ( ap , fmt ) ;
if ( config -> tracetype ) voutf ( config , NOTE_PREFIX , fmt , ap ) ;
va_end ( ap ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Pattern_Prefix_Status regex_fixed_prefix ( Const * patt_const , bool case_insensitive , Oid collation , Const * * prefix_const , Selectivity * rest_selec ) {
Oid typeid = patt_const -> consttype ;
char * prefix ;
bool exact ;
if ( typeid == BYTEAOID ) ereport ( ERROR , ( errcode ( ERRCODE_FEATURE_NOT_SUPPORTED ) , errmsg ( "regular-expression matching not supported on type bytea" ) ) ) ;
prefix = regexp_fixed_prefix ( DatumGetTextPP ( patt_const -> constvalue ) , case_insensitive , collation , & exact ) ;
if ( prefix == NULL ) {
* prefix_const = NULL ;
if ( rest_selec != NULL ) {
char * patt = TextDatumGetCString ( patt_const -> constvalue ) ;
* rest_selec = regex_selectivity ( patt , strlen ( patt ) , case_insensitive , 0 ) ;
pfree ( patt ) ;
}
return Pattern_Prefix_None ;
}
* prefix_const = string_to_const ( prefix , typeid ) ;
if ( rest_selec != NULL ) {
if ( exact ) {
* rest_selec = 1.0 ;
}
else {
char * patt = TextDatumGetCString ( patt_const -> constvalue ) ;
* rest_selec = regex_selectivity ( patt , strlen ( patt ) , case_insensitive , strlen ( prefix ) ) ;
pfree ( patt ) ;
}
}
pfree ( prefix ) ;
if ( exact ) return Pattern_Prefix_Exact ;
else return Pattern_Prefix_Partial ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_list_fields ( ) {
MYSQL_RES * result ;
int rc ;
myheader ( "test_list_fields" ) ;
rc = mysql_query ( mysql , "drop table if exists t1" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create table t1(c1 int primary key auto_increment, c2 char(10) default 'mysql')" ) ;
myquery ( rc ) ;
result = mysql_list_fields ( mysql , "t1" , NULL ) ;
mytest ( result ) ;
rc = my_process_result_set ( result ) ;
DIE_UNLESS ( rc == 0 ) ;
verify_prepare_field ( result , 0 , "c1" , "c1" , MYSQL_TYPE_LONG , "t1" , "t1" , current_db , 11 , "0" ) ;
verify_prepare_field ( result , 1 , "c2" , "c2" , MYSQL_TYPE_STRING , "t1" , "t1" , current_db , 10 , "mysql" ) ;
mysql_free_result ( result ) ;
myquery ( mysql_query ( mysql , "drop table t1" ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
file_transfer_t * imcb_file_send_start ( struct im_connection * ic , char * handle , char * file_name , size_t file_size ) {
bee_t * bee = ic -> bee ;
bee_user_t * bu = bee_user_by_handle ( bee , ic , handle ) ;
if ( bee -> ui -> ft_in_start && bu ) {
return bee -> ui -> ft_in_start ( bee , bu , file_name , file_size ) ;
}
else {
return NULL ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ContentFaviconDriverTest , AssociateIconWithInitialPageIconDespiteReplaceState ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
GURL url = embedded_test_server ( ) -> GetURL ( "/favicon/replacestate_with_favicon.html" ) ;
GURL replacestate_url = embedded_test_server ( ) -> GetURL ( "/favicon/replacestate_with_favicon_replaced.html" ) ;
PendingTaskWaiter waiter ( web_contents ( ) ) ;
waiter . AlsoRequireUrl ( replacestate_url ) ;
ui_test_utils : : NavigateToURLWithDisposition ( browser ( ) , url , WindowOpenDisposition : : CURRENT_TAB , ui_test_utils : : BROWSER_TEST_NONE ) ;
waiter . Wait ( ) ;
EXPECT_NE ( nullptr , GetFaviconForPageURL ( url , favicon_base : : IconType : : kFavicon ) . bitmap_data ) ;
EXPECT_NE ( nullptr , GetFaviconForPageURL ( replacestate_url , favicon_base : : IconType : : kFavicon ) . bitmap_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void decorrelate_stereo ( int32_t * buffer [ 2 ] , int nb_samples , int decorr_shift , int decorr_left_weight ) {
int i ;
for ( i = 0 ;
i < nb_samples ;
i ++ ) {
int32_t a , b ;
a = buffer [ 0 ] [ i ] ;
b = buffer [ 1 ] [ i ] ;
a -= ( b * decorr_left_weight ) >> decorr_shift ;
b += a ;
buffer [ 0 ] [ i ] = b ;
buffer [ 1 ] [ i ] = a ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int jpc_pchglist_numpchgs ( jpc_pchglist_t * pchglist ) {
return pchglist -> numpchgs ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int reassemble_octet_string ( asn1_ctx_t * actx , proto_tree * tree , gint hf_id , tvbuff_t * tvb , int offset , guint32 con_len , gboolean ind , tvbuff_t * * out_tvb ) {
fragment_head * fd_head = NULL ;
tvbuff_t * next_tvb = NULL ;
tvbuff_t * reassembled_tvb = NULL ;
guint16 dst_ref = 0 ;
int start_offset = offset ;
gboolean fragment = TRUE ;
gboolean firstFragment = TRUE ;
if ( out_tvb ) * out_tvb = NULL ;
if ( con_len == 0 ) return offset ;
actx -> pinfo -> fragmented = TRUE ;
while ( ! fd_head ) {
offset = dissect_ber_octet_string ( FALSE , actx , NULL , tvb , offset , hf_id , & next_tvb ) ;
if ( next_tvb == NULL ) {
THROW ( ReportedBoundsError ) ;
}
if ( ind ) {
if ( ( tvb_get_guint8 ( tvb , offset ) == 0 ) && ( tvb_get_guint8 ( tvb , offset + 1 ) == 0 ) ) {
fragment = FALSE ;
offset += 2 ;
}
}
else {
if ( ( guint32 ) ( offset - start_offset ) >= con_len ) fragment = FALSE ;
}
if ( ! fragment && firstFragment ) {
gboolean pc ;
get_ber_identifier ( tvb , start_offset , NULL , & pc , NULL ) ;
if ( ! pc && tree ) {
dissect_ber_octet_string ( FALSE , actx , tree , tvb , start_offset , hf_id , NULL ) ;
}
reassembled_tvb = next_tvb ;
break ;
}
if ( tvb_reported_length ( next_tvb ) < 1 ) {
THROW ( ReportedBoundsError ) ;
}
fd_head = fragment_add_seq_next ( & octet_segment_reassembly_table , next_tvb , 0 , actx -> pinfo , dst_ref , NULL , tvb_reported_length ( next_tvb ) , fragment ) ;
firstFragment = FALSE ;
}
if ( fd_head ) {
if ( fd_head -> next ) {
proto_tree * next_tree ;
proto_item * frag_tree_item ;
reassembled_tvb = tvb_new_chain ( next_tvb , fd_head -> tvb_data ) ;
actx -> created_item = proto_tree_add_item ( tree , hf_id , reassembled_tvb , 0 , - 1 , ENC_BIG_ENDIAN ) ;
next_tree = proto_item_add_subtree ( actx -> created_item , ett_ber_reassembled_octet_string ) ;
add_new_data_source ( actx -> pinfo , reassembled_tvb , "Reassembled OCTET STRING" ) ;
show_fragment_seq_tree ( fd_head , & octet_string_frag_items , next_tree , actx -> pinfo , reassembled_tvb , & frag_tree_item ) ;
}
}
if ( out_tvb ) * out_tvb = reassembled_tvb ;
actx -> pinfo -> fragmented = FALSE ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
unsigned int vp9_sub_pixel_avg_variance ## W ## x ## H ## _c ( const uint8_t * src , int src_stride , int xoffset , int yoffset , const uint8_t * dst , int dst_stride , unsigned int * sse , const uint8_t * second_pred ) {
uint16_t fdata3 [ ( H + 1 ) * W ] ;
uint8_t temp2 [ H * W ] ;
DECLARE_ALIGNED_ARRAY ( 16 , uint8_t , temp3 , H * W ) ;
var_filter_block2d_bil_first_pass ( src , fdata3 , src_stride , 1 , H + 1 , W , BILINEAR_FILTERS_2TAP ( xoffset ) ) ;
var_filter_block2d_bil_second_pass ( fdata3 , temp2 , W , W , H , W , BILINEAR_FILTERS_2TAP ( yoffset ) ) ;
vp9_comp_avg_pred ( temp3 , second_pred , W , H , temp2 , W ) ;
return vp9_variance ## W ## x ## H ## _c ( temp3 , W , dst , dst_stride , sse ) ;
\ }
void vp9_get16x16var_c ( const uint8_t * src_ptr , int source_stride , const uint8_t * ref_ptr , int ref_stride , unsigned int * sse , int * sum ) {
variance ( src_ptr , source_stride , ref_ptr , ref_stride , 16 , 16 , sse , sum ) ;
}
void vp9_get8x8var_c ( const uint8_t * src_ptr , int source_stride , const uint8_t * ref_ptr , int ref_stride , unsigned int * sse , int * sum ) {
variance ( src_ptr , source_stride , ref_ptr , ref_stride , 8 , 8 , sse , sum ) ;
}
unsigned int vp9_mse16x16_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 16 , 16 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse16x8_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 16 , 8 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse8x16_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 8 , 16 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse8x8_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 8 , 8 , sse , & sum ) ;
return * sse ;
}
VAR ( 4 , 4 ) SUBPIX_VAR ( 4 , 4 ) SUBPIX_AVG_VAR ( 4 , 4 ) VAR ( 4 , 8 ) SUBPIX_VAR ( 4 , 8 ) SUBPIX_AVG_VAR ( 4 , 8 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void http_hdr_describe ( HdrHeapObjImpl * raw , bool recurse ) {
HTTPHdrImpl * obj = ( HTTPHdrImpl * ) raw ;
if ( obj -> m_polarity == HTTP_TYPE_REQUEST ) {
Debug ( "http" , "[TYPE: REQ, V: %04X, URL: %p, METHOD: \"%.*s\", METHOD_LEN: %d, FIELDS: %p]" , obj -> m_version , obj -> u . req . m_url_impl , obj -> u . req . m_len_method , ( obj -> u . req . m_ptr_method ? obj -> u . req . m_ptr_method : "NULL" ) , obj -> u . req . m_len_method , obj -> m_fields_impl ) ;
if ( recurse ) {
if ( obj -> u . req . m_url_impl ) {
obj_describe ( obj -> u . req . m_url_impl , recurse ) ;
}
if ( obj -> m_fields_impl ) {
obj_describe ( obj -> m_fields_impl , recurse ) ;
}
}
}
else {
Debug ( "http" , "[TYPE: RSP, V: %04X, STATUS: %d, REASON: \"%.*s\", REASON_LEN: %d, FIELDS: %p]" , obj -> m_version , obj -> u . resp . m_status , obj -> u . resp . m_len_reason , ( obj -> u . resp . m_ptr_reason ? obj -> u . resp . m_ptr_reason : "NULL" ) , obj -> u . resp . m_len_reason , obj -> m_fields_impl ) ;
if ( recurse ) {
if ( obj -> m_fields_impl ) {
obj_describe ( obj -> m_fields_impl , recurse ) ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
kadm5_ret_t kadm5_delete_policy ( void * server_handle , kadm5_policy_t name ) {
kadm5_server_handle_t handle = server_handle ;
osa_policy_ent_t entry ;
int ret ;
CHECK_HANDLE ( server_handle ) ;
krb5_clear_error_message ( handle -> context ) ;
if ( name == ( kadm5_policy_t ) NULL ) return EINVAL ;
if ( strlen ( name ) == 0 ) return KADM5_BAD_POLICY ;
ret = krb5_db_get_policy ( handle -> context , name , & entry ) ;
if ( ret == KRB5_KDB_NOENTRY ) return KADM5_UNK_POLICY ;
else if ( ret ) return ret ;
if ( entry -> policy_refcnt != 0 ) {
krb5_db_free_policy ( handle -> context , entry ) ;
return KADM5_POLICY_REF ;
}
krb5_db_free_policy ( handle -> context , entry ) ;
ret = krb5_db_delete_policy ( handle -> context , name ) ;
if ( ret == KRB5_KDB_POLICY_REF ) ret = KADM5_POLICY_REF ;
return ( ret == 0 ) ? KADM5_OK : ret ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileObject , fscanf ) {
spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
spl_filesystem_file_free_line ( intern TSRMLS_CC ) ;
intern -> u . file . current_line_num ++ ;
FileFunctionCall ( fscanf , ZEND_NUM_ARGS ( ) , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_MultilinkIndication ( 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_MultilinkIndication , MultilinkIndication_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_process_BDC ( fz_context * ctx , pdf_processor * proc , pdf_csi * csi ) {
if ( proc -> op_BDC ) proc -> op_BDC ( ctx , proc , csi -> name , csi -> obj , resolve_properties ( ctx , csi , csi -> obj ) ) ;
if ( proc -> hidden > 0 ) {
++ proc -> hidden ;
return ;
}
if ( strcmp ( csi -> name , "OC" ) ) return ;
if ( pdf_is_hidden_ocg ( ctx , csi -> doc -> ocg , csi -> rdb , proc -> usage , csi -> obj ) ) ++ proc -> hidden ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void reindex_system_catalogs ( const char * dbname , const char * host , const char * port , const char * username , enum trivalue prompt_password , const char * progname , bool echo , bool verbose ) {
PGconn * conn ;
PQExpBufferData sql ;
conn = connectDatabase ( dbname , host , port , username , prompt_password , progname , false , false ) ;
initPQExpBuffer ( & sql ) ;
appendPQExpBuffer ( & sql , "REINDEX" ) ;
if ( verbose ) appendPQExpBuffer ( & sql , " (VERBOSE)" ) ;
appendPQExpBuffer ( & sql , " SYSTEM %s;
" , PQdb ( conn ) ) ;
if ( ! executeMaintenanceCommand ( conn , sql . data , echo ) ) {
fprintf ( stderr , _ ( "%s: reindexing of system catalogs failed: %s" ) , progname , PQerrorMessage ( conn ) ) ;
PQfinish ( conn ) ;
exit ( 1 ) ;
}
PQfinish ( conn ) ;
termPQExpBuffer ( & sql ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int EvaluatePS ( char * str , real * stack , int size ) {
EntityChar ec ;
RetStack rs ;
memset ( & ec , '\0' , sizeof ( ec ) ) ;
memset ( & rs , '\0' , sizeof ( rs ) ) ;
rs . max = size ;
rs . stack = stack ;
InterpretPS ( NULL , str , & ec , & rs ) ;
return ( rs . cnt ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void nautilus_self_check_file_operations ( void ) {
setlocale ( LC_MESSAGES , "C" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( " (copy)" , 1 , - 1 ) , " (another copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo" , 1 , - 1 ) , "foo (copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( ".bashrc" , 1 , - 1 ) , ".bashrc (copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( ".foo.txt" , 1 , - 1 ) , ".foo (copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo" , 1 , - 1 ) , "foo foo (copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo.txt" , 1 , - 1 ) , "foo (copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo.txt" , 1 , - 1 ) , "foo foo (copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo.txt txt" , 1 , - 1 ) , "foo foo (copy).txt txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo...txt" , 1 , - 1 ) , "foo.. (copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo..." , 1 , - 1 ) , "foo... (copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo. (copy)" , 1 , - 1 ) , "foo. (another copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (copy)" , 1 , - 1 ) , "foo (another copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (copy).txt" , 1 , - 1 ) , "foo (another copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (another copy)" , 1 , - 1 ) , "foo (3rd copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (another copy).txt" , 1 , - 1 ) , "foo (3rd copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo (another copy).txt" , 1 , - 1 ) , "foo foo (3rd copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (13th copy)" , 1 , - 1 ) , "foo (14th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (13th copy).txt" , 1 , - 1 ) , "foo (14th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (21st copy)" , 1 , - 1 ) , "foo (22nd copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (21st copy).txt" , 1 , - 1 ) , "foo (22nd copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (22nd copy)" , 1 , - 1 ) , "foo (23rd copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (22nd copy).txt" , 1 , - 1 ) , "foo (23rd copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (23rd copy)" , 1 , - 1 ) , "foo (24th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (23rd copy).txt" , 1 , - 1 ) , "foo (24th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (24th copy)" , 1 , - 1 ) , "foo (25th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (24th copy).txt" , 1 , - 1 ) , "foo (25th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo (24th copy)" , 1 , - 1 ) , "foo foo (25th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo (24th copy).txt" , 1 , - 1 ) , "foo foo (25th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo foo (100000000000000th copy).txt" , 1 , - 1 ) , "foo foo (copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (10th copy)" , 1 , - 1 ) , "foo (11th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (10th copy).txt" , 1 , - 1 ) , "foo (11th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (11th copy)" , 1 , - 1 ) , "foo (12th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (11th copy).txt" , 1 , - 1 ) , "foo (12th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (12th copy)" , 1 , - 1 ) , "foo (13th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (12th copy).txt" , 1 , - 1 ) , "foo (13th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (110th copy)" , 1 , - 1 ) , "foo (111th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (110th copy).txt" , 1 , - 1 ) , "foo (111th copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (122nd copy)" , 1 , - 1 ) , "foo (123rd copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (122nd copy).txt" , 1 , - 1 ) , "foo (123rd copy).txt" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (123rd copy)" , 1 , - 1 ) , "foo (124th copy)" ) ;
EEL_CHECK_STRING_RESULT ( get_duplicate_name ( "foo (123rd copy).txt" , 1 , - 1 ) , "foo (124th copy).txt" ) ;
setlocale ( LC_MESSAGES , "" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pnm_get ( PNMContext * sc , char * str , int buf_size ) {
char * s ;
int c ;
for ( ;
;
) {
c = * sc -> bytestream ++ ;
if ( c == '#' ) {
do {
c = * sc -> bytestream ++ ;
}
while ( c != '\n' && sc -> bytestream < sc -> bytestream_end ) ;
}
else if ( ! pnm_space ( c ) ) {
break ;
}
}
s = str ;
while ( sc -> bytestream < sc -> bytestream_end && ! pnm_space ( c ) ) {
if ( ( s - str ) < buf_size - 1 ) * s ++ = c ;
c = * sc -> bytestream ++ ;
}
* s = '\0' ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void gistcostestimate ( PlannerInfo * root , IndexPath * path , double loop_count , Cost * indexStartupCost , Cost * indexTotalCost , Selectivity * indexSelectivity , double * indexCorrelation ) {
IndexOptInfo * index = path -> indexinfo ;
List * qinfos ;
GenericCosts costs ;
Cost descentCost ;
qinfos = deconstruct_indexquals ( path ) ;
MemSet ( & costs , 0 , sizeof ( costs ) ) ;
genericcostestimate ( root , path , loop_count , qinfos , & costs ) ;
if ( index -> tree_height < 0 ) {
if ( index -> pages > 1 ) index -> tree_height = ( int ) ( log ( index -> pages ) / log ( 100.0 ) ) ;
else index -> tree_height = 0 ;
}
if ( index -> tuples > 1 ) {
descentCost = ceil ( log ( index -> tuples ) ) * cpu_operator_cost ;
costs . indexStartupCost += descentCost ;
costs . indexTotalCost += costs . num_sa_scans * descentCost ;
}
descentCost = ( index -> tree_height + 1 ) * 50.0 * cpu_operator_cost ;
costs . indexStartupCost += descentCost ;
costs . indexTotalCost += costs . num_sa_scans * descentCost ;
* indexStartupCost = costs . indexStartupCost ;
* indexTotalCost = costs . indexTotalCost ;
* indexSelectivity = costs . indexSelectivity ;
* indexCorrelation = costs . indexCorrelation ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_picture_header ( ProresContext * ctx , const uint8_t * buf , const int data_size , AVCodecContext * avctx ) {
int i , hdr_size , pic_data_size , num_slices ;
int slice_width_factor , slice_height_factor ;
int remainder , num_x_slices ;
const uint8_t * data_ptr , * index_ptr ;
hdr_size = data_size > 0 ? buf [ 0 ] >> 3 : 0 ;
if ( hdr_size < 8 || hdr_size > data_size ) {
av_log ( avctx , AV_LOG_ERROR , "picture header too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
pic_data_size = AV_RB32 ( buf + 1 ) ;
if ( pic_data_size > data_size ) {
av_log ( avctx , AV_LOG_ERROR , "picture data too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
slice_width_factor = buf [ 7 ] >> 4 ;
slice_height_factor = buf [ 7 ] & 0xF ;
if ( slice_width_factor > 3 || slice_height_factor ) {
av_log ( avctx , AV_LOG_ERROR , "unsupported slice dimension: %d x %d\n" , 1 << slice_width_factor , 1 << slice_height_factor ) ;
return AVERROR_INVALIDDATA ;
}
ctx -> slice_width_factor = slice_width_factor ;
ctx -> slice_height_factor = slice_height_factor ;
ctx -> num_x_mbs = ( avctx -> width + 15 ) >> 4 ;
ctx -> num_y_mbs = ( avctx -> height + ( 1 << ( 4 + ctx -> picture . interlaced_frame ) ) - 1 ) >> ( 4 + ctx -> picture . interlaced_frame ) ;
remainder = ctx -> num_x_mbs & ( ( 1 << slice_width_factor ) - 1 ) ;
num_x_slices = ( ctx -> num_x_mbs >> slice_width_factor ) + ( remainder & 1 ) + ( ( remainder >> 1 ) & 1 ) + ( ( remainder >> 2 ) & 1 ) ;
num_slices = num_x_slices * ctx -> num_y_mbs ;
if ( num_slices != AV_RB16 ( buf + 5 ) ) {
av_log ( avctx , AV_LOG_ERROR , "invalid number of slices\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( ctx -> total_slices != num_slices ) {
av_freep ( & ctx -> slice_data ) ;
ctx -> slice_data = av_malloc ( ( num_slices + 1 ) * sizeof ( ctx -> slice_data [ 0 ] ) ) ;
if ( ! ctx -> slice_data ) return AVERROR ( ENOMEM ) ;
ctx -> total_slices = num_slices ;
}
if ( hdr_size + num_slices * 2 > data_size ) {
av_log ( avctx , AV_LOG_ERROR , "slice table too small\n" ) ;
return AVERROR_INVALIDDATA ;
}
index_ptr = buf + hdr_size ;
data_ptr = index_ptr + num_slices * 2 ;
for ( i = 0 ;
i < num_slices ;
i ++ ) {
ctx -> slice_data [ i ] . index = data_ptr ;
ctx -> slice_data [ i ] . prev_slice_sf = 0 ;
data_ptr += AV_RB16 ( index_ptr + i * 2 ) ;
}
ctx -> slice_data [ i ] . index = data_ptr ;
ctx -> slice_data [ i ] . prev_slice_sf = 0 ;
if ( data_ptr > buf + data_size ) {
av_log ( avctx , AV_LOG_ERROR , "out of slice data\n" ) ;
return - 1 ;
}
return pic_data_size ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _slurm_rpc_dump_front_end ( slurm_msg_t * msg ) {
DEF_TIMERS ;
char * dump = NULL ;
int dump_size = 0 ;
slurm_msg_t response_msg ;
front_end_info_request_msg_t * front_end_req_msg = ( front_end_info_request_msg_t * ) msg -> data ;
slurmctld_lock_t node_read_lock = {
READ_LOCK , NO_LOCK , NO_LOCK , READ_LOCK , NO_LOCK }
;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
START_TIMER ;
debug3 ( "Processing RPC: REQUEST_FRONT_END_INFO from uid=%d" , uid ) ;
lock_slurmctld ( node_read_lock ) ;
if ( ( front_end_req_msg -> last_update - 1 ) >= last_front_end_update ) {
unlock_slurmctld ( node_read_lock ) ;
debug3 ( "_slurm_rpc_dump_front_end, no change" ) ;
slurm_send_rc_msg ( msg , SLURM_NO_CHANGE_IN_DATA ) ;
}
else {
pack_all_front_end ( & dump , & dump_size , uid , msg -> protocol_version ) ;
unlock_slurmctld ( node_read_lock ) ;
END_TIMER2 ( "_slurm_rpc_dump_front_end" ) ;
debug2 ( "_slurm_rpc_dump_front_end, size=%d %s" , dump_size , TIME_STR ) ;
slurm_msg_t_init ( & response_msg ) ;
response_msg . flags = msg -> flags ;
response_msg . protocol_version = msg -> protocol_version ;
response_msg . address = msg -> address ;
response_msg . conn = msg -> conn ;
response_msg . msg_type = RESPONSE_FRONT_END_INFO ;
response_msg . data = dump ;
response_msg . data_size = dump_size ;
slurm_send_node_msg ( msg -> conn_fd , & response_msg ) ;
xfree ( dump ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool chal_reply_h ( connection_t * c ) {
char hishash [ MAX_STRING_SIZE ] ;
char myhash [ EVP_MAX_MD_SIZE ] ;
EVP_MD_CTX * ctx ;
if ( sscanf ( c -> buffer , "%*d " MAX_STRING , hishash ) != 1 ) {
logger ( LOG_ERR , "Got bad %s from %s (%s)" , "CHAL_REPLY" , c -> name , c -> hostname ) ;
return false ;
}
if ( strlen ( hishash ) != ( size_t ) EVP_MD_size ( c -> outdigest ) * 2 ) {
logger ( LOG_ERR , "Possible intruder %s (%s): %s" , c -> name , c -> hostname , "wrong challenge reply length" ) ;
return false ;
}
if ( ! hex2bin ( hishash , hishash , EVP_MD_size ( c -> outdigest ) ) ) {
logger ( LOG_ERR , "Got bad %s from %s(%s): %s" , "CHAL_REPLY" , c -> name , c -> hostname , "invalid hash" ) ;
return false ;
}
ctx = EVP_MD_CTX_create ( ) ;
if ( ! ctx ) {
abort ( ) ;
}
if ( ! EVP_DigestInit ( ctx , c -> outdigest ) || ! EVP_DigestUpdate ( ctx , c -> hischallenge , RSA_size ( c -> rsa_key ) ) || ! EVP_DigestFinal ( ctx , ( unsigned char * ) myhash , NULL ) ) {
EVP_MD_CTX_destroy ( ctx ) ;
logger ( LOG_ERR , "Error during calculation of response from %s (%s): %s" , c -> name , c -> hostname , ERR_error_string ( ERR_get_error ( ) , NULL ) ) ;
return false ;
}
EVP_MD_CTX_destroy ( ctx ) ;
if ( memcmp ( hishash , myhash , EVP_MD_size ( c -> outdigest ) ) ) {
logger ( LOG_ERR , "Possible intruder %s (%s): %s" , c -> name , c -> hostname , "wrong challenge reply" ) ;
ifdebug ( SCARY_THINGS ) {
bin2hex ( myhash , hishash , SHA_DIGEST_LENGTH ) ;
hishash [ SHA_DIGEST_LENGTH * 2 ] = '\0' ;
logger ( LOG_DEBUG , "Expected challenge reply: %s" , hishash ) ;
}
return false ;
}
c -> allow_request = ACK ;
if ( ! c -> outgoing ) {
send_chal_reply ( c ) ;
}
return send_ack ( c ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void stroke_purge ( private_stroke_socket_t * this , stroke_msg_t * msg , FILE * out ) {
if ( msg -> purge . flags & PURGE_OCSP ) {
lib -> credmgr -> flush_cache ( lib -> credmgr , CERT_X509_OCSP_RESPONSE ) ;
}
if ( msg -> purge . flags & PURGE_CRLS ) {
lib -> credmgr -> flush_cache ( lib -> credmgr , CERT_X509_CRL ) ;
}
if ( msg -> purge . flags & PURGE_CERTS ) {
lib -> credmgr -> flush_cache ( lib -> credmgr , CERT_X509 ) ;
}
if ( msg -> purge . flags & PURGE_IKE ) {
this -> control -> purge_ike ( this -> control , msg , out ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static char * w_addchar ( char * buffer , size_t * actlen , size_t * maxlen , char ch ) {
if ( * actlen == * maxlen ) {
char * old_buffer = buffer ;
assert ( buffer == NULL || * maxlen != 0 ) ;
* maxlen += W_CHUNK ;
buffer = ( char * ) realloc ( buffer , 1 + * maxlen ) ;
if ( buffer == NULL ) free ( old_buffer ) ;
}
if ( buffer != NULL ) {
buffer [ * actlen ] = ch ;
buffer [ ++ ( * actlen ) ] = '\0' ;
}
return buffer ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
ber_tag_t ber_get_next ( Sockbuf * sb , ber_len_t * len , BerElement * ber ) {
assert ( sb != NULL ) ;
assert ( len != NULL ) ;
assert ( ber != NULL ) ;
assert ( SOCKBUF_VALID ( sb ) ) ;
assert ( LBER_VALID ( ber ) ) ;
if ( ber -> ber_debug & LDAP_DEBUG_TRACE ) {
ber_log_printf ( LDAP_DEBUG_TRACE , ber -> ber_debug , "ber_get_next\n" ) ;
}
if ( ber -> ber_rwptr == NULL ) {
assert ( ber -> ber_buf == NULL ) ;
ber -> ber_rwptr = ( char * ) & ber -> ber_len - 1 ;
ber -> ber_ptr = ber -> ber_rwptr ;
ber -> ber_tag = 0 ;
}
while ( ber -> ber_rwptr > ( char * ) & ber -> ber_tag && ber -> ber_rwptr < ( char * ) & ber -> ber_len + LENSIZE * 2 ) {
ber_slen_t sblen ;
char buf [ sizeof ( ber -> ber_len ) - 1 ] ;
ber_len_t tlen = 0 ;
sock_errset ( 0 ) ;
sblen = ( ( char * ) & ber -> ber_len + LENSIZE * 2 - 1 ) - ber -> ber_rwptr ;
if ( sblen < 1 ) sblen = 1 ;
sblen = ber_int_sb_read ( sb , ber -> ber_rwptr , sblen ) ;
if ( sblen <= 0 ) return LBER_DEFAULT ;
ber -> ber_rwptr += sblen ;
if ( ber -> ber_ptr == ( char * ) & ber -> ber_len - 1 ) {
ber_tag_t tag ;
unsigned char * p = ( unsigned char * ) ber -> ber_ptr ;
tag = * p ++ ;
if ( ( tag & LBER_BIG_TAG_MASK ) == LBER_BIG_TAG_MASK ) {
ber_len_t i ;
for ( i = 1 ;
( char * ) p < ber -> ber_rwptr ;
i ++ ) {
tag <<= 8 ;
tag |= * p ++ ;
if ( ! ( tag & LBER_MORE_TAG_MASK ) ) break ;
if ( i == sizeof ( ber_tag_t ) - 1 ) {
sock_errset ( ERANGE ) ;
return LBER_DEFAULT ;
}
}
if ( ( char * ) p == ber -> ber_rwptr ) {
sock_errset ( EWOULDBLOCK ) ;
return LBER_DEFAULT ;
}
}
ber -> ber_tag = tag ;
ber -> ber_ptr = ( char * ) p ;
}
if ( ber -> ber_ptr == ber -> ber_rwptr ) {
sock_errset ( EWOULDBLOCK ) ;
return LBER_DEFAULT ;
}
if ( * ber -> ber_ptr & 0x80 ) {
int i ;
unsigned char * p = ( unsigned char * ) ber -> ber_ptr ;
int llen = * p ++ & 0x7f ;
if ( llen > LENSIZE ) {
sock_errset ( ERANGE ) ;
return LBER_DEFAULT ;
}
if ( ber -> ber_rwptr - ( char * ) p < llen ) {
sock_errset ( EWOULDBLOCK ) ;
return LBER_DEFAULT ;
}
for ( i = 0 ;
i < llen ;
i ++ ) {
tlen <<= 8 ;
tlen |= * p ++ ;
}
ber -> ber_ptr = ( char * ) p ;
}
else {
tlen = * ( unsigned char * ) ber -> ber_ptr ++ ;
}
if ( ber -> ber_ptr < ( char * ) & ber -> ber_usertag ) {
if ( ber -> ber_rwptr < ( char * ) & ber -> ber_usertag ) {
sblen = ber -> ber_rwptr - ber -> ber_ptr ;
}
else {
sblen = ( char * ) & ber -> ber_usertag - ber -> ber_ptr ;
}
AC_MEMCPY ( buf , ber -> ber_ptr , sblen ) ;
ber -> ber_ptr += sblen ;
}
else {
sblen = 0 ;
}
ber -> ber_len = tlen ;
if ( ber -> ber_len == 0 ) {
sock_errset ( ERANGE ) ;
return LBER_DEFAULT ;
}
if ( sb -> sb_max_incoming && ber -> ber_len > sb -> sb_max_incoming ) {
ber_log_printf ( LDAP_DEBUG_CONNS , ber -> ber_debug , "ber_get_next: sockbuf_max_incoming exceeded " "(%ld > %ld)\n" , ber -> ber_len , sb -> sb_max_incoming ) ;
sock_errset ( ERANGE ) ;
return LBER_DEFAULT ;
}
if ( ber -> ber_buf == NULL ) {
ber_len_t l = ber -> ber_rwptr - ber -> ber_ptr ;
if ( ber -> ber_len < sblen + l ) {
sock_errset ( ERANGE ) ;
return LBER_DEFAULT ;
}
ber -> ber_buf = ( char * ) ber_memalloc_x ( ber -> ber_len + 1 , ber -> ber_memctx ) ;
if ( ber -> ber_buf == NULL ) {
return LBER_DEFAULT ;
}
ber -> ber_end = ber -> ber_buf + ber -> ber_len ;
if ( sblen ) {
AC_MEMCPY ( ber -> ber_buf , buf , sblen ) ;
}
if ( l > 0 ) {
AC_MEMCPY ( ber -> ber_buf + sblen , ber -> ber_ptr , l ) ;
sblen += l ;
}
* ber -> ber_end = '\0' ;
ber -> ber_ptr = ber -> ber_buf ;
ber -> ber_usertag = 0 ;
if ( ( ber_len_t ) sblen == ber -> ber_len ) {
goto done ;
}
ber -> ber_rwptr = ber -> ber_buf + sblen ;
}
}
if ( ( ber -> ber_rwptr >= ber -> ber_buf ) && ( ber -> ber_rwptr < ber -> ber_end ) ) {
ber_slen_t res ;
ber_slen_t to_go ;
to_go = ber -> ber_end - ber -> ber_rwptr ;
assert ( to_go > 0 ) ;
sock_errset ( 0 ) ;
res = ber_int_sb_read ( sb , ber -> ber_rwptr , to_go ) ;
if ( res <= 0 ) return LBER_DEFAULT ;
ber -> ber_rwptr += res ;
if ( res < to_go ) {
sock_errset ( EWOULDBLOCK ) ;
return LBER_DEFAULT ;
}
done : ber -> ber_rwptr = NULL ;
* len = ber -> ber_len ;
if ( ber -> ber_debug ) {
ber_log_printf ( LDAP_DEBUG_TRACE , ber -> ber_debug , "ber_get_next: tag 0x%lx len %ld contents:\n" , ber -> ber_tag , ber -> ber_len ) ;
ber_log_dump ( LDAP_DEBUG_BER , ber -> ber_debug , ber , 1 ) ;
}
return ( ber -> ber_tag ) ;
}
assert ( 0 ) ;
return LBER_DEFAULT ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gpgme_error_t uiserver_verify ( void * engine , gpgme_data_t sig , gpgme_data_t signed_text , gpgme_data_t plaintext ) {
engine_uiserver_t uiserver = engine ;
gpgme_error_t err ;
const char * protocol ;
char * cmd ;
if ( ! uiserver ) return gpg_error ( GPG_ERR_INV_VALUE ) ;
if ( uiserver -> protocol == GPGME_PROTOCOL_DEFAULT ) protocol = "" ;
else if ( uiserver -> protocol == GPGME_PROTOCOL_OpenPGP ) protocol = " --protocol=OpenPGP" ;
else if ( uiserver -> protocol == GPGME_PROTOCOL_CMS ) protocol = " --protocol=CMS" ;
else return gpgme_error ( GPG_ERR_UNSUPPORTED_PROTOCOL ) ;
if ( asprintf ( & cmd , "VERIFY%s" , protocol ) < 0 ) return gpg_error_from_syserror ( ) ;
uiserver -> input_cb . data = sig ;
err = uiserver_set_fd ( uiserver , INPUT_FD , map_data_enc ( uiserver -> input_cb . data ) ) ;
if ( err ) {
free ( cmd ) ;
return err ;
}
if ( plaintext ) {
uiserver -> output_cb . data = plaintext ;
err = uiserver_set_fd ( uiserver , OUTPUT_FD , 0 ) ;
}
else {
uiserver -> message_cb . data = signed_text ;
err = uiserver_set_fd ( uiserver , MESSAGE_FD , 0 ) ;
}
uiserver -> inline_data = NULL ;
if ( ! err ) err = start ( uiserver , cmd ) ;
free ( cmd ) ;
return err ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint16 de_tp_epc_ue_tl_c_setup ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len _U_ , gchar * add_string _U_ , int string_len _U_ ) {
guint32 curr_offset ;
curr_offset = offset ;
proto_tree_add_bits_item ( tree , hf_gsm_a_dtap_epc_ue_tl_c_mbsfn_area_id , tvb , curr_offset << 3 , 8 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
proto_tree_add_bits_item ( tree , hf_gsm_a_dtap_epc_ue_tl_c_mch_id , tvb , ( curr_offset << 3 ) + 4 , 4 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
proto_tree_add_bits_item ( tree , hf_gsm_a_dtap_epc_ue_tl_c_lcid , tvb , ( curr_offset << 3 ) + 3 , 5 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
return ( curr_offset - offset ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ __u32 __arch_swab32 ( __u32 val ) {
__asm__ ( "bswapl %0" : "=r" ( val ) : "0" ( val ) ) ;
return val ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_CommandMessage ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 461 "../../asn1/h245/h245.cnf" gint32 value ;
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_CommandMessage , CommandMessage_choice , & value ) ;
if ( h245_shorttypes == TRUE ) {
col_prepend_fstr ( actx -> pinfo -> cinfo , COL_INFO , "%s " , val_to_str ( value , h245_CommandMessage_short_vals , "<unknown>" ) ) ;
}
else {
col_prepend_fstr ( actx -> pinfo -> cinfo , COL_INFO , "%s " , val_to_str ( value , h245_CommandMessage_vals , "<unknown>" ) ) ;
}
col_set_fence ( actx -> pinfo -> cinfo , COL_INFO ) ;
if ( h245_pi != NULL ) {
if ( strlen ( h245_pi -> frame_label ) == 0 ) {
g_snprintf ( h245_pi -> frame_label , 50 , "%s" , val_to_str ( value , h245_CommandMessage_short_vals , "UKN" ) ) ;
}
g_strlcat ( h245_pi -> comment , val_to_str ( value , h245_CommandMessage_vals , "<unknown>" ) , 50 ) ;
}
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int exsltMathXpathCtxtRegister ( xmlXPathContextPtr ctxt , const xmlChar * prefix ) {
if ( ctxt && prefix && ! xmlXPathRegisterNs ( ctxt , prefix , ( const xmlChar * ) EXSLT_MATH_NAMESPACE ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "min" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathMinFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "max" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathMaxFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "highest" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathHighestFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "lowest" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathLowestFunction ) # ifdef HAVE_STDLIB_H && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "random" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathRandomFunction ) # endif # if HAVE_MATH_H && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "abs" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathAbsFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "sqrt" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathSqrtFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "power" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathPowerFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "log" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathLogFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "sin" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathSinFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "cos" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathCosFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "tan" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathTanFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "asin" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathAsinFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "acos" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathAcosFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "atan" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathAtanFunction ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "atan2" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathAtan2Function ) && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "exp" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathExpFunction ) # endif && ! xmlXPathRegisterFuncNS ( ctxt , ( const xmlChar * ) "constant" , ( const xmlChar * ) EXSLT_MATH_NAMESPACE , exsltMathConstantFunction ) ) {
return 0 ;
}
return - 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int asn1_d2i_read_bio ( BIO * in , BUF_MEM * * pb ) {
BUF_MEM * b ;
unsigned char * p ;
int i ;
size_t want = HEADER_SIZE ;
int eos = 0 ;
size_t off = 0 ;
size_t len = 0 ;
const unsigned char * q ;
long slen ;
int inf , tag , xclass ;
b = BUF_MEM_new ( ) ;
if ( b == NULL ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ERR_R_MALLOC_FAILURE ) ;
return - 1 ;
}
ERR_clear_error ( ) ;
for ( ;
;
) {
if ( want >= ( len - off ) ) {
want -= ( len - off ) ;
if ( len + want < len || ! BUF_MEM_grow_clean ( b , len + want ) ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ERR_R_MALLOC_FAILURE ) ;
goto err ;
}
i = BIO_read ( in , & ( b -> data [ len ] ) , want ) ;
if ( ( i < 0 ) && ( ( len - off ) == 0 ) ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_NOT_ENOUGH_DATA ) ;
goto err ;
}
if ( i > 0 ) {
if ( len + i < len ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_TOO_LONG ) ;
goto err ;
}
len += i ;
}
}
p = ( unsigned char * ) & ( b -> data [ off ] ) ;
q = p ;
inf = ASN1_get_object ( & q , & slen , & tag , & xclass , len - off ) ;
if ( inf & 0x80 ) {
unsigned long e ;
e = ERR_GET_REASON ( ERR_peek_error ( ) ) ;
if ( e != ASN1_R_TOO_LONG ) goto err ;
else ERR_clear_error ( ) ;
}
i = q - p ;
off += i ;
if ( inf & 1 ) {
eos ++ ;
if ( eos < 0 ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_HEADER_TOO_LONG ) ;
goto err ;
}
want = HEADER_SIZE ;
}
else if ( eos && ( slen == 0 ) && ( tag == V_ASN1_EOC ) ) {
eos -- ;
if ( eos <= 0 ) break ;
else want = HEADER_SIZE ;
}
else {
want = slen ;
if ( want > ( len - off ) ) {
want -= ( len - off ) ;
if ( want > INT_MAX || len + want < len ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_TOO_LONG ) ;
goto err ;
}
if ( ! BUF_MEM_grow_clean ( b , len + want ) ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ERR_R_MALLOC_FAILURE ) ;
goto err ;
}
while ( want > 0 ) {
i = BIO_read ( in , & ( b -> data [ len ] ) , want ) ;
if ( i <= 0 ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_NOT_ENOUGH_DATA ) ;
goto err ;
}
len += i ;
want -= i ;
}
}
if ( off + slen < off ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_TOO_LONG ) ;
goto err ;
}
off += slen ;
if ( eos <= 0 ) {
break ;
}
else want = HEADER_SIZE ;
}
}
if ( off > INT_MAX ) {
ASN1err ( ASN1_F_ASN1_D2I_READ_BIO , ASN1_R_TOO_LONG ) ;
goto err ;
}
* pb = b ;
return off ;
err : BUF_MEM_free ( b ) ;
return - 1 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int cine_read_probe ( AVProbeData * p ) {
int HeaderSize ;
if ( p -> buf [ 0 ] == 'C' && p -> buf [ 1 ] == 'I' && ( HeaderSize = AV_RL16 ( p -> buf + 2 ) ) >= 0x2C && AV_RL16 ( p -> buf + 4 ) <= CC_UNINT && AV_RL16 ( p -> buf + 6 ) <= 1 && AV_RL32 ( p -> buf + 20 ) && AV_RL32 ( p -> buf + 24 ) >= HeaderSize && AV_RL32 ( p -> buf + 28 ) >= HeaderSize && AV_RL32 ( p -> buf + 32 ) >= HeaderSize ) return AVPROBE_SCORE_MAX ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int alloc_addbyter ( int output , FILE * data ) {
struct asprintf * infop = ( struct asprintf * ) data ;
unsigned char outc = ( unsigned char ) output ;
if ( ! infop -> buffer ) {
infop -> buffer = malloc ( 32 ) ;
if ( ! infop -> buffer ) {
infop -> fail = 1 ;
return - 1 ;
}
infop -> alloc = 32 ;
infop -> len = 0 ;
}
else if ( infop -> len + 1 >= infop -> alloc ) {
char * newptr = NULL ;
size_t newsize = infop -> alloc * 2 ;
if ( newsize > infop -> alloc ) newptr = realloc ( infop -> buffer , newsize ) ;
if ( ! newptr ) {
infop -> fail = 1 ;
return - 1 ;
}
infop -> buffer = newptr ;
infop -> alloc = newsize ;
}
infop -> buffer [ infop -> len ] = outc ;
infop -> len ++ ;
return outc ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void setup_masks_hangul ( const hb_ot_shape_plan_t * plan , hb_buffer_t * buffer , hb_font_t * font HB_UNUSED ) {
const hangul_shape_plan_t * hangul_plan = ( const hangul_shape_plan_t * ) plan -> data ;
if ( likely ( hangul_plan ) ) {
unsigned int count = buffer -> len ;
hb_glyph_info_t * info = buffer -> info ;
for ( unsigned int i = 0 ;
i < count ;
i ++ , info ++ ) info -> mask |= hangul_plan -> mask_array [ info -> hangul_shaping_feature ( ) ] ;
}
HB_BUFFER_DEALLOCATE_VAR ( buffer , hangul_shaping_feature ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int kvm_get_xcrs ( X86CPU * cpu ) {
CPUX86State * env = & cpu -> env ;
int i , ret ;
struct kvm_xcrs xcrs ;
if ( ! has_xcrs ) {
return 0 ;
}
ret = kvm_vcpu_ioctl ( CPU ( cpu ) , KVM_GET_XCRS , & xcrs ) ;
if ( ret < 0 ) {
return ret ;
}
for ( i = 0 ;
i < xcrs . nr_xcrs ;
i ++ ) {
if ( xcrs . xcrs [ i ] . xcr == 0 ) {
env -> xcr0 = xcrs . xcrs [ i ] . value ;
break ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_FECCapability ( 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_FECCapability , FECCapability_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
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 )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ssl3_send_finished ( SSL * s , int a , int b , const char * sender , int slen ) {
unsigned char * p , * d ;
int i ;
unsigned long l ;
if ( s -> state == a ) {
d = ( unsigned char * ) s -> init_buf -> data ;
p = & ( d [ 4 ] ) ;
i = s -> method -> ssl3_enc -> final_finish_mac ( s , sender , slen , s -> s3 -> tmp . finish_md ) ;
s -> s3 -> tmp . finish_md_len = i ;
memcpy ( p , s -> s3 -> tmp . finish_md , i ) ;
p += i ;
l = i ;
if ( s -> type == SSL_ST_CONNECT ) {
OPENSSL_assert ( i <= EVP_MAX_MD_SIZE ) ;
memcpy ( s -> s3 -> previous_client_finished , s -> s3 -> tmp . finish_md , i ) ;
s -> s3 -> previous_client_finished_len = i ;
}
else {
OPENSSL_assert ( i <= EVP_MAX_MD_SIZE ) ;
memcpy ( s -> s3 -> previous_server_finished , s -> s3 -> tmp . finish_md , i ) ;
s -> s3 -> previous_server_finished_len = i ;
}
# ifdef OPENSSL_SYS_WIN16 l &= 0xffff ;
# endif * ( d ++ ) = SSL3_MT_FINISHED ;
l2n3 ( l , d ) ;
s -> init_num = ( int ) l + 4 ;
s -> init_off = 0 ;
s -> state = b ;
}
return ( ssl3_do_write ( s , SSL3_RT_HANDSHAKE ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dct_unquantize_mpeg1_inter_c ( MpegEncContext * s , int16_t * block , int n , int qscale ) {
int i , level , nCoeffs ;
const uint16_t * quant_matrix ;
nCoeffs = s -> block_last_index [ n ] ;
quant_matrix = s -> inter_matrix ;
for ( i = 0 ;
i <= nCoeffs ;
i ++ ) {
int j = s -> intra_scantable . permutated [ i ] ;
level = block [ j ] ;
if ( level ) {
if ( level < 0 ) {
level = - level ;
level = ( ( ( level << 1 ) + 1 ) * qscale * ( ( int ) ( quant_matrix [ j ] ) ) ) >> 4 ;
level = ( level - 1 ) | 1 ;
level = - level ;
}
else {
level = ( ( ( level << 1 ) + 1 ) * qscale * ( ( int ) ( quant_matrix [ j ] ) ) ) >> 4 ;
level = ( level - 1 ) | 1 ;
}
block [ j ] = level ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * authGSSClientClean ( PyObject * self , PyObject * args ) {
gss_client_state * state ;
PyObject * pystate ;
int result = 0 ;
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 ) {
result = authenticate_gss_client_clean ( state ) ;
free ( state ) ;
# if PY_MAJOR_VERSION >= 3 PyCapsule_SetPointer ( pystate , NULL ) ;
# else PyCObject_SetVoidPtr ( pystate , NULL ) ;
# endif }
return Py_BuildValue ( "i" , result ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSMimeHdrFieldCreateNamed ( TSMBuffer bufp , TSMLoc mh_mloc , const char * name , int name_len , TSMLoc * locp ) {
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
sdk_assert ( ( sdk_sanity_check_mime_hdr_handle ( mh_mloc ) == TS_SUCCESS ) || ( sdk_sanity_check_http_hdr_handle ( mh_mloc ) == TS_SUCCESS ) ) ;
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) name ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) locp ) == TS_SUCCESS ) ;
if ( ! isWriteable ( bufp ) ) {
return TS_ERROR ;
}
if ( name_len == - 1 ) {
name_len = strlen ( name ) ;
}
MIMEHdrImpl * mh = _hdr_mloc_to_mime_hdr_impl ( mh_mloc ) ;
HdrHeap * heap = ( HdrHeap * ) ( ( ( HdrHeapSDKHandle * ) bufp ) -> m_heap ) ;
MIMEFieldSDKHandle * h = sdk_alloc_field_handle ( bufp , mh ) ;
h -> field_ptr = mime_field_create_named ( heap , mh , name , name_len ) ;
* locp = reinterpret_cast < TSMLoc > ( h ) ;
return TS_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void skip_char ( hb_buffer_t * buffer ) {
buffer -> skip_glyph ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_q931_protocol_discriminator ( tvbuff_t * tvb , int offset , proto_tree * tree ) {
unsigned int discriminator = tvb_get_guint8 ( tvb , offset ) ;
if ( discriminator == NLPID_DMS ) {
proto_tree_add_uint_format_value ( tree , hf_q931_discriminator , tvb , offset , 1 , discriminator , "Maintenance messages" ) ;
}
else if ( discriminator == NLPID_Q_931 ) {
proto_tree_add_uint_format_value ( tree , hf_q931_discriminator , tvb , offset , 1 , discriminator , "Q.931" ) ;
}
else if ( discriminator == NLPID_Q_2931 ) {
proto_tree_add_uint_format_value ( tree , hf_q931_discriminator , tvb , offset , 1 , discriminator , "Q.2931" ) ;
}
else if ( ( discriminator >= 16 && discriminator < 63 ) || ( ( discriminator >= 80 ) && ( discriminator < 254 ) ) ) {
proto_tree_add_uint_format_value ( tree , hf_q931_discriminator , tvb , offset , 1 , discriminator , "Network layer or layer 3 protocol (0x%02X)" , discriminator ) ;
}
else if ( discriminator >= 64 && discriminator <= 79 ) {
proto_tree_add_uint_format_value ( tree , hf_q931_discriminator , tvb , offset , 1 , discriminator , "National use (0x%02X)" , discriminator ) ;
}
else {
proto_tree_add_uint_format_value ( tree , hf_q931_discriminator , tvb , offset , 1 , discriminator , "Reserved (0x%02X)" , discriminator ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void usb_ohci_exit ( PCIDevice * dev ) {
OHCIPCIState * ohci = PCI_OHCI ( dev ) ;
OHCIState * s = & ohci -> state ;
trace_usb_ohci_exit ( s -> name ) ;
ohci_bus_stop ( s ) ;
if ( s -> async_td ) {
usb_cancel_packet ( & s -> usb_packet ) ;
s -> async_td = 0 ;
}
ohci_stop_endpoints ( s ) ;
if ( ! ohci -> masterbus ) {
usb_bus_release ( & s -> bus ) ;
}
timer_del ( s -> eof_timer ) ;
timer_free ( s -> eof_timer ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int open_pack_bitmap ( void ) {
struct packed_git * p ;
int ret = - 1 ;
assert ( ! bitmap_git . map && ! bitmap_git . loaded ) ;
prepare_packed_git ( ) ;
for ( p = packed_git ;
p ;
p = p -> next ) {
if ( open_pack_bitmap_1 ( p ) == 0 ) ret = 0 ;
}
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int ac6_proc_init ( struct net * net ) {
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
ttfFont * ttfFont__create ( gs_font_dir * dir ) {
gs_memory_t * mem = dir -> memory -> stable_memory ;
ttfFont * ttf ;
if ( dir -> ttm == NULL ) {
gx_ttfMemory * m = gs_alloc_struct ( mem , gx_ttfMemory , & st_gx_ttfMemory , "ttfFont__create(gx_ttfMemory)" ) ;
if ( ! m ) return 0 ;
m -> super . alloc_struct = gx_ttfMemory__alloc_struct ;
m -> super . alloc_bytes = gx_ttfMemory__alloc_bytes ;
m -> super . free = gx_ttfMemory__free ;
m -> memory = mem ;
dir -> ttm = m ;
}
if ( ttfInterpreter__obtain ( & dir -> ttm -> super , & dir -> tti ) ) return 0 ;
if ( gx_san__obtain ( mem , & dir -> san ) ) return 0 ;
ttf = gs_alloc_struct ( mem , ttfFont , & st_ttfFont , "ttfFont__create" ) ;
if ( ttf == NULL ) return 0 ;
# ifdef DEBUG ttfFont__init ( ttf , & dir -> ttm -> super , DebugRepaint , ( gs_debug_c ( 'Y' ) ? DebugPrint : NULL ) , mem ) ;
# else ttfFont__init ( ttf , & dir -> ttm -> super , DebugRepaint , NULL , mem ) ;
# endif return ttf ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gboolean is_64bit_mode ( struct mswsp_ct * ct , packet_info * pinfo , gboolean * result , void * private_data ) {
guint32 client_ver = 0 ;
guint32 server_ver = 0 ;
struct message_data * data = find_matching_request_by_fid ( ct , pinfo , 0xC8 , TRUE , private_data ) ;
if ( data ) {
client_ver = data -> content . version ;
data = find_matching_request_by_fid ( ct , pinfo , 0xC8 , FALSE , private_data ) ;
if ( data ) {
server_ver = data -> content . version ;
* result = ( server_ver & 0xffff0000 ) && ( client_ver & 0xffff0000 ) ;
return TRUE ;
}
}
return FALSE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int may_create ( struct inode * dir , struct dentry * dentry , u16 tclass ) {
const struct task_security_struct * tsec = current_security ( ) ;
struct inode_security_struct * dsec ;
struct superblock_security_struct * sbsec ;
u32 sid , newsid ;
struct common_audit_data ad ;
int rc ;
dsec = inode_security ( dir ) ;
sbsec = dir -> i_sb -> s_security ;
sid = tsec -> sid ;
ad . type = LSM_AUDIT_DATA_DENTRY ;
ad . u . dentry = dentry ;
rc = avc_has_perm ( sid , dsec -> sid , SECCLASS_DIR , DIR__ADD_NAME | DIR__SEARCH , & ad ) ;
if ( rc ) return rc ;
rc = selinux_determine_inode_label ( current_security ( ) , dir , & dentry -> d_name , tclass , & newsid ) ;
if ( rc ) return rc ;
rc = avc_has_perm ( sid , newsid , tclass , FILE__CREATE , & ad ) ;
if ( rc ) return rc ;
return avc_has_perm ( newsid , sbsec -> sid , SECCLASS_FILESYSTEM , FILESYSTEM__ASSOCIATE , & ad ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_MultiplexEntrySend ( 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_MultiplexEntrySend , MultiplexEntrySend_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vc1_decode_i_blocks ( VC1Context * v ) {
int k , j ;
MpegEncContext * s = & v -> s ;
int cbp , val ;
uint8_t * coded_val ;
int mb_pos ;
switch ( v -> y_ac_table_index ) {
case 0 : v -> codingset = ( v -> pqindex <= 8 ) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA ;
break ;
case 1 : v -> codingset = CS_HIGH_MOT_INTRA ;
break ;
case 2 : v -> codingset = CS_MID_RATE_INTRA ;
break ;
}
switch ( v -> c_ac_table_index ) {
case 0 : v -> codingset2 = ( v -> pqindex <= 8 ) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER ;
break ;
case 1 : v -> codingset2 = CS_HIGH_MOT_INTER ;
break ;
case 2 : v -> codingset2 = CS_MID_RATE_INTER ;
break ;
}
s -> y_dc_scale = s -> y_dc_scale_table [ v -> pq ] ;
s -> c_dc_scale = s -> c_dc_scale_table [ v -> pq ] ;
s -> mb_x = s -> mb_y = 0 ;
s -> mb_intra = 1 ;
s -> first_slice_line = 1 ;
for ( s -> mb_y = 0 ;
s -> mb_y < s -> end_mb_y ;
s -> mb_y ++ ) {
s -> mb_x = 0 ;
ff_init_block_index ( s ) ;
for ( ;
s -> mb_x < v -> end_mb_x ;
s -> mb_x ++ ) {
uint8_t * dst [ 6 ] ;
ff_update_block_index ( s ) ;
dst [ 0 ] = s -> dest [ 0 ] ;
dst [ 1 ] = dst [ 0 ] + 8 ;
dst [ 2 ] = s -> dest [ 0 ] + s -> linesize * 8 ;
dst [ 3 ] = dst [ 2 ] + 8 ;
dst [ 4 ] = s -> dest [ 1 ] ;
dst [ 5 ] = s -> dest [ 2 ] ;
s -> dsp . clear_blocks ( s -> block [ 0 ] ) ;
mb_pos = s -> mb_x + s -> mb_y * s -> mb_width ;
s -> current_picture . f . mb_type [ mb_pos ] = MB_TYPE_INTRA ;
s -> current_picture . f . qscale_table [ mb_pos ] = v -> pq ;
s -> current_picture . f . motion_val [ 1 ] [ s -> block_index [ 0 ] ] [ 0 ] = 0 ;
s -> current_picture . f . motion_val [ 1 ] [ s -> block_index [ 0 ] ] [ 1 ] = 0 ;
cbp = get_vlc2 ( & v -> s . gb , ff_msmp4_mb_i_vlc . table , MB_INTRA_VLC_BITS , 2 ) ;
v -> s . ac_pred = get_bits1 ( & v -> s . gb ) ;
for ( k = 0 ;
k < 6 ;
k ++ ) {
val = ( ( cbp >> ( 5 - k ) ) & 1 ) ;
if ( k < 4 ) {
int pred = vc1_coded_block_pred ( & v -> s , k , & coded_val ) ;
val = val ^ pred ;
* coded_val = val ;
}
cbp |= val << ( 5 - k ) ;
vc1_decode_i_block ( v , s -> block [ k ] , k , val , ( k < 4 ) ? v -> codingset : v -> codingset2 ) ;
if ( k > 3 && ( s -> flags & CODEC_FLAG_GRAY ) ) continue ;
v -> vc1dsp . vc1_inv_trans_8x8 ( s -> block [ k ] ) ;
if ( v -> pq >= 9 && v -> overlap ) {
if ( v -> rangeredfrm ) for ( j = 0 ;
j < 64 ;
j ++ ) s -> block [ k ] [ j ] <<= 1 ;
s -> dsp . put_signed_pixels_clamped ( s -> block [ k ] , dst [ k ] , k & 4 ? s -> uvlinesize : s -> linesize ) ;
}
else {
if ( v -> rangeredfrm ) for ( j = 0 ;
j < 64 ;
j ++ ) s -> block [ k ] [ j ] = ( s -> block [ k ] [ j ] - 64 ) << 1 ;
s -> dsp . put_pixels_clamped ( s -> block [ k ] , dst [ k ] , k & 4 ? s -> uvlinesize : s -> linesize ) ;
}
}
if ( v -> pq >= 9 && v -> overlap ) {
if ( s -> mb_x ) {
v -> vc1dsp . vc1_h_overlap ( s -> dest [ 0 ] , s -> linesize ) ;
v -> vc1dsp . vc1_h_overlap ( s -> dest [ 0 ] + 8 * s -> linesize , s -> linesize ) ;
if ( ! ( s -> flags & CODEC_FLAG_GRAY ) ) {
v -> vc1dsp . vc1_h_overlap ( s -> dest [ 1 ] , s -> uvlinesize ) ;
v -> vc1dsp . vc1_h_overlap ( s -> dest [ 2 ] , s -> uvlinesize ) ;
}
}
v -> vc1dsp . vc1_h_overlap ( s -> dest [ 0 ] + 8 , s -> linesize ) ;
v -> vc1dsp . vc1_h_overlap ( s -> dest [ 0 ] + 8 * s -> linesize + 8 , s -> linesize ) ;
if ( ! s -> first_slice_line ) {
v -> vc1dsp . vc1_v_overlap ( s -> dest [ 0 ] , s -> linesize ) ;
v -> vc1dsp . vc1_v_overlap ( s -> dest [ 0 ] + 8 , s -> linesize ) ;
if ( ! ( s -> flags & CODEC_FLAG_GRAY ) ) {
v -> vc1dsp . vc1_v_overlap ( s -> dest [ 1 ] , s -> uvlinesize ) ;
v -> vc1dsp . vc1_v_overlap ( s -> dest [ 2 ] , s -> uvlinesize ) ;
}
}
v -> vc1dsp . vc1_v_overlap ( s -> dest [ 0 ] + 8 * s -> linesize , s -> linesize ) ;
v -> vc1dsp . vc1_v_overlap ( s -> dest [ 0 ] + 8 * s -> linesize + 8 , s -> linesize ) ;
}
if ( v -> s . loop_filter ) vc1_loop_filter_iblk ( v , v -> pq ) ;
if ( get_bits_count ( & s -> gb ) > v -> bits ) {
ff_er_add_slice ( & s -> er , 0 , 0 , s -> mb_x , s -> mb_y , ER_MB_ERROR ) ;
av_log ( s -> avctx , AV_LOG_ERROR , "Bits overconsumption: %i > %i\n" , get_bits_count ( & s -> gb ) , v -> bits ) ;
return ;
}
}
if ( ! v -> s . loop_filter ) ff_mpeg_draw_horiz_band ( s , s -> mb_y * 16 , 16 ) ;
else if ( s -> mb_y ) ff_mpeg_draw_horiz_band ( s , ( s -> mb_y - 1 ) * 16 , 16 ) ;
s -> first_slice_line = 0 ;
}
if ( v -> s . loop_filter ) ff_mpeg_draw_horiz_band ( s , ( s -> end_mb_y - 1 ) * 16 , 16 ) ;
ff_er_add_slice ( & s -> er , 0 , 0 , s -> mb_width - 1 , s -> mb_height - 1 , ER_MB_END ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_create_drop ( ) {
MYSQL_STMT * stmt_create , * stmt_drop , * stmt_select , * stmt_create_select ;
char * query ;
int rc , i ;
myheader ( "test_table_manipulation" ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS t1, t2" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create table t2 (a int);
" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "create table t1 (a int);
" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "insert into t2 values (3), (2), (1);
" ) ;
myquery ( rc ) ;
query = ( char * ) "create table t1 (a int)" ;
stmt_create = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt_create ) ;
query = ( char * ) "drop table t1" ;
stmt_drop = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt_drop ) ;
query = ( char * ) "select a in (select a from t2) from t1" ;
stmt_select = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt_select ) ;
rc = mysql_query ( mysql , "DROP TABLE t1" ) ;
myquery ( rc ) ;
query = ( char * ) "create table t1 select a from t2" ;
stmt_create_select = mysql_simple_prepare ( mysql , query ) ;
check_stmt ( stmt_create_select ) ;
for ( i = 0 ;
i < 3 ;
i ++ ) {
rc = mysql_stmt_execute ( stmt_create ) ;
check_execute ( stmt_create , rc ) ;
if ( ! opt_silent ) fprintf ( stdout , "created %i\n" , i ) ;
rc = mysql_stmt_execute ( stmt_select ) ;
check_execute ( stmt_select , rc ) ;
rc = my_process_stmt_result ( stmt_select ) ;
DIE_UNLESS ( rc == 0 ) ;
rc = mysql_stmt_execute ( stmt_drop ) ;
check_execute ( stmt_drop , rc ) ;
if ( ! opt_silent ) fprintf ( stdout , "dropped %i\n" , i ) ;
rc = mysql_stmt_execute ( stmt_create_select ) ;
check_execute ( stmt_create , rc ) ;
if ( ! opt_silent ) fprintf ( stdout , "created select %i\n" , i ) ;
rc = mysql_stmt_execute ( stmt_select ) ;
check_execute ( stmt_select , rc ) ;
rc = my_process_stmt_result ( stmt_select ) ;
DIE_UNLESS ( rc == 3 ) ;
rc = mysql_stmt_execute ( stmt_drop ) ;
check_execute ( stmt_drop , rc ) ;
if ( ! opt_silent ) fprintf ( stdout , "dropped %i\n" , i ) ;
}
mysql_stmt_close ( stmt_create ) ;
mysql_stmt_close ( stmt_drop ) ;
mysql_stmt_close ( stmt_select ) ;
mysql_stmt_close ( stmt_create_select ) ;
rc = mysql_query ( mysql , "DROP TABLE t2" ) ;
myquery ( rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void h225_init_routine ( void ) {
int i ;
for ( i = 0 ;
i < 7 ;
i ++ ) {
ras_calls [ i ] = g_hash_table_new ( h225ras_call_hash , h225ras_call_equal ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( PageLoadMetricsBrowserTest , AbortReload ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
GURL url ( embedded_test_server ( ) -> GetURL ( "/title1.html" ) ) ;
NavigateParams params ( browser ( ) , url , ui : : PAGE_TRANSITION_LINK ) ;
content : : TestNavigationManager manager ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , url ) ;
Navigate ( & params ) ;
EXPECT_TRUE ( manager . WaitForRequestStart ( ) ) ;
NavigateParams params2 ( browser ( ) , url , ui : : PAGE_TRANSITION_RELOAD ) ;
auto waiter = CreatePageLoadMetricsWaiter ( ) ;
waiter -> AddPageExpectation ( TimingField : : LOAD_EVENT ) ;
Navigate ( & params2 ) ;
waiter -> Wait ( ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHistogramAbortReloadBeforeCommit , 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pxa2xx_ssp_save ( QEMUFile * f , void * opaque ) {
PXA2xxSSPState * s = ( PXA2xxSSPState * ) opaque ;
int i ;
qemu_put_be32 ( f , s -> enable ) ;
qemu_put_be32s ( f , & s -> sscr [ 0 ] ) ;
qemu_put_be32s ( f , & s -> sscr [ 1 ] ) ;
qemu_put_be32s ( f , & s -> sspsp ) ;
qemu_put_be32s ( f , & s -> ssto ) ;
qemu_put_be32s ( f , & s -> ssitr ) ;
qemu_put_be32s ( f , & s -> sssr ) ;
qemu_put_8s ( f , & s -> sstsa ) ;
qemu_put_8s ( f , & s -> ssrsa ) ;
qemu_put_8s ( f , & s -> ssacd ) ;
qemu_put_byte ( f , s -> rx_level ) ;
for ( i = 0 ;
i < s -> rx_level ;
i ++ ) qemu_put_byte ( f , s -> rx_fifo [ ( s -> rx_start + i ) & 0xf ] ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static cmsTagTypeSignature DecideXYZtype ( cmsFloat64Number ICCVersion , const void * Data ) {
return cmsSigXYZType ;
cmsUNUSED_PARAMETER ( ICCVersion ) ;
cmsUNUSED_PARAMETER ( Data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp8_yv12_de_alloc_frame_buffer ( YV12_BUFFER_CONFIG * ybf ) {
if ( ybf ) {
if ( ybf -> buffer_alloc_sz > 0 ) {
vpx_free ( ybf -> buffer_alloc ) ;
}
vpx_memset ( ybf , 0 , sizeof ( YV12_BUFFER_CONFIG ) ) ;
}
else {
return - 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void draw_arrow ( uint8_t * buf , int sx , int sy , int ex , int ey , int w , int h , int stride , int color ) {
int dx , dy ;
sx = av_clip ( sx , - 100 , w + 100 ) ;
sy = av_clip ( sy , - 100 , h + 100 ) ;
ex = av_clip ( ex , - 100 , w + 100 ) ;
ey = av_clip ( ey , - 100 , h + 100 ) ;
dx = ex - sx ;
dy = ey - sy ;
if ( dx * dx + dy * dy > 3 * 3 ) {
int rx = dx + dy ;
int ry = - dx + dy ;
int length = ff_sqrt ( ( rx * rx + ry * ry ) << 8 ) ;
rx = ROUNDED_DIV ( rx * 3 << 4 , length ) ;
ry = ROUNDED_DIV ( ry * 3 << 4 , length ) ;
draw_line ( buf , sx , sy , sx + rx , sy + ry , w , h , stride , color ) ;
draw_line ( buf , sx , sy , sx - ry , sy + rx , w , h , stride , color ) ;
}
draw_line ( buf , sx , sy , ex , ey , w , h , stride , color ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void show ( const char * format , ... ) {
va_list arg_ptr ;
if ( ! verbose ) return ;
fprintf ( stderr , "%s: " , PGM ) ;
va_start ( arg_ptr , format ) ;
vfprintf ( stderr , format , arg_ptr ) ;
va_end ( arg_ptr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static fz_font * xps_lookup_font ( xps_document * doc , char * name ) {
xps_font_cache * cache ;
for ( cache = doc -> font_table ;
cache ;
cache = cache -> next ) if ( ! xps_strcasecmp ( cache -> name , name ) ) return fz_keep_font ( doc -> ctx , cache -> font ) ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int checkHttpTxnClientAddrGet ( SocketTest * test , void * data ) {
uint16_t port ;
uint16_t browser_port ;
TSHttpTxn txnp = ( TSHttpTxn ) data ;
sockaddr const * ptr = TSHttpTxnClientAddrGet ( txnp ) ;
browser_port = test -> browser -> local_port ;
if ( nullptr == ptr ) {
SDK_RPRINT ( test -> regtest , "TSHttpTxnClientClientAddrGet" , "TestCase2" , TC_FAIL , "TSHttpTxnClientAddrGet returned 0 pointer." ) ;
test -> test_client_remote_port_get = false ;
return TS_EVENT_CONTINUE ;
}
port = ats_ip_port_host_order ( ptr ) ;
TSDebug ( UTDBG_TAG , "Browser port = %x, Txn remote port = %x" , browser_port , port ) ;
if ( port == browser_port ) {
SDK_RPRINT ( test -> regtest , "TSHttpTxnClientAddrGet" , "TestCase1" , TC_PASS , "ok" ) ;
test -> test_client_remote_port_get = true ;
}
else {
SDK_RPRINT ( test -> regtest , "TSHttpTxnClientAddrGet" , "TestCase1" , TC_FAIL , "Value's Mismatch. From Function: %d Expected Value: %d" , port , browser_port ) ;
test -> test_client_remote_port_get = false ;
}
return TS_EVENT_CONTINUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dtls1_retransmit_buffered_messages ( SSL * s ) {
pqueue sent = s -> d1 -> sent_messages ;
piterator iter ;
pitem * item ;
hm_fragment * frag ;
int found = 0 ;
iter = pqueue_iterator ( sent ) ;
for ( item = pqueue_next ( & iter ) ;
item != NULL ;
item = pqueue_next ( & iter ) ) {
frag = ( hm_fragment * ) item -> data ;
if ( dtls1_retransmit_message ( s , ( unsigned short ) dtls1_get_queue_priority ( frag -> msg_header . seq , frag -> msg_header . is_ccs ) , 0 , & found ) <= 0 && found ) {
fprintf ( stderr , "dtls1_retransmit_message() failed\n" ) ;
return - 1 ;
}
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int pfkey_sockaddr_len ( sa_family_t family ) {
switch ( family ) {
case AF_INET : return sizeof ( struct sockaddr_in ) ;
# if IS_ENABLED ( CONFIG_IPV6 ) case AF_INET6 : return sizeof ( struct sockaddr_in6 ) ;
# endif }
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PyObject * authGSSClientUserName ( PyObject * self , PyObject * args ) {
gss_client_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 -> username ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static struct cgroup_meta_data * lxc_cgroup_load_meta2 ( const char * * subsystem_whitelist ) {
bool all_kernel_subsystems = true ;
bool all_named_subsystems = false ;
struct cgroup_meta_data * meta_data = NULL ;
char * * kernel_subsystems = NULL ;
int saved_errno = 0 ;
all_kernel_subsystems = subsystem_whitelist ? ( lxc_string_in_array ( "@kernel" , subsystem_whitelist ) || lxc_string_in_array ( "@all" , subsystem_whitelist ) ) : true ;
all_named_subsystems = subsystem_whitelist ? ( lxc_string_in_array ( "@named" , subsystem_whitelist ) || lxc_string_in_array ( "@all" , subsystem_whitelist ) ) : false ;
meta_data = calloc ( 1 , sizeof ( struct cgroup_meta_data ) ) ;
if ( ! meta_data ) return NULL ;
meta_data -> ref = 1 ;
if ( ! find_cgroup_subsystems ( & kernel_subsystems ) ) goto out_error ;
if ( ! find_cgroup_hierarchies ( meta_data , all_kernel_subsystems , all_named_subsystems , subsystem_whitelist ) ) goto out_error ;
if ( ! find_hierarchy_mountpts ( meta_data , kernel_subsystems ) ) goto out_error ;
if ( ! meta_data -> hierarchies || ! meta_data -> mount_points ) {
errno = EINVAL ;
goto out_error ;
}
lxc_free_array ( ( void * * ) kernel_subsystems , free ) ;
return meta_data ;
out_error : saved_errno = errno ;
lxc_free_array ( ( void * * ) kernel_subsystems , free ) ;
lxc_cgroup_put_meta ( meta_data ) ;
errno = saved_errno ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
my_bool mi_test_if_sort_rep ( MI_INFO * info , ha_rows rows , ulonglong key_map , my_bool force ) {
MYISAM_SHARE * share = info -> s ;
MI_KEYDEF * key = share -> keyinfo ;
uint i ;
if ( ! mi_is_any_key_active ( key_map ) ) return FALSE ;
for ( i = 0 ;
i < share -> base . keys ;
i ++ , key ++ ) {
if ( ! force && mi_too_big_key_for_sort ( key , rows ) ) return FALSE ;
}
return TRUE ;
}
| 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 ) ;
}
# if CONFIG_VP9_HIGHBITDEPTH # define intra_pred_high_sized ( type , size ) void vp9_high_ ## type ## _predictor_ ## size ## x ## size ## _c ( uint16_t * dst , ptrdiff_t stride , const uint16_t * above , const uint16_t * left , int bd ) {
high_ ## type ## _predictor ( dst , stride , size , above , left , bd ) ;
}
# 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 ) intra_pred_high_sized ( type , 4 ) intra_pred_high_sized ( type , 8 ) intra_pred_high_sized ( type , 16 ) intra_pred_high_sized ( type , 32 ) # else # 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 ) # endif # if CONFIG_VP9_HIGHBITDEPTH static INLINE void high_d207_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
( void ) above ;
( void ) bd ;
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 ] ;
}
}
static INLINE void high_d63_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
( void ) left ;
( void ) bd ;
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 ;
}
}
static INLINE void high_d45_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
( void ) left ;
( void ) bd ;
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 ;
}
}
static INLINE void high_d117_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
( void ) bd ;
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 ;
}
}
static INLINE void high_d135_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
( void ) bd ;
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 ;
}
}
static INLINE void high_d153_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
( void ) bd ;
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 ;
}
}
static INLINE void high_v_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r ;
( void ) left ;
( void ) bd ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memcpy ( dst , above , bs * sizeof ( uint16_t ) ) ;
dst += stride ;
}
}
static INLINE void high_h_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r ;
( void ) above ;
( void ) bd ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset16 ( dst , left [ r ] , bs ) ;
dst += stride ;
}
}
static INLINE void high_tm_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r , c ;
int ytop_left = above [ - 1 ] ;
( void ) bd ;
for ( r = 0 ;
r < bs ;
r ++ ) {
for ( c = 0 ;
c < bs ;
c ++ ) dst [ c ] = clip_pixel_high ( left [ r ] + above [ c ] - ytop_left , bd ) ;
dst += stride ;
}
}
static INLINE void high_dc_128_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int r ;
( void ) above ;
( void ) left ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset16 ( dst , 128 << ( bd - 8 ) , bs ) ;
dst += stride ;
}
}
static INLINE void high_dc_left_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int i , r , expected_dc , sum = 0 ;
( void ) above ;
( void ) bd ;
for ( i = 0 ;
i < bs ;
i ++ ) sum += left [ i ] ;
expected_dc = ( sum + ( bs >> 1 ) ) / bs ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset16 ( dst , expected_dc , bs ) ;
dst += stride ;
}
}
static INLINE void high_dc_top_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int i , r , expected_dc , sum = 0 ;
( void ) left ;
( void ) bd ;
for ( i = 0 ;
i < bs ;
i ++ ) sum += above [ i ] ;
expected_dc = ( sum + ( bs >> 1 ) ) / bs ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset16 ( dst , expected_dc , bs ) ;
dst += stride ;
}
}
static INLINE void high_dc_predictor ( uint16_t * dst , ptrdiff_t stride , int bs , const uint16_t * above , const uint16_t * left , int bd ) {
int i , r , expected_dc , sum = 0 ;
const int count = 2 * bs ;
( void ) bd ;
for ( i = 0 ;
i < bs ;
i ++ ) {
sum += above [ i ] ;
sum += left [ i ] ;
}
expected_dc = ( sum + ( count >> 1 ) ) / count ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset16 ( dst , expected_dc , bs ) ;
dst += stride ;
}
}
# endif 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 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_RTPSession ( 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_RTPSession , RTPSession_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VALUE mFalseClass_to_json ( int argc , VALUE * argv , VALUE self ) {
GENERATE_JSON ( false ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int gs_main_finit ( gs_main_instance * minst , int exit_status , int code ) {
i_ctx_t * i_ctx_p = minst -> i_ctx_p ;
gs_dual_memory_t dmem = {
0 }
;
int exit_code ;
ref error_object ;
char * tempnames ;
tempnames = gs_main_tempnames ( minst ) ;
gs_finit_push_systemdict ( i_ctx_p ) ;
if ( minst -> init_done >= 2 ) {
gs_main_run_string ( minst , "/BGPrint /GetDeviceParam .special_op \ {
{
<</BeginPage {
pop}
/EndPage {
pop pop //false }
\ /BGPrint false /NumRenderingThreads 0>> setpagedevice}
if}
if \ serverdict /.jobsavelevel get 0 eq {
/quit}
{
/stop}
ifelse \ .systemvar exec" , 0 , & exit_code , & error_object ) ;
}
if ( minst -> init_done >= 2 ) {
int code = 0 ;
if ( idmemory -> reclaim != 0 ) {
code = interp_reclaim ( & minst -> i_ctx_p , avm_global ) ;
if ( code < 0 ) {
ref error_name ;
if ( tempnames ) free ( tempnames ) ;
if ( gs_errorname ( i_ctx_p , code , & error_name ) >= 0 ) {
char err_str [ 32 ] = {
0 }
;
name_string_ref ( imemory , & error_name , & error_name ) ;
memcpy ( err_str , error_name . value . const_bytes , r_size ( & error_name ) ) ;
emprintf2 ( imemory , "ERROR: %s (%d) reclaiming the memory while the interpreter finalization.\n" , err_str , code ) ;
}
else {
emprintf1 ( imemory , "UNKNOWN ERROR %d reclaiming the memory while the interpreter finalization.\n" , code ) ;
}
# ifdef MEMENTO_SQUEEZE_BUILD if ( code != gs_error_VMerror ) return gs_error_Fatal ;
# else return gs_error_Fatal ;
# endif }
i_ctx_p = minst -> i_ctx_p ;
}
if ( i_ctx_p -> pgs != NULL && i_ctx_p -> pgs -> device != NULL && gx_device_is_null ( i_ctx_p -> pgs -> device ) ) {
int code = gs_grestoreall ( i_ctx_p -> pgs ) ;
if ( code < 0 ) return_error ( gs_error_Fatal ) ;
}
if ( i_ctx_p -> pgs != NULL && i_ctx_p -> pgs -> device != NULL ) {
gx_device * pdev = i_ctx_p -> pgs -> device ;
const char * dname = pdev -> dname ;
rc_adjust ( pdev , 1 , "gs_main_finit" ) ;
gs_main_run_string ( minst , ".uninstallpagedevice serverdict \ /.jobsavelevel get 0 eq {
/quit}
{
/stop}
ifelse .systemvar exec" , 0 , & exit_code , & error_object ) ;
code = gs_closedevice ( pdev ) ;
if ( code < 0 ) {
ref error_name ;
if ( gs_errorname ( i_ctx_p , code , & error_name ) >= 0 ) {
char err_str [ 32 ] = {
0 }
;
name_string_ref ( imemory , & error_name , & error_name ) ;
memcpy ( err_str , error_name . value . const_bytes , r_size ( & error_name ) ) ;
emprintf3 ( imemory , "ERROR: %s (%d) on closing %s device.\n" , err_str , code , dname ) ;
}
else {
emprintf2 ( imemory , "UNKNOWN ERROR %d closing %s device.\n" , code , dname ) ;
}
}
rc_decrement ( pdev , "gs_main_finit" ) ;
if ( exit_status == 0 || exit_status == gs_error_Quit ) exit_status = code ;
}
gs_main_run_string ( minst , "(%stdout) (w) file closefile (%stderr) (w) file closefile \ serverdict /.jobsavelevel get 0 eq {
/quit}
{
/stop}
ifelse .systemexec \ systemdict /savedinitialgstate .forceundef" , 0 , & exit_code , & error_object ) ;
}
gp_readline_finit ( minst -> readline_data ) ;
i_ctx_p = minst -> i_ctx_p ;
if ( gs_debug_c ( ':' ) ) {
print_resource_usage ( minst , & gs_imemory , "Final" ) ;
dmprintf1 ( minst -> heap , "%% Exiting instance 0x%p\n" , minst ) ;
}
if ( minst -> init_done >= 1 ) {
gs_memory_t * mem_raw = i_ctx_p -> memory . current -> non_gc_memory ;
i_plugin_holder * h = i_ctx_p -> plugin_list ;
dmem = * idmemory ;
code = alloc_restore_all ( i_ctx_p ) ;
if ( code < 0 ) emprintf1 ( mem_raw , "ERROR %d while the final restore. See gs/psi/ierrors.h for code explanation.\n" , code ) ;
i_iodev_finit ( & dmem ) ;
i_plugin_finit ( mem_raw , h ) ;
}
if ( minst -> heap -> gs_lib_ctx -> fstdout2 && ( minst -> heap -> gs_lib_ctx -> fstdout2 != minst -> heap -> gs_lib_ctx -> fstdout ) && ( minst -> heap -> gs_lib_ctx -> fstdout2 != minst -> heap -> gs_lib_ctx -> fstderr ) ) {
fclose ( minst -> heap -> gs_lib_ctx -> fstdout2 ) ;
minst -> heap -> gs_lib_ctx -> fstdout2 = ( FILE * ) NULL ;
}
minst -> heap -> gs_lib_ctx -> stdout_is_redirected = 0 ;
minst -> heap -> gs_lib_ctx -> stdout_to_stderr = 0 ;
if ( tempnames ) {
char * p = tempnames ;
while ( * p ) {
unlink ( p ) ;
p += strlen ( p ) + 1 ;
}
free ( tempnames ) ;
}
gs_lib_finit ( exit_status , code , minst -> heap ) ;
gs_free_object ( minst -> heap , minst -> lib_path . container . value . refs , "lib_path array" ) ;
ialloc_finit ( & dmem ) ;
return exit_status ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * ultag_getRegion ( const ULanguageTag * langtag ) {
return langtag -> region ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int main_atou ( const char * arg , usize_t * uo , usize_t low , usize_t high , char which ) {
int ret ;
xoff_t xo ;
if ( ( ret = main_atoux ( arg , & xo , low , high , which ) ) ) {
return ret ;
}
* uo = ( usize_t ) xo ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _toUnicodeWithCallback ( UConverterToUnicodeArgs * pArgs , UErrorCode * err ) {
UConverterToUnicode toUnicode ;
UConverter * cnv ;
const char * s ;
UChar * t ;
int32_t * offsets ;
int32_t sourceIndex ;
int32_t errorInputLength ;
UBool converterSawEndOfInput , calledCallback ;
char replay [ UCNV_EXT_MAX_BYTES ] ;
const char * realSource , * realSourceLimit ;
int32_t realSourceIndex ;
UBool realFlush ;
cnv = pArgs -> converter ;
s = pArgs -> source ;
t = pArgs -> target ;
offsets = pArgs -> offsets ;
sourceIndex = 0 ;
if ( offsets == NULL ) {
toUnicode = cnv -> sharedData -> impl -> toUnicode ;
}
else {
toUnicode = cnv -> sharedData -> impl -> toUnicodeWithOffsets ;
if ( toUnicode == NULL ) {
toUnicode = cnv -> sharedData -> impl -> toUnicode ;
sourceIndex = - 1 ;
}
}
if ( cnv -> preToULength >= 0 ) {
realSource = NULL ;
realSourceLimit = NULL ;
realFlush = FALSE ;
realSourceIndex = 0 ;
}
else {
realSource = pArgs -> source ;
realSourceLimit = pArgs -> sourceLimit ;
realFlush = pArgs -> flush ;
realSourceIndex = sourceIndex ;
uprv_memcpy ( replay , cnv -> preToU , - cnv -> preToULength ) ;
pArgs -> source = replay ;
pArgs -> sourceLimit = replay - cnv -> preToULength ;
pArgs -> flush = FALSE ;
sourceIndex = - 1 ;
cnv -> preToULength = 0 ;
}
for ( ;
;
) {
if ( U_SUCCESS ( * err ) ) {
toUnicode ( pArgs , err ) ;
converterSawEndOfInput = ( UBool ) ( U_SUCCESS ( * err ) && pArgs -> flush && pArgs -> source == pArgs -> sourceLimit && cnv -> toULength == 0 ) ;
}
else {
converterSawEndOfInput = FALSE ;
}
calledCallback = FALSE ;
errorInputLength = 0 ;
for ( ;
;
) {
if ( offsets != NULL ) {
int32_t length = ( int32_t ) ( pArgs -> target - t ) ;
if ( length > 0 ) {
_updateOffsets ( offsets , length , sourceIndex , errorInputLength ) ;
pArgs -> offsets = offsets += length ;
}
if ( sourceIndex >= 0 ) {
sourceIndex += ( int32_t ) ( pArgs -> source - s ) ;
}
}
if ( cnv -> preToULength < 0 ) {
if ( realSource == NULL ) {
realSource = pArgs -> source ;
realSourceLimit = pArgs -> sourceLimit ;
realFlush = pArgs -> flush ;
realSourceIndex = sourceIndex ;
uprv_memcpy ( replay , cnv -> preToU , - cnv -> preToULength ) ;
pArgs -> source = replay ;
pArgs -> sourceLimit = replay - cnv -> preToULength ;
pArgs -> flush = FALSE ;
if ( ( sourceIndex += cnv -> preToULength ) < 0 ) {
sourceIndex = - 1 ;
}
cnv -> preToULength = 0 ;
}
else {
U_ASSERT ( realSource == NULL ) ;
* err = U_INTERNAL_PROGRAM_ERROR ;
}
}
s = pArgs -> source ;
t = pArgs -> target ;
if ( U_SUCCESS ( * err ) ) {
if ( s < pArgs -> sourceLimit ) {
break ;
}
else if ( realSource != NULL ) {
pArgs -> source = realSource ;
pArgs -> sourceLimit = realSourceLimit ;
pArgs -> flush = realFlush ;
sourceIndex = realSourceIndex ;
realSource = NULL ;
break ;
}
else if ( pArgs -> flush && cnv -> toULength > 0 ) {
* err = U_TRUNCATED_CHAR_FOUND ;
calledCallback = FALSE ;
}
else {
if ( pArgs -> flush ) {
if ( ! converterSawEndOfInput ) {
break ;
}
_reset ( cnv , UCNV_RESET_TO_UNICODE , FALSE ) ;
}
return ;
}
}
{
UErrorCode e ;
if ( calledCallback || ( e = * err ) == U_BUFFER_OVERFLOW_ERROR || ( e != U_INVALID_CHAR_FOUND && e != U_ILLEGAL_CHAR_FOUND && e != U_TRUNCATED_CHAR_FOUND && e != U_ILLEGAL_ESCAPE_SEQUENCE && e != U_UNSUPPORTED_ESCAPE_SEQUENCE ) ) {
if ( realSource != NULL ) {
int32_t length ;
U_ASSERT ( cnv -> preToULength == 0 ) ;
length = ( int32_t ) ( pArgs -> sourceLimit - pArgs -> source ) ;
if ( length > 0 ) {
uprv_memcpy ( cnv -> preToU , pArgs -> source , length ) ;
cnv -> preToULength = ( int8_t ) - length ;
}
pArgs -> source = realSource ;
pArgs -> sourceLimit = realSourceLimit ;
pArgs -> flush = realFlush ;
}
return ;
}
}
errorInputLength = cnv -> invalidCharLength = cnv -> toULength ;
if ( errorInputLength > 0 ) {
uprv_memcpy ( cnv -> invalidCharBuffer , cnv -> toUBytes , errorInputLength ) ;
}
cnv -> toULength = 0 ;
if ( cnv -> toUCallbackReason == UCNV_ILLEGAL && * err == U_INVALID_CHAR_FOUND ) {
cnv -> toUCallbackReason = UCNV_UNASSIGNED ;
}
cnv -> fromCharErrorBehaviour ( cnv -> toUContext , pArgs , cnv -> invalidCharBuffer , errorInputLength , cnv -> toUCallbackReason , err ) ;
cnv -> toUCallbackReason = UCNV_ILLEGAL ;
calledCallback = TRUE ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
CURLcode Curl_http ( struct connectdata * conn , bool * done ) {
struct Curl_easy * data = conn -> data ;
CURLcode result = CURLE_OK ;
struct HTTP * http ;
const char * ppath = data -> state . path ;
bool paste_ftp_userpwd = FALSE ;
char ftp_typecode [ sizeof ( "/;
type=?" ) ] = "" ;
const char * host = conn -> host . name ;
const char * te = "" ;
const char * ptr ;
const char * request ;
Curl_HttpReq httpreq = data -> set . httpreq ;
# if ! defined ( CURL_DISABLE_COOKIES ) char * addcookies = NULL ;
# endif curl_off_t included_body = 0 ;
const char * httpstring ;
Curl_send_buffer * req_buffer ;
curl_off_t postsize = 0 ;
int seekerr = CURL_SEEKFUNC_OK ;
* done = TRUE ;
if ( conn -> httpversion < 20 ) {
switch ( conn -> negnpn ) {
case CURL_HTTP_VERSION_2 : conn -> httpversion = 20 ;
result = Curl_http2_switched ( conn , NULL , 0 ) ;
if ( result ) return result ;
break ;
case CURL_HTTP_VERSION_1_1 : break ;
default : # ifdef USE_NGHTTP2 if ( conn -> data -> set . httpversion == CURL_HTTP_VERSION_2_PRIOR_KNOWLEDGE ) {
DEBUGF ( infof ( data , "HTTP/2 over clean TCP\n" ) ) ;
conn -> httpversion = 20 ;
result = Curl_http2_switched ( conn , NULL , 0 ) ;
if ( result ) return result ;
}
# endif break ;
}
}
else {
result = Curl_http2_setup ( conn ) ;
if ( result ) return result ;
}
http = data -> req . protop ;
if ( ! data -> state . this_is_a_follow ) {
free ( data -> state . first_host ) ;
data -> state . first_host = strdup ( conn -> host . name ) ;
if ( ! data -> state . first_host ) return CURLE_OUT_OF_MEMORY ;
data -> state . first_remote_port = conn -> remote_port ;
}
http -> writebytecount = http -> readbytecount = 0 ;
if ( ( conn -> handler -> protocol & ( PROTO_FAMILY_HTTP | CURLPROTO_FTP ) ) && data -> set . upload ) {
httpreq = HTTPREQ_PUT ;
}
if ( data -> set . str [ STRING_CUSTOMREQUEST ] ) request = data -> set . str [ STRING_CUSTOMREQUEST ] ;
else {
if ( data -> set . opt_no_body ) request = "HEAD" ;
else {
DEBUGASSERT ( ( httpreq > HTTPREQ_NONE ) && ( httpreq < HTTPREQ_LAST ) ) ;
switch ( httpreq ) {
case HTTPREQ_POST : case HTTPREQ_POST_FORM : request = "POST" ;
break ;
case HTTPREQ_PUT : request = "PUT" ;
break ;
default : case HTTPREQ_GET : request = "GET" ;
break ;
case HTTPREQ_HEAD : request = "HEAD" ;
break ;
}
}
}
if ( Curl_checkheaders ( conn , "User-Agent:" ) ) {
free ( conn -> allocptr . uagent ) ;
conn -> allocptr . uagent = NULL ;
}
result = Curl_http_output_auth ( conn , request , ppath , FALSE ) ;
if ( result ) return result ;
if ( ( data -> state . authhost . multi || data -> state . authproxy . multi ) && ( httpreq != HTTPREQ_GET ) && ( httpreq != HTTPREQ_HEAD ) ) {
conn -> bits . authneg = TRUE ;
}
else conn -> bits . authneg = FALSE ;
Curl_safefree ( conn -> allocptr . ref ) ;
if ( data -> change . referer && ! Curl_checkheaders ( conn , "Referer:" ) ) {
conn -> allocptr . ref = aprintf ( "Referer: %s\r\n" , data -> change . referer ) ;
if ( ! conn -> allocptr . ref ) return CURLE_OUT_OF_MEMORY ;
}
else conn -> allocptr . ref = NULL ;
# if ! defined ( CURL_DISABLE_COOKIES ) if ( data -> set . str [ STRING_COOKIE ] && ! Curl_checkheaders ( conn , "Cookie:" ) ) addcookies = data -> set . str [ STRING_COOKIE ] ;
# endif if ( ! Curl_checkheaders ( conn , "Accept-Encoding:" ) && data -> set . str [ STRING_ENCODING ] ) {
Curl_safefree ( conn -> allocptr . accept_encoding ) ;
conn -> allocptr . accept_encoding = aprintf ( "Accept-Encoding: %s\r\n" , data -> set . str [ STRING_ENCODING ] ) ;
if ( ! conn -> allocptr . accept_encoding ) return CURLE_OUT_OF_MEMORY ;
}
else {
Curl_safefree ( conn -> allocptr . accept_encoding ) ;
conn -> allocptr . accept_encoding = NULL ;
}
# ifdef HAVE_LIBZ if ( ! Curl_checkheaders ( conn , "TE:" ) && data -> set . http_transfer_encoding ) {
char * cptr = Curl_checkheaders ( conn , "Connection:" ) ;
# define TE_HEADER "TE: gzip\r\n" Curl_safefree ( conn -> allocptr . te ) ;
conn -> allocptr . te = cptr ? aprintf ( "%s, TE\r\n" TE_HEADER , cptr ) : strdup ( "Connection: TE\r\n" TE_HEADER ) ;
if ( ! conn -> allocptr . te ) return CURLE_OUT_OF_MEMORY ;
}
# endif ptr = Curl_checkheaders ( conn , "Transfer-Encoding:" ) ;
if ( ptr ) {
data -> req . upload_chunky = Curl_compareheader ( ptr , "Transfer-Encoding:" , "chunked" ) ;
}
else {
if ( ( conn -> handler -> protocol & PROTO_FAMILY_HTTP ) && data -> set . upload && ( data -> state . infilesize == - 1 ) ) {
if ( conn -> bits . authneg ) ;
else if ( use_http_1_1plus ( data , conn ) ) {
data -> req . upload_chunky = TRUE ;
}
else {
failf ( data , "Chunky upload is not supported by HTTP 1.0" ) ;
return CURLE_UPLOAD_FAILED ;
}
}
else {
data -> req . upload_chunky = FALSE ;
}
if ( data -> req . upload_chunky ) te = "Transfer-Encoding: chunked\r\n" ;
}
Curl_safefree ( conn -> allocptr . host ) ;
ptr = Curl_checkheaders ( conn , "Host:" ) ;
if ( ptr && ( ! data -> state . this_is_a_follow || Curl_raw_equal ( data -> state . first_host , conn -> host . name ) ) ) {
# if ! defined ( CURL_DISABLE_COOKIES ) char * cookiehost = Curl_copy_header_value ( ptr ) ;
if ( ! cookiehost ) return CURLE_OUT_OF_MEMORY ;
if ( ! * cookiehost ) free ( cookiehost ) ;
else {
int startsearch = 0 ;
if ( * cookiehost == '[' ) {
char * closingbracket ;
memmove ( cookiehost , cookiehost + 1 , strlen ( cookiehost ) - 1 ) ;
closingbracket = strchr ( cookiehost , ']' ) ;
if ( closingbracket ) * closingbracket = 0 ;
}
else {
char * colon = strchr ( cookiehost + startsearch , ':' ) ;
if ( colon ) * colon = 0 ;
}
Curl_safefree ( conn -> allocptr . cookiehost ) ;
conn -> allocptr . cookiehost = cookiehost ;
}
# endif if ( strcmp ( "Host:" , ptr ) ) {
conn -> allocptr . host = aprintf ( "%s\r\n" , ptr ) ;
if ( ! conn -> allocptr . host ) return CURLE_OUT_OF_MEMORY ;
}
else conn -> allocptr . host = NULL ;
}
else {
if ( ( ( conn -> given -> protocol & CURLPROTO_HTTPS ) && ( conn -> remote_port == PORT_HTTPS ) ) || ( ( conn -> given -> protocol & CURLPROTO_HTTP ) && ( conn -> remote_port == PORT_HTTP ) ) ) conn -> allocptr . host = aprintf ( "Host: %s%s%s\r\n" , conn -> bits . ipv6_ip ? "[" : "" , host , conn -> bits . ipv6_ip ? "]" : "" ) ;
else conn -> allocptr . host = aprintf ( "Host: %s%s%s:%hu\r\n" , conn -> bits . ipv6_ip ? "[" : "" , host , conn -> bits . ipv6_ip ? "]" : "" , conn -> remote_port ) ;
if ( ! conn -> allocptr . host ) return CURLE_OUT_OF_MEMORY ;
}
# ifndef CURL_DISABLE_PROXY if ( conn -> bits . httpproxy && ! conn -> bits . tunnel_proxy ) {
if ( conn -> host . dispname != conn -> host . name ) {
char * url = data -> change . url ;
ptr = strstr ( url , conn -> host . dispname ) ;
if ( ptr ) {
size_t currlen = strlen ( conn -> host . dispname ) ;
size_t newlen = strlen ( conn -> host . name ) ;
size_t urllen = strlen ( url ) ;
char * newurl ;
newurl = malloc ( urllen + newlen - currlen + 1 ) ;
if ( newurl ) {
memcpy ( newurl , url , ptr - url ) ;
memcpy ( newurl + ( ptr - url ) , conn -> host . name , newlen ) ;
memcpy ( newurl + newlen + ( ptr - url ) , ptr + currlen , urllen - ( ptr - url ) - currlen + 1 ) ;
if ( data -> change . url_alloc ) {
Curl_safefree ( data -> change . url ) ;
data -> change . url_alloc = FALSE ;
}
data -> change . url = newurl ;
data -> change . url_alloc = TRUE ;
}
else return CURLE_OUT_OF_MEMORY ;
}
}
ppath = data -> change . url ;
if ( checkprefix ( "ftp://" , ppath ) ) {
if ( data -> set . proxy_transfer_mode ) {
char * type = strstr ( ppath , ";
type=" ) ;
if ( type && type [ 6 ] && type [ 7 ] == 0 ) {
switch ( Curl_raw_toupper ( type [ 6 ] ) ) {
case 'A' : case 'D' : case 'I' : break ;
default : type = NULL ;
}
}
if ( ! type ) {
char * p = ftp_typecode ;
if ( ! * data -> state . path && ppath [ strlen ( ppath ) - 1 ] != '/' ) {
* p ++ = '/' ;
}
snprintf ( p , sizeof ( ftp_typecode ) - 1 , ";
type=%c" , data -> set . prefer_ascii ? 'a' : 'i' ) ;
}
}
if ( conn -> bits . user_passwd && ! conn -> bits . userpwd_in_url ) paste_ftp_userpwd = TRUE ;
}
}
# endif if ( HTTPREQ_POST_FORM == httpreq ) {
result = Curl_getformdata ( data , & http -> sendit , data -> set . httppost , Curl_checkheaders ( conn , "Content-Type:" ) , & http -> postsize ) ;
if ( result ) return result ;
}
http -> p_accept = Curl_checkheaders ( conn , "Accept:" ) ? NULL : "Accept: */*\r\n" ;
if ( ( ( HTTPREQ_POST == httpreq ) || ( HTTPREQ_POST_FORM == httpreq ) || ( HTTPREQ_PUT == httpreq ) ) && data -> state . resume_from ) {
if ( data -> state . resume_from < 0 ) {
data -> state . resume_from = 0 ;
}
if ( data -> state . resume_from && ! data -> state . this_is_a_follow ) {
if ( conn -> seek_func ) {
seekerr = conn -> seek_func ( conn -> seek_client , data -> state . resume_from , SEEK_SET ) ;
}
if ( seekerr != CURL_SEEKFUNC_OK ) {
if ( seekerr != CURL_SEEKFUNC_CANTSEEK ) {
failf ( data , "Could not seek stream" ) ;
return CURLE_READ_ERROR ;
}
else {
curl_off_t passed = 0 ;
do {
size_t readthisamountnow = ( data -> state . resume_from - passed > CURL_OFF_T_C ( BUFSIZE ) ) ? BUFSIZE : curlx_sotouz ( data -> state . resume_from - passed ) ;
size_t actuallyread = data -> state . fread_func ( data -> state . buffer , 1 , readthisamountnow , data -> state . in ) ;
passed += actuallyread ;
if ( ( actuallyread == 0 ) || ( actuallyread > readthisamountnow ) ) {
failf ( data , "Could only read %" CURL_FORMAT_CURL_OFF_T " bytes from the input" , passed ) ;
return CURLE_READ_ERROR ;
}
}
while ( passed < data -> state . resume_from ) ;
}
}
if ( data -> state . infilesize > 0 ) {
data -> state . infilesize -= data -> state . resume_from ;
if ( data -> state . infilesize <= 0 ) {
failf ( data , "File already completely uploaded" ) ;
return CURLE_PARTIAL_FILE ;
}
}
}
}
if ( data -> state . use_range ) {
if ( ( ( httpreq == HTTPREQ_GET ) || ( httpreq == HTTPREQ_HEAD ) ) && ! Curl_checkheaders ( conn , "Range:" ) ) {
free ( conn -> allocptr . rangeline ) ;
conn -> allocptr . rangeline = aprintf ( "Range: bytes=%s\r\n" , data -> state . range ) ;
}
else if ( ( httpreq != HTTPREQ_GET ) && ! Curl_checkheaders ( conn , "Content-Range:" ) ) {
free ( conn -> allocptr . rangeline ) ;
if ( data -> set . set_resume_from < 0 ) {
conn -> allocptr . rangeline = aprintf ( "Content-Range: bytes 0-%" CURL_FORMAT_CURL_OFF_T "/%" CURL_FORMAT_CURL_OFF_T "\r\n" , data -> state . infilesize - 1 , data -> state . infilesize ) ;
}
else if ( data -> state . resume_from ) {
curl_off_t total_expected_size = data -> state . resume_from + data -> state . infilesize ;
conn -> allocptr . rangeline = aprintf ( "Content-Range: bytes %s%" CURL_FORMAT_CURL_OFF_T "/%" CURL_FORMAT_CURL_OFF_T "\r\n" , data -> state . range , total_expected_size - 1 , total_expected_size ) ;
}
else {
conn -> allocptr . rangeline = aprintf ( "Content-Range: bytes %s/%" CURL_FORMAT_CURL_OFF_T "\r\n" , data -> state . range , data -> state . infilesize ) ;
}
if ( ! conn -> allocptr . rangeline ) return CURLE_OUT_OF_MEMORY ;
}
}
httpstring = use_http_1_1plus ( data , conn ) ? "1.1" : "1.0" ;
req_buffer = Curl_add_buffer_init ( ) ;
if ( ! req_buffer ) return CURLE_OUT_OF_MEMORY ;
result = Curl_add_bufferf ( req_buffer , "%s " , request ) ;
if ( result ) return result ;
if ( paste_ftp_userpwd ) result = Curl_add_bufferf ( req_buffer , "ftp://%s:%s@%s" , conn -> user , conn -> passwd , ppath + sizeof ( "ftp://" ) - 1 ) ;
else result = Curl_add_buffer ( req_buffer , ppath , strlen ( ppath ) ) ;
if ( result ) return result ;
result = Curl_add_bufferf ( req_buffer , "%s" " HTTP/%s\r\n" "%s" "%s" "%s" "%s" "%s" "%s" "%s" "%s" "%s" "%s" "%s" , ftp_typecode , httpstring , ( conn -> allocptr . host ? conn -> allocptr . host : "" ) , conn -> allocptr . proxyuserpwd ? conn -> allocptr . proxyuserpwd : "" , conn -> allocptr . userpwd ? conn -> allocptr . userpwd : "" , ( data -> state . use_range && conn -> allocptr . rangeline ) ? conn -> allocptr . rangeline : "" , ( data -> set . str [ STRING_USERAGENT ] && * data -> set . str [ STRING_USERAGENT ] && conn -> allocptr . uagent ) ? conn -> allocptr . uagent : "" , http -> p_accept ? http -> p_accept : "" , conn -> allocptr . te ? conn -> allocptr . te : "" , ( data -> set . str [ STRING_ENCODING ] && * data -> set . str [ STRING_ENCODING ] && conn -> allocptr . accept_encoding ) ? conn -> allocptr . accept_encoding : "" , ( data -> change . referer && conn -> allocptr . ref ) ? conn -> allocptr . ref : "" , ( conn -> bits . httpproxy && ! conn -> bits . tunnel_proxy && ! Curl_checkProxyheaders ( conn , "Proxy-Connection:" ) ) ? "Proxy-Connection: Keep-Alive\r\n" : "" , te ) ;
Curl_safefree ( conn -> allocptr . userpwd ) ;
switch ( data -> state . authproxy . picked ) {
case CURLAUTH_NEGOTIATE : case CURLAUTH_NTLM : case CURLAUTH_NTLM_WB : Curl_safefree ( conn -> allocptr . proxyuserpwd ) ;
break ;
}
if ( result ) return result ;
if ( ! ( conn -> handler -> flags & PROTOPT_SSL ) && conn -> httpversion != 20 && ( data -> set . httpversion == CURL_HTTP_VERSION_2 ) ) {
result = Curl_http2_request_upgrade ( req_buffer , conn ) ;
if ( result ) return result ;
}
# if ! defined ( CURL_DISABLE_COOKIES ) if ( data -> cookies || addcookies ) {
struct Cookie * co = NULL ;
int count = 0 ;
if ( data -> cookies ) {
Curl_share_lock ( data , CURL_LOCK_DATA_COOKIE , CURL_LOCK_ACCESS_SINGLE ) ;
co = Curl_cookie_getlist ( data -> cookies , conn -> allocptr . cookiehost ? conn -> allocptr . cookiehost : host , data -> state . path , ( conn -> handler -> protocol & CURLPROTO_HTTPS ) ? TRUE : FALSE ) ;
Curl_share_unlock ( data , CURL_LOCK_DATA_COOKIE ) ;
}
if ( co ) {
struct Cookie * store = co ;
while ( co ) {
if ( co -> value ) {
if ( 0 == count ) {
result = Curl_add_bufferf ( req_buffer , "Cookie: " ) ;
if ( result ) break ;
}
result = Curl_add_bufferf ( req_buffer , "%s%s=%s" , count ? ";
" : "" , co -> name , co -> value ) ;
if ( result ) break ;
count ++ ;
}
co = co -> next ;
}
Curl_cookie_freelist ( store , FALSE ) ;
}
if ( addcookies && ! result ) {
if ( ! count ) result = Curl_add_bufferf ( req_buffer , "Cookie: " ) ;
if ( ! result ) {
result = Curl_add_bufferf ( req_buffer , "%s%s" , count ? ";
" : "" , addcookies ) ;
count ++ ;
}
}
if ( count && ! result ) result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
}
# endif result = Curl_add_timecondition ( data , req_buffer ) ;
if ( result ) return result ;
result = Curl_add_custom_headers ( conn , FALSE , req_buffer ) ;
if ( result ) return result ;
http -> postdata = NULL ;
Curl_pgrsSetUploadSize ( data , - 1 ) ;
switch ( httpreq ) {
case HTTPREQ_POST_FORM : if ( ! http -> sendit || conn -> bits . authneg ) {
result = Curl_add_bufferf ( req_buffer , "Content-Length: 0\r\n\r\n" ) ;
if ( result ) return result ;
result = Curl_add_buffer_send ( req_buffer , conn , & data -> info . request_size , 0 , FIRSTSOCKET ) ;
if ( result ) failf ( data , "Failed sending POST request" ) ;
else Curl_setup_transfer ( conn , FIRSTSOCKET , - 1 , TRUE , & http -> readbytecount , - 1 , NULL ) ;
break ;
}
if ( Curl_FormInit ( & http -> form , http -> sendit ) ) {
failf ( data , "Internal HTTP POST error!" ) ;
return CURLE_HTTP_POST_ERROR ;
}
http -> form . fread_func = data -> state . fread_func ;
data -> state . fread_func = ( curl_read_callback ) Curl_FormReader ;
data -> state . in = & http -> form ;
http -> sending = HTTPSEND_BODY ;
if ( ! data -> req . upload_chunky && ! Curl_checkheaders ( conn , "Content-Length:" ) ) {
result = Curl_add_bufferf ( req_buffer , "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n" , http -> postsize ) ;
if ( result ) return result ;
}
result = expect100 ( data , conn , req_buffer ) ;
if ( result ) return result ;
{
char * contentType ;
size_t linelength = 0 ;
contentType = Curl_formpostheader ( ( void * ) & http -> form , & linelength ) ;
if ( ! contentType ) {
failf ( data , "Could not get Content-Type header line!" ) ;
return CURLE_HTTP_POST_ERROR ;
}
result = Curl_add_buffer ( req_buffer , contentType , linelength ) ;
if ( result ) return result ;
}
result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
Curl_pgrsSetUploadSize ( data , http -> postsize ) ;
result = Curl_add_buffer_send ( req_buffer , conn , & data -> info . request_size , 0 , FIRSTSOCKET ) ;
if ( result ) failf ( data , "Failed sending POST request" ) ;
else Curl_setup_transfer ( conn , FIRSTSOCKET , - 1 , TRUE , & http -> readbytecount , FIRSTSOCKET , & http -> writebytecount ) ;
if ( result ) {
Curl_formclean ( & http -> sendit ) ;
return result ;
}
result = Curl_convert_form ( data , http -> sendit ) ;
if ( result ) {
Curl_formclean ( & http -> sendit ) ;
return result ;
}
break ;
case HTTPREQ_PUT : if ( conn -> bits . authneg ) postsize = 0 ;
else postsize = data -> state . infilesize ;
if ( ( postsize != - 1 ) && ! data -> req . upload_chunky && ! Curl_checkheaders ( conn , "Content-Length:" ) ) {
result = Curl_add_bufferf ( req_buffer , "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n" , postsize ) ;
if ( result ) return result ;
}
if ( postsize != 0 ) {
result = expect100 ( data , conn , req_buffer ) ;
if ( result ) return result ;
}
result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
Curl_pgrsSetUploadSize ( data , postsize ) ;
result = Curl_add_buffer_send ( req_buffer , conn , & data -> info . request_size , 0 , FIRSTSOCKET ) ;
if ( result ) failf ( data , "Failed sending PUT request" ) ;
else Curl_setup_transfer ( conn , FIRSTSOCKET , - 1 , TRUE , & http -> readbytecount , postsize ? FIRSTSOCKET : - 1 , postsize ? & http -> writebytecount : NULL ) ;
if ( result ) return result ;
break ;
case HTTPREQ_POST : if ( conn -> bits . authneg ) postsize = 0 ;
else {
postsize = ( data -> state . infilesize != - 1 ) ? data -> state . infilesize : ( data -> set . postfields ? ( curl_off_t ) strlen ( data -> set . postfields ) : - 1 ) ;
}
if ( ( postsize != - 1 ) && ! data -> req . upload_chunky && ! Curl_checkheaders ( conn , "Content-Length:" ) ) {
result = Curl_add_bufferf ( req_buffer , "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n" , postsize ) ;
if ( result ) return result ;
}
if ( ! Curl_checkheaders ( conn , "Content-Type:" ) ) {
result = Curl_add_bufferf ( req_buffer , "Content-Type: application/" "x-www-form-urlencoded\r\n" ) ;
if ( result ) return result ;
}
ptr = Curl_checkheaders ( conn , "Expect:" ) ;
if ( ptr ) {
data -> state . expect100header = Curl_compareheader ( ptr , "Expect:" , "100-continue" ) ;
}
else if ( postsize > TINY_INITIAL_POST_SIZE || postsize < 0 ) {
result = expect100 ( data , conn , req_buffer ) ;
if ( result ) return result ;
}
else data -> state . expect100header = FALSE ;
if ( data -> set . postfields ) {
if ( conn -> httpversion != 20 && ! data -> state . expect100header && ( postsize < MAX_INITIAL_POST_SIZE ) ) {
result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
if ( ! data -> req . upload_chunky ) {
result = Curl_add_buffer ( req_buffer , data -> set . postfields , ( size_t ) postsize ) ;
included_body = postsize ;
}
else {
if ( postsize ) {
result = Curl_add_bufferf ( req_buffer , "%x\r\n" , ( int ) postsize ) ;
if ( ! result ) {
result = Curl_add_buffer ( req_buffer , data -> set . postfields , ( size_t ) postsize ) ;
if ( ! result ) result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
included_body = postsize + 2 ;
}
}
if ( ! result ) result = Curl_add_buffer ( req_buffer , "\x30\x0d\x0a\x0d\x0a" , 5 ) ;
included_body += 5 ;
}
if ( result ) return result ;
Curl_pgrsSetUploadSize ( data , postsize ) ;
}
else {
http -> postsize = postsize ;
http -> postdata = data -> set . postfields ;
http -> sending = HTTPSEND_BODY ;
data -> state . fread_func = ( curl_read_callback ) readmoredata ;
data -> state . in = ( void * ) conn ;
Curl_pgrsSetUploadSize ( data , http -> postsize ) ;
result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
}
}
else {
result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
if ( data -> req . upload_chunky && conn -> bits . authneg ) {
result = Curl_add_buffer ( req_buffer , "\x30\x0d\x0a\x0d\x0a" , 5 ) ;
if ( result ) return result ;
}
else if ( data -> state . infilesize ) {
Curl_pgrsSetUploadSize ( data , postsize ? postsize : - 1 ) ;
if ( ! conn -> bits . authneg ) {
http -> postdata = ( char * ) & http -> postdata ;
http -> postsize = postsize ;
}
}
}
result = Curl_add_buffer_send ( req_buffer , conn , & data -> info . request_size , ( size_t ) included_body , FIRSTSOCKET ) ;
if ( result ) failf ( data , "Failed sending HTTP POST request" ) ;
else Curl_setup_transfer ( conn , FIRSTSOCKET , - 1 , TRUE , & http -> readbytecount , http -> postdata ? FIRSTSOCKET : - 1 , http -> postdata ? & http -> writebytecount : NULL ) ;
break ;
default : result = Curl_add_buffer ( req_buffer , "\r\n" , 2 ) ;
if ( result ) return result ;
result = Curl_add_buffer_send ( req_buffer , conn , & data -> info . request_size , 0 , FIRSTSOCKET ) ;
if ( result ) failf ( data , "Failed sending HTTP request" ) ;
else Curl_setup_transfer ( conn , FIRSTSOCKET , - 1 , TRUE , & http -> readbytecount , http -> postdata ? FIRSTSOCKET : - 1 , http -> postdata ? & http -> writebytecount : NULL ) ;
}
if ( result ) return result ;
if ( http -> writebytecount ) {
Curl_pgrsSetUploadCounter ( data , http -> writebytecount ) ;
if ( Curl_pgrsUpdate ( conn ) ) result = CURLE_ABORTED_BY_CALLBACK ;
if ( http -> writebytecount >= postsize ) {
infof ( data , "upload completely sent off: %" CURL_FORMAT_CURL_OFF_T " out of %" CURL_FORMAT_CURL_OFF_T " bytes\n" , http -> writebytecount , postsize ) ;
data -> req . upload_done = TRUE ;
data -> req . keepon &= ~ KEEP_SEND ;
data -> req . exp100 = EXP100_SEND_DATA ;
}
}
if ( ( conn -> httpversion == 20 ) && data -> req . upload_chunky ) data -> req . upload_chunky = FALSE ;
return result ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cdxl_decode_ham6 ( CDXLVideoContext * c , AVFrame * frame ) {
AVCodecContext * avctx = c -> avctx ;
uint32_t new_palette [ 16 ] , r , g , b ;
uint8_t * ptr , * out , index , op ;
int x , y ;
ptr = c -> new_video ;
out = frame -> data [ 0 ] ;
import_palette ( c , new_palette ) ;
import_format ( c , avctx -> width , c -> new_video ) ;
for ( y = 0 ;
y < avctx -> height ;
y ++ ) {
r = new_palette [ 0 ] & 0xFF0000 ;
g = new_palette [ 0 ] & 0xFF00 ;
b = new_palette [ 0 ] & 0xFF ;
for ( x = 0 ;
x < avctx -> width ;
x ++ ) {
index = * ptr ++ ;
op = index >> 4 ;
index &= 15 ;
switch ( op ) {
case 0 : r = new_palette [ index ] & 0xFF0000 ;
g = new_palette [ index ] & 0xFF00 ;
b = new_palette [ index ] & 0xFF ;
break ;
case 1 : b = index * 0x11 ;
break ;
case 2 : r = index * 0x11 << 16 ;
break ;
case 3 : g = index * 0x11 << 8 ;
break ;
}
AV_WL24 ( out + x * 3 , r | g | b ) ;
}
out += frame -> linesize [ 0 ] ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_process_stream ( fz_context * ctx , pdf_processor * proc , pdf_csi * csi , fz_stream * stm ) {
pdf_document * doc = csi -> doc ;
pdf_lexbuf * buf = csi -> buf ;
fz_cookie * cookie = csi -> cookie ;
pdf_token tok = PDF_TOK_ERROR ;
int in_text_array = 0 ;
int syntax_errors = 0 ;
pdf_clear_stack ( ctx , csi ) ;
fz_var ( in_text_array ) ;
fz_var ( tok ) ;
if ( cookie ) {
cookie -> progress_max = - 1 ;
cookie -> progress = 0 ;
}
do {
fz_try ( ctx ) {
do {
if ( cookie ) {
if ( cookie -> abort ) {
tok = PDF_TOK_EOF ;
break ;
}
cookie -> progress ++ ;
}
tok = pdf_lex ( ctx , stm , buf ) ;
if ( in_text_array ) {
switch ( tok ) {
case PDF_TOK_CLOSE_ARRAY : in_text_array = 0 ;
break ;
case PDF_TOK_REAL : pdf_array_push_drop ( ctx , csi -> obj , pdf_new_real ( ctx , doc , buf -> f ) ) ;
break ;
case PDF_TOK_INT : pdf_array_push_drop ( ctx , csi -> obj , pdf_new_int ( ctx , doc , buf -> i ) ) ;
break ;
case PDF_TOK_STRING : pdf_array_push_drop ( ctx , csi -> obj , pdf_new_string ( ctx , doc , buf -> scratch , buf -> len ) ) ;
break ;
case PDF_TOK_EOF : break ;
case PDF_TOK_KEYWORD : if ( buf -> scratch [ 0 ] == 'T' && ( buf -> scratch [ 1 ] == 'w' || buf -> scratch [ 1 ] == 'c' ) && buf -> scratch [ 2 ] == 0 ) {
int n = pdf_array_len ( ctx , csi -> obj ) ;
if ( n > 0 ) {
pdf_obj * o = pdf_array_get ( ctx , csi -> obj , n - 1 ) ;
if ( pdf_is_number ( ctx , o ) ) {
csi -> stack [ 0 ] = pdf_to_real ( ctx , o ) ;
pdf_array_delete ( ctx , csi -> obj , n - 1 ) ;
pdf_process_keyword ( ctx , proc , csi , stm , buf -> scratch ) ;
}
}
}
default : fz_throw ( ctx , FZ_ERROR_SYNTAX , "syntax error in array" ) ;
}
}
else switch ( tok ) {
case PDF_TOK_ENDSTREAM : case PDF_TOK_EOF : tok = PDF_TOK_EOF ;
break ;
case PDF_TOK_OPEN_ARRAY : if ( csi -> obj ) {
pdf_drop_obj ( ctx , csi -> obj ) ;
csi -> obj = NULL ;
}
if ( csi -> in_text ) {
in_text_array = 1 ;
csi -> obj = pdf_new_array ( ctx , doc , 4 ) ;
}
else {
csi -> obj = pdf_parse_array ( ctx , doc , stm , buf ) ;
}
break ;
case PDF_TOK_OPEN_DICT : if ( csi -> obj ) {
pdf_drop_obj ( ctx , csi -> obj ) ;
csi -> obj = NULL ;
}
csi -> obj = pdf_parse_dict ( ctx , doc , stm , buf ) ;
break ;
case PDF_TOK_NAME : if ( csi -> name [ 0 ] ) {
pdf_drop_obj ( ctx , csi -> obj ) ;
csi -> obj = NULL ;
csi -> obj = pdf_new_name ( ctx , doc , buf -> scratch ) ;
}
else fz_strlcpy ( csi -> name , buf -> scratch , sizeof ( csi -> name ) ) ;
break ;
case PDF_TOK_INT : if ( csi -> top < nelem ( csi -> stack ) ) {
csi -> stack [ csi -> top ] = buf -> i ;
csi -> top ++ ;
}
else fz_throw ( ctx , FZ_ERROR_SYNTAX , "stack overflow" ) ;
break ;
case PDF_TOK_REAL : if ( csi -> top < nelem ( csi -> stack ) ) {
csi -> stack [ csi -> top ] = buf -> f ;
csi -> top ++ ;
}
else fz_throw ( ctx , FZ_ERROR_SYNTAX , "stack overflow" ) ;
break ;
case PDF_TOK_STRING : if ( buf -> len <= sizeof ( csi -> string ) ) {
memcpy ( csi -> string , buf -> scratch , buf -> len ) ;
csi -> string_len = buf -> len ;
}
else {
if ( csi -> obj ) {
pdf_drop_obj ( ctx , csi -> obj ) ;
csi -> obj = NULL ;
}
csi -> obj = pdf_new_string ( ctx , doc , buf -> scratch , buf -> len ) ;
}
break ;
case PDF_TOK_KEYWORD : pdf_process_keyword ( ctx , proc , csi , stm , buf -> scratch ) ;
pdf_clear_stack ( ctx , csi ) ;
break ;
default : fz_throw ( ctx , FZ_ERROR_SYNTAX , "syntax error in content stream" ) ;
}
}
while ( tok != PDF_TOK_EOF ) ;
}
fz_always ( ctx ) {
pdf_clear_stack ( ctx , csi ) ;
}
fz_catch ( ctx ) {
int caught = fz_caught ( ctx ) ;
if ( cookie ) {
if ( caught == FZ_ERROR_TRYLATER ) {
if ( cookie -> incomplete_ok ) cookie -> incomplete ++ ;
else fz_rethrow ( ctx ) ;
}
else if ( caught == FZ_ERROR_ABORT ) {
fz_rethrow ( ctx ) ;
}
else if ( caught == FZ_ERROR_SYNTAX ) {
cookie -> errors ++ ;
if ( ++ syntax_errors >= MAX_SYNTAX_ERRORS ) {
fz_warn ( ctx , "too many syntax errors;
ignoring rest of page" ) ;
tok = PDF_TOK_EOF ;
}
}
else {
cookie -> errors ++ ;
fz_warn ( ctx , "unrecoverable error;
ignoring rest of page" ) ;
tok = PDF_TOK_EOF ;
}
}
else {
if ( caught == FZ_ERROR_TRYLATER ) fz_rethrow ( ctx ) ;
else if ( caught == FZ_ERROR_ABORT ) fz_rethrow ( ctx ) ;
else if ( caught == FZ_ERROR_SYNTAX ) {
if ( ++ syntax_errors >= MAX_SYNTAX_ERRORS ) {
fz_warn ( ctx , "too many syntax errors;
ignoring rest of page" ) ;
tok = PDF_TOK_EOF ;
}
}
else {
fz_warn ( ctx , "unrecoverable error;
ignoring rest of page" ) ;
tok = PDF_TOK_EOF ;
}
}
in_text_array = 0 ;
}
}
while ( tok != PDF_TOK_EOF ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int restore_check_save ( i_ctx_t * i_ctx_p , alloc_save_t * * asave ) {
os_ptr op = osp ;
int code = restore_check_operand ( op , asave , idmemory ) ;
if ( code < 0 ) return code ;
if_debug2m ( 'u' , imemory , "[u]vmrestore 0x%lx, id = %lu\n" , ( ulong ) alloc_save_client_data ( * asave ) , ( ulong ) op -> value . saveid ) ;
if ( I_VALIDATE_BEFORE_RESTORE ) ivalidate_clean_spaces ( i_ctx_p ) ;
osp -- ;
{
int code ;
if ( ( code = restore_check_stack ( i_ctx_p , & o_stack , * asave , false ) ) < 0 || ( code = restore_check_stack ( i_ctx_p , & e_stack , * asave , true ) ) < 0 || ( code = restore_check_stack ( i_ctx_p , & d_stack , * asave , false ) ) < 0 ) {
osp ++ ;
return code ;
}
}
osp ++ ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int mss1_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
MSS1Context * ctx = avctx -> priv_data ;
MSS12Context * c = & ctx -> ctx ;
GetBitContext gb ;
ArithCoder acoder ;
int pal_changed = 0 ;
int ret ;
init_get_bits ( & gb , buf , buf_size * 8 ) ;
arith_init ( & acoder , & gb ) ;
ctx -> pic . reference = 3 ;
ctx -> pic . buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_READABLE | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE ;
if ( ( ret = avctx -> reget_buffer ( avctx , & ctx -> pic ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "reget_buffer() failed\n" ) ;
return ret ;
}
c -> pal_pic = ctx -> pic . data [ 0 ] + ctx -> pic . linesize [ 0 ] * ( avctx -> height - 1 ) ;
c -> pal_stride = - ctx -> pic . linesize [ 0 ] ;
c -> keyframe = ! arith_get_bit ( & acoder ) ;
if ( c -> keyframe ) {
c -> corrupted = 0 ;
ff_mss12_slicecontext_reset ( & ctx -> sc ) ;
pal_changed = decode_pal ( c , & acoder ) ;
ctx -> pic . key_frame = 1 ;
ctx -> pic . pict_type = AV_PICTURE_TYPE_I ;
}
else {
if ( c -> corrupted ) return AVERROR_INVALIDDATA ;
ctx -> pic . key_frame = 0 ;
ctx -> pic . pict_type = AV_PICTURE_TYPE_P ;
}
c -> corrupted = ff_mss12_decode_rect ( & ctx -> sc , & acoder , 0 , 0 , avctx -> width , avctx -> height ) ;
if ( c -> corrupted ) return AVERROR_INVALIDDATA ;
memcpy ( ctx -> pic . data [ 1 ] , c -> pal , AVPALETTE_SIZE ) ;
ctx -> pic . palette_has_changed = pal_changed ;
* got_frame = 1 ;
* ( AVFrame * ) data = ctx -> pic ;
return buf_size ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void update_frame_size ( VP9_COMP * cpi ) {
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCKD * const xd = & cpi -> mb . e_mbd ;
vp9_set_mb_mi ( cm , cm -> width , cm -> height ) ;
vp9_init_context_buffers ( cm ) ;
init_macroblockd ( cm , xd ) ;
if ( is_two_pass_svc ( cpi ) ) {
if ( vp9_realloc_frame_buffer ( & cpi -> alt_ref_buffer , cm -> width , cm -> height , cm -> subsampling_x , cm -> subsampling_y , # if CONFIG_VP9_HIGHBITDEPTH cm -> use_highbitdepth , # endif VP9_ENC_BORDER_IN_PIXELS , NULL , NULL , NULL ) ) vpx_internal_error ( & cm -> error , VPX_CODEC_MEM_ERROR , "Failed to reallocate alt_ref_buffer" ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void http_hdr_init ( HdrHeap * heap , HTTPHdrImpl * hh , HTTPType polarity ) {
memset ( & ( hh -> u ) , 0 , sizeof ( hh -> u ) ) ;
hh -> m_polarity = polarity ;
hh -> m_version = HTTP_VERSION ( 1 , 0 ) ;
hh -> m_fields_impl = mime_hdr_create ( heap ) ;
if ( polarity == HTTP_TYPE_REQUEST ) {
hh -> u . req . m_url_impl = url_create ( heap ) ;
hh -> u . req . m_method_wks_idx = - 1 ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static UBool _isPrivateuseValueSubtags ( const char * s , int32_t len ) {
const char * p = s ;
const char * pSubtag = NULL ;
if ( len < 0 ) {
len = ( int32_t ) uprv_strlen ( s ) ;
}
while ( ( p - s ) < len ) {
if ( * p == SEP ) {
if ( pSubtag == NULL ) {
return FALSE ;
}
if ( ! _isPrivateuseValueSubtag ( pSubtag , ( int32_t ) ( p - pSubtag ) ) ) {
return FALSE ;
}
pSubtag = NULL ;
}
else if ( pSubtag == NULL ) {
pSubtag = p ;
}
p ++ ;
}
if ( pSubtag == NULL ) {
return FALSE ;
}
return _isPrivateuseValueSubtag ( pSubtag , ( int32_t ) ( p - pSubtag ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int x8_get_dc_rlf ( IntraX8Context * const w , int const mode , int * const level , int * const final ) {
MpegEncContext * const s = w -> s ;
int i , e , c ;
assert ( mode < 3 ) ;
if ( ! w -> j_dc_vlc [ mode ] ) {
int table_index ;
table_index = get_bits ( & s -> gb , 3 ) ;
w -> j_dc_vlc [ mode ] = & j_dc_vlc [ w -> quant < 13 ] [ table_index ] ;
}
assert ( w -> j_dc_vlc ) ;
assert ( w -> j_dc_vlc [ mode ] -> table ) ;
i = get_vlc2 ( & s -> gb , w -> j_dc_vlc [ mode ] -> table , DC_VLC_BITS , DC_VLC_MTD ) ;
c = i > 16 ;
( * final ) = c ;
i -= 17 * c ;
if ( i <= 0 ) {
( * level ) = 0 ;
return - i ;
}
c = ( i + 1 ) >> 1 ;
c -= c > 1 ;
e = get_bits ( & s -> gb , c ) ;
i = dc_index_offset [ i ] + ( e >> 1 ) ;
e = - ( e & 1 ) ;
( * level ) = ( i ^ e ) - e ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int restore_check_operand ( os_ptr op , alloc_save_t * * pasave , gs_dual_memory_t * idmem ) {
vm_save_t * vmsave ;
ulong sid ;
alloc_save_t * asave ;
check_type ( * op , t_save ) ;
vmsave = r_ptr ( op , vm_save_t ) ;
if ( vmsave == 0 ) return_error ( gs_error_invalidrestore ) ;
sid = op -> value . saveid ;
asave = alloc_find_save ( idmem , sid ) ;
if ( asave == 0 ) return_error ( gs_error_invalidrestore ) ;
* pasave = asave ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void Type_ColorantOrderType_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
|
void vp9_idct32x32_1024_add_sse2 ( const int16_t * input , uint8_t * dest , int stride ) {
const __m128i rounding = _mm_set1_epi32 ( DCT_CONST_ROUNDING ) ;
const __m128i final_rounding = _mm_set1_epi16 ( 1 << 5 ) ;
const __m128i zero = _mm_setzero_si128 ( ) ;
const __m128i stg1_0 = pair_set_epi16 ( cospi_31_64 , - cospi_1_64 ) ;
const __m128i stg1_1 = pair_set_epi16 ( cospi_1_64 , cospi_31_64 ) ;
const __m128i stg1_2 = pair_set_epi16 ( cospi_15_64 , - cospi_17_64 ) ;
const __m128i stg1_3 = pair_set_epi16 ( cospi_17_64 , cospi_15_64 ) ;
const __m128i stg1_4 = pair_set_epi16 ( cospi_23_64 , - cospi_9_64 ) ;
const __m128i stg1_5 = pair_set_epi16 ( cospi_9_64 , cospi_23_64 ) ;
const __m128i stg1_6 = pair_set_epi16 ( cospi_7_64 , - cospi_25_64 ) ;
const __m128i stg1_7 = pair_set_epi16 ( cospi_25_64 , cospi_7_64 ) ;
const __m128i stg1_8 = pair_set_epi16 ( cospi_27_64 , - cospi_5_64 ) ;
const __m128i stg1_9 = pair_set_epi16 ( cospi_5_64 , cospi_27_64 ) ;
const __m128i stg1_10 = pair_set_epi16 ( cospi_11_64 , - cospi_21_64 ) ;
const __m128i stg1_11 = pair_set_epi16 ( cospi_21_64 , cospi_11_64 ) ;
const __m128i stg1_12 = pair_set_epi16 ( cospi_19_64 , - cospi_13_64 ) ;
const __m128i stg1_13 = pair_set_epi16 ( cospi_13_64 , cospi_19_64 ) ;
const __m128i stg1_14 = pair_set_epi16 ( cospi_3_64 , - cospi_29_64 ) ;
const __m128i stg1_15 = pair_set_epi16 ( cospi_29_64 , cospi_3_64 ) ;
const __m128i stg2_0 = pair_set_epi16 ( cospi_30_64 , - cospi_2_64 ) ;
const __m128i stg2_1 = pair_set_epi16 ( cospi_2_64 , cospi_30_64 ) ;
const __m128i stg2_2 = pair_set_epi16 ( cospi_14_64 , - cospi_18_64 ) ;
const __m128i stg2_3 = pair_set_epi16 ( cospi_18_64 , cospi_14_64 ) ;
const __m128i stg2_4 = pair_set_epi16 ( cospi_22_64 , - cospi_10_64 ) ;
const __m128i stg2_5 = pair_set_epi16 ( cospi_10_64 , cospi_22_64 ) ;
const __m128i stg2_6 = pair_set_epi16 ( cospi_6_64 , - cospi_26_64 ) ;
const __m128i stg2_7 = pair_set_epi16 ( cospi_26_64 , cospi_6_64 ) ;
const __m128i stg3_0 = pair_set_epi16 ( cospi_28_64 , - cospi_4_64 ) ;
const __m128i stg3_1 = pair_set_epi16 ( cospi_4_64 , cospi_28_64 ) ;
const __m128i stg3_2 = pair_set_epi16 ( cospi_12_64 , - cospi_20_64 ) ;
const __m128i stg3_3 = pair_set_epi16 ( cospi_20_64 , cospi_12_64 ) ;
const __m128i stg3_4 = pair_set_epi16 ( - cospi_4_64 , cospi_28_64 ) ;
const __m128i stg3_5 = pair_set_epi16 ( cospi_28_64 , cospi_4_64 ) ;
const __m128i stg3_6 = pair_set_epi16 ( - cospi_28_64 , - cospi_4_64 ) ;
const __m128i stg3_8 = pair_set_epi16 ( - cospi_20_64 , cospi_12_64 ) ;
const __m128i stg3_9 = pair_set_epi16 ( cospi_12_64 , cospi_20_64 ) ;
const __m128i stg3_10 = pair_set_epi16 ( - cospi_12_64 , - cospi_20_64 ) ;
const __m128i stg4_0 = pair_set_epi16 ( cospi_16_64 , cospi_16_64 ) ;
const __m128i stg4_1 = pair_set_epi16 ( cospi_16_64 , - cospi_16_64 ) ;
const __m128i stg4_2 = pair_set_epi16 ( cospi_24_64 , - cospi_8_64 ) ;
const __m128i stg4_3 = pair_set_epi16 ( cospi_8_64 , cospi_24_64 ) ;
const __m128i stg4_4 = pair_set_epi16 ( - cospi_8_64 , cospi_24_64 ) ;
const __m128i stg4_5 = pair_set_epi16 ( cospi_24_64 , cospi_8_64 ) ;
const __m128i stg4_6 = pair_set_epi16 ( - cospi_24_64 , - cospi_8_64 ) ;
const __m128i stg6_0 = pair_set_epi16 ( - cospi_16_64 , cospi_16_64 ) ;
__m128i in [ 32 ] , col [ 128 ] , zero_idx [ 16 ] ;
__m128i stp1_0 , stp1_1 , stp1_2 , stp1_3 , stp1_4 , stp1_5 , stp1_6 , stp1_7 , stp1_8 , stp1_9 , stp1_10 , stp1_11 , stp1_12 , stp1_13 , stp1_14 , stp1_15 , stp1_16 , stp1_17 , stp1_18 , stp1_19 , stp1_20 , stp1_21 , stp1_22 , stp1_23 , stp1_24 , stp1_25 , stp1_26 , stp1_27 , stp1_28 , stp1_29 , stp1_30 , stp1_31 ;
__m128i stp2_0 , stp2_1 , stp2_2 , stp2_3 , stp2_4 , stp2_5 , stp2_6 , stp2_7 , stp2_8 , stp2_9 , stp2_10 , stp2_11 , stp2_12 , stp2_13 , stp2_14 , stp2_15 , stp2_16 , stp2_17 , stp2_18 , stp2_19 , stp2_20 , stp2_21 , stp2_22 , stp2_23 , stp2_24 , stp2_25 , stp2_26 , stp2_27 , stp2_28 , stp2_29 , stp2_30 , stp2_31 ;
__m128i tmp0 , tmp1 , tmp2 , tmp3 , tmp4 , tmp5 , tmp6 , tmp7 ;
int i , j , i32 ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
i32 = ( i << 5 ) ;
LOAD_DQCOEFF ( in [ 0 ] , input ) ;
LOAD_DQCOEFF ( in [ 8 ] , input ) ;
LOAD_DQCOEFF ( in [ 16 ] , input ) ;
LOAD_DQCOEFF ( in [ 24 ] , input ) ;
LOAD_DQCOEFF ( in [ 1 ] , input ) ;
LOAD_DQCOEFF ( in [ 9 ] , input ) ;
LOAD_DQCOEFF ( in [ 17 ] , input ) ;
LOAD_DQCOEFF ( in [ 25 ] , input ) ;
LOAD_DQCOEFF ( in [ 2 ] , input ) ;
LOAD_DQCOEFF ( in [ 10 ] , input ) ;
LOAD_DQCOEFF ( in [ 18 ] , input ) ;
LOAD_DQCOEFF ( in [ 26 ] , input ) ;
LOAD_DQCOEFF ( in [ 3 ] , input ) ;
LOAD_DQCOEFF ( in [ 11 ] , input ) ;
LOAD_DQCOEFF ( in [ 19 ] , input ) ;
LOAD_DQCOEFF ( in [ 27 ] , input ) ;
LOAD_DQCOEFF ( in [ 4 ] , input ) ;
LOAD_DQCOEFF ( in [ 12 ] , input ) ;
LOAD_DQCOEFF ( in [ 20 ] , input ) ;
LOAD_DQCOEFF ( in [ 28 ] , input ) ;
LOAD_DQCOEFF ( in [ 5 ] , input ) ;
LOAD_DQCOEFF ( in [ 13 ] , input ) ;
LOAD_DQCOEFF ( in [ 21 ] , input ) ;
LOAD_DQCOEFF ( in [ 29 ] , input ) ;
LOAD_DQCOEFF ( in [ 6 ] , input ) ;
LOAD_DQCOEFF ( in [ 14 ] , input ) ;
LOAD_DQCOEFF ( in [ 22 ] , input ) ;
LOAD_DQCOEFF ( in [ 30 ] , input ) ;
LOAD_DQCOEFF ( in [ 7 ] , input ) ;
LOAD_DQCOEFF ( in [ 15 ] , input ) ;
LOAD_DQCOEFF ( in [ 23 ] , input ) ;
LOAD_DQCOEFF ( in [ 31 ] , input ) ;
zero_idx [ 0 ] = _mm_or_si128 ( in [ 0 ] , in [ 1 ] ) ;
zero_idx [ 1 ] = _mm_or_si128 ( in [ 2 ] , in [ 3 ] ) ;
zero_idx [ 2 ] = _mm_or_si128 ( in [ 4 ] , in [ 5 ] ) ;
zero_idx [ 3 ] = _mm_or_si128 ( in [ 6 ] , in [ 7 ] ) ;
zero_idx [ 4 ] = _mm_or_si128 ( in [ 8 ] , in [ 9 ] ) ;
zero_idx [ 5 ] = _mm_or_si128 ( in [ 10 ] , in [ 11 ] ) ;
zero_idx [ 6 ] = _mm_or_si128 ( in [ 12 ] , in [ 13 ] ) ;
zero_idx [ 7 ] = _mm_or_si128 ( in [ 14 ] , in [ 15 ] ) ;
zero_idx [ 8 ] = _mm_or_si128 ( in [ 16 ] , in [ 17 ] ) ;
zero_idx [ 9 ] = _mm_or_si128 ( in [ 18 ] , in [ 19 ] ) ;
zero_idx [ 10 ] = _mm_or_si128 ( in [ 20 ] , in [ 21 ] ) ;
zero_idx [ 11 ] = _mm_or_si128 ( in [ 22 ] , in [ 23 ] ) ;
zero_idx [ 12 ] = _mm_or_si128 ( in [ 24 ] , in [ 25 ] ) ;
zero_idx [ 13 ] = _mm_or_si128 ( in [ 26 ] , in [ 27 ] ) ;
zero_idx [ 14 ] = _mm_or_si128 ( in [ 28 ] , in [ 29 ] ) ;
zero_idx [ 15 ] = _mm_or_si128 ( in [ 30 ] , in [ 31 ] ) ;
zero_idx [ 0 ] = _mm_or_si128 ( zero_idx [ 0 ] , zero_idx [ 1 ] ) ;
zero_idx [ 1 ] = _mm_or_si128 ( zero_idx [ 2 ] , zero_idx [ 3 ] ) ;
zero_idx [ 2 ] = _mm_or_si128 ( zero_idx [ 4 ] , zero_idx [ 5 ] ) ;
zero_idx [ 3 ] = _mm_or_si128 ( zero_idx [ 6 ] , zero_idx [ 7 ] ) ;
zero_idx [ 4 ] = _mm_or_si128 ( zero_idx [ 8 ] , zero_idx [ 9 ] ) ;
zero_idx [ 5 ] = _mm_or_si128 ( zero_idx [ 10 ] , zero_idx [ 11 ] ) ;
zero_idx [ 6 ] = _mm_or_si128 ( zero_idx [ 12 ] , zero_idx [ 13 ] ) ;
zero_idx [ 7 ] = _mm_or_si128 ( zero_idx [ 14 ] , zero_idx [ 15 ] ) ;
zero_idx [ 8 ] = _mm_or_si128 ( zero_idx [ 0 ] , zero_idx [ 1 ] ) ;
zero_idx [ 9 ] = _mm_or_si128 ( zero_idx [ 2 ] , zero_idx [ 3 ] ) ;
zero_idx [ 10 ] = _mm_or_si128 ( zero_idx [ 4 ] , zero_idx [ 5 ] ) ;
zero_idx [ 11 ] = _mm_or_si128 ( zero_idx [ 6 ] , zero_idx [ 7 ] ) ;
zero_idx [ 12 ] = _mm_or_si128 ( zero_idx [ 8 ] , zero_idx [ 9 ] ) ;
zero_idx [ 13 ] = _mm_or_si128 ( zero_idx [ 10 ] , zero_idx [ 11 ] ) ;
zero_idx [ 14 ] = _mm_or_si128 ( zero_idx [ 12 ] , zero_idx [ 13 ] ) ;
if ( _mm_movemask_epi8 ( _mm_cmpeq_epi32 ( zero_idx [ 14 ] , zero ) ) == 0xFFFF ) {
col [ i32 + 0 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 1 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 2 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 3 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 4 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 5 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 6 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 7 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 8 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 9 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 10 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 11 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 12 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 13 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 14 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 15 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 16 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 17 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 18 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 19 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 20 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 21 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 22 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 23 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 24 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 25 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 26 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 27 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 28 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 29 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 30 ] = _mm_setzero_si128 ( ) ;
col [ i32 + 31 ] = _mm_setzero_si128 ( ) ;
continue ;
}
array_transpose_8x8 ( in , in ) ;
array_transpose_8x8 ( in + 8 , in + 8 ) ;
array_transpose_8x8 ( in + 16 , in + 16 ) ;
array_transpose_8x8 ( in + 24 , in + 24 ) ;
IDCT32 col [ i32 + 0 ] = _mm_add_epi16 ( stp1_0 , stp1_31 ) ;
col [ i32 + 1 ] = _mm_add_epi16 ( stp1_1 , stp1_30 ) ;
col [ i32 + 2 ] = _mm_add_epi16 ( stp1_2 , stp1_29 ) ;
col [ i32 + 3 ] = _mm_add_epi16 ( stp1_3 , stp1_28 ) ;
col [ i32 + 4 ] = _mm_add_epi16 ( stp1_4 , stp1_27 ) ;
col [ i32 + 5 ] = _mm_add_epi16 ( stp1_5 , stp1_26 ) ;
col [ i32 + 6 ] = _mm_add_epi16 ( stp1_6 , stp1_25 ) ;
col [ i32 + 7 ] = _mm_add_epi16 ( stp1_7 , stp1_24 ) ;
col [ i32 + 8 ] = _mm_add_epi16 ( stp1_8 , stp1_23 ) ;
col [ i32 + 9 ] = _mm_add_epi16 ( stp1_9 , stp1_22 ) ;
col [ i32 + 10 ] = _mm_add_epi16 ( stp1_10 , stp1_21 ) ;
col [ i32 + 11 ] = _mm_add_epi16 ( stp1_11 , stp1_20 ) ;
col [ i32 + 12 ] = _mm_add_epi16 ( stp1_12 , stp1_19 ) ;
col [ i32 + 13 ] = _mm_add_epi16 ( stp1_13 , stp1_18 ) ;
col [ i32 + 14 ] = _mm_add_epi16 ( stp1_14 , stp1_17 ) ;
col [ i32 + 15 ] = _mm_add_epi16 ( stp1_15 , stp1_16 ) ;
col [ i32 + 16 ] = _mm_sub_epi16 ( stp1_15 , stp1_16 ) ;
col [ i32 + 17 ] = _mm_sub_epi16 ( stp1_14 , stp1_17 ) ;
col [ i32 + 18 ] = _mm_sub_epi16 ( stp1_13 , stp1_18 ) ;
col [ i32 + 19 ] = _mm_sub_epi16 ( stp1_12 , stp1_19 ) ;
col [ i32 + 20 ] = _mm_sub_epi16 ( stp1_11 , stp1_20 ) ;
col [ i32 + 21 ] = _mm_sub_epi16 ( stp1_10 , stp1_21 ) ;
col [ i32 + 22 ] = _mm_sub_epi16 ( stp1_9 , stp1_22 ) ;
col [ i32 + 23 ] = _mm_sub_epi16 ( stp1_8 , stp1_23 ) ;
col [ i32 + 24 ] = _mm_sub_epi16 ( stp1_7 , stp1_24 ) ;
col [ i32 + 25 ] = _mm_sub_epi16 ( stp1_6 , stp1_25 ) ;
col [ i32 + 26 ] = _mm_sub_epi16 ( stp1_5 , stp1_26 ) ;
col [ i32 + 27 ] = _mm_sub_epi16 ( stp1_4 , stp1_27 ) ;
col [ i32 + 28 ] = _mm_sub_epi16 ( stp1_3 , stp1_28 ) ;
col [ i32 + 29 ] = _mm_sub_epi16 ( stp1_2 , stp1_29 ) ;
col [ i32 + 30 ] = _mm_sub_epi16 ( stp1_1 , stp1_30 ) ;
col [ i32 + 31 ] = _mm_sub_epi16 ( stp1_0 , stp1_31 ) ;
}
for ( i = 0 ;
i < 4 ;
i ++ ) {
j = i << 3 ;
array_transpose_8x8 ( col + j , in ) ;
array_transpose_8x8 ( col + j + 32 , in + 8 ) ;
array_transpose_8x8 ( col + j + 64 , in + 16 ) ;
array_transpose_8x8 ( col + j + 96 , in + 24 ) ;
IDCT32 in [ 0 ] = _mm_add_epi16 ( stp1_0 , stp1_31 ) ;
in [ 1 ] = _mm_add_epi16 ( stp1_1 , stp1_30 ) ;
in [ 2 ] = _mm_add_epi16 ( stp1_2 , stp1_29 ) ;
in [ 3 ] = _mm_add_epi16 ( stp1_3 , stp1_28 ) ;
in [ 4 ] = _mm_add_epi16 ( stp1_4 , stp1_27 ) ;
in [ 5 ] = _mm_add_epi16 ( stp1_5 , stp1_26 ) ;
in [ 6 ] = _mm_add_epi16 ( stp1_6 , stp1_25 ) ;
in [ 7 ] = _mm_add_epi16 ( stp1_7 , stp1_24 ) ;
in [ 8 ] = _mm_add_epi16 ( stp1_8 , stp1_23 ) ;
in [ 9 ] = _mm_add_epi16 ( stp1_9 , stp1_22 ) ;
in [ 10 ] = _mm_add_epi16 ( stp1_10 , stp1_21 ) ;
in [ 11 ] = _mm_add_epi16 ( stp1_11 , stp1_20 ) ;
in [ 12 ] = _mm_add_epi16 ( stp1_12 , stp1_19 ) ;
in [ 13 ] = _mm_add_epi16 ( stp1_13 , stp1_18 ) ;
in [ 14 ] = _mm_add_epi16 ( stp1_14 , stp1_17 ) ;
in [ 15 ] = _mm_add_epi16 ( stp1_15 , stp1_16 ) ;
in [ 16 ] = _mm_sub_epi16 ( stp1_15 , stp1_16 ) ;
in [ 17 ] = _mm_sub_epi16 ( stp1_14 , stp1_17 ) ;
in [ 18 ] = _mm_sub_epi16 ( stp1_13 , stp1_18 ) ;
in [ 19 ] = _mm_sub_epi16 ( stp1_12 , stp1_19 ) ;
in [ 20 ] = _mm_sub_epi16 ( stp1_11 , stp1_20 ) ;
in [ 21 ] = _mm_sub_epi16 ( stp1_10 , stp1_21 ) ;
in [ 22 ] = _mm_sub_epi16 ( stp1_9 , stp1_22 ) ;
in [ 23 ] = _mm_sub_epi16 ( stp1_8 , stp1_23 ) ;
in [ 24 ] = _mm_sub_epi16 ( stp1_7 , stp1_24 ) ;
in [ 25 ] = _mm_sub_epi16 ( stp1_6 , stp1_25 ) ;
in [ 26 ] = _mm_sub_epi16 ( stp1_5 , stp1_26 ) ;
in [ 27 ] = _mm_sub_epi16 ( stp1_4 , stp1_27 ) ;
in [ 28 ] = _mm_sub_epi16 ( stp1_3 , stp1_28 ) ;
in [ 29 ] = _mm_sub_epi16 ( stp1_2 , stp1_29 ) ;
in [ 30 ] = _mm_sub_epi16 ( stp1_1 , stp1_30 ) ;
in [ 31 ] = _mm_sub_epi16 ( stp1_0 , stp1_31 ) ;
in [ 0 ] = _mm_adds_epi16 ( in [ 0 ] , final_rounding ) ;
in [ 1 ] = _mm_adds_epi16 ( in [ 1 ] , final_rounding ) ;
in [ 2 ] = _mm_adds_epi16 ( in [ 2 ] , final_rounding ) ;
in [ 3 ] = _mm_adds_epi16 ( in [ 3 ] , final_rounding ) ;
in [ 4 ] = _mm_adds_epi16 ( in [ 4 ] , final_rounding ) ;
in [ 5 ] = _mm_adds_epi16 ( in [ 5 ] , final_rounding ) ;
in [ 6 ] = _mm_adds_epi16 ( in [ 6 ] , final_rounding ) ;
in [ 7 ] = _mm_adds_epi16 ( in [ 7 ] , final_rounding ) ;
in [ 8 ] = _mm_adds_epi16 ( in [ 8 ] , final_rounding ) ;
in [ 9 ] = _mm_adds_epi16 ( in [ 9 ] , final_rounding ) ;
in [ 10 ] = _mm_adds_epi16 ( in [ 10 ] , final_rounding ) ;
in [ 11 ] = _mm_adds_epi16 ( in [ 11 ] , final_rounding ) ;
in [ 12 ] = _mm_adds_epi16 ( in [ 12 ] , final_rounding ) ;
in [ 13 ] = _mm_adds_epi16 ( in [ 13 ] , final_rounding ) ;
in [ 14 ] = _mm_adds_epi16 ( in [ 14 ] , final_rounding ) ;
in [ 15 ] = _mm_adds_epi16 ( in [ 15 ] , final_rounding ) ;
in [ 16 ] = _mm_adds_epi16 ( in [ 16 ] , final_rounding ) ;
in [ 17 ] = _mm_adds_epi16 ( in [ 17 ] , final_rounding ) ;
in [ 18 ] = _mm_adds_epi16 ( in [ 18 ] , final_rounding ) ;
in [ 19 ] = _mm_adds_epi16 ( in [ 19 ] , final_rounding ) ;
in [ 20 ] = _mm_adds_epi16 ( in [ 20 ] , final_rounding ) ;
in [ 21 ] = _mm_adds_epi16 ( in [ 21 ] , final_rounding ) ;
in [ 22 ] = _mm_adds_epi16 ( in [ 22 ] , final_rounding ) ;
in [ 23 ] = _mm_adds_epi16 ( in [ 23 ] , final_rounding ) ;
in [ 24 ] = _mm_adds_epi16 ( in [ 24 ] , final_rounding ) ;
in [ 25 ] = _mm_adds_epi16 ( in [ 25 ] , final_rounding ) ;
in [ 26 ] = _mm_adds_epi16 ( in [ 26 ] , final_rounding ) ;
in [ 27 ] = _mm_adds_epi16 ( in [ 27 ] , final_rounding ) ;
in [ 28 ] = _mm_adds_epi16 ( in [ 28 ] , final_rounding ) ;
in [ 29 ] = _mm_adds_epi16 ( in [ 29 ] , final_rounding ) ;
in [ 30 ] = _mm_adds_epi16 ( in [ 30 ] , final_rounding ) ;
in [ 31 ] = _mm_adds_epi16 ( in [ 31 ] , final_rounding ) ;
in [ 0 ] = _mm_srai_epi16 ( in [ 0 ] , 6 ) ;
in [ 1 ] = _mm_srai_epi16 ( in [ 1 ] , 6 ) ;
in [ 2 ] = _mm_srai_epi16 ( in [ 2 ] , 6 ) ;
in [ 3 ] = _mm_srai_epi16 ( in [ 3 ] , 6 ) ;
in [ 4 ] = _mm_srai_epi16 ( in [ 4 ] , 6 ) ;
in [ 5 ] = _mm_srai_epi16 ( in [ 5 ] , 6 ) ;
in [ 6 ] = _mm_srai_epi16 ( in [ 6 ] , 6 ) ;
in [ 7 ] = _mm_srai_epi16 ( in [ 7 ] , 6 ) ;
in [ 8 ] = _mm_srai_epi16 ( in [ 8 ] , 6 ) ;
in [ 9 ] = _mm_srai_epi16 ( in [ 9 ] , 6 ) ;
in [ 10 ] = _mm_srai_epi16 ( in [ 10 ] , 6 ) ;
in [ 11 ] = _mm_srai_epi16 ( in [ 11 ] , 6 ) ;
in [ 12 ] = _mm_srai_epi16 ( in [ 12 ] , 6 ) ;
in [ 13 ] = _mm_srai_epi16 ( in [ 13 ] , 6 ) ;
in [ 14 ] = _mm_srai_epi16 ( in [ 14 ] , 6 ) ;
in [ 15 ] = _mm_srai_epi16 ( in [ 15 ] , 6 ) ;
in [ 16 ] = _mm_srai_epi16 ( in [ 16 ] , 6 ) ;
in [ 17 ] = _mm_srai_epi16 ( in [ 17 ] , 6 ) ;
in [ 18 ] = _mm_srai_epi16 ( in [ 18 ] , 6 ) ;
in [ 19 ] = _mm_srai_epi16 ( in [ 19 ] , 6 ) ;
in [ 20 ] = _mm_srai_epi16 ( in [ 20 ] , 6 ) ;
in [ 21 ] = _mm_srai_epi16 ( in [ 21 ] , 6 ) ;
in [ 22 ] = _mm_srai_epi16 ( in [ 22 ] , 6 ) ;
in [ 23 ] = _mm_srai_epi16 ( in [ 23 ] , 6 ) ;
in [ 24 ] = _mm_srai_epi16 ( in [ 24 ] , 6 ) ;
in [ 25 ] = _mm_srai_epi16 ( in [ 25 ] , 6 ) ;
in [ 26 ] = _mm_srai_epi16 ( in [ 26 ] , 6 ) ;
in [ 27 ] = _mm_srai_epi16 ( in [ 27 ] , 6 ) ;
in [ 28 ] = _mm_srai_epi16 ( in [ 28 ] , 6 ) ;
in [ 29 ] = _mm_srai_epi16 ( in [ 29 ] , 6 ) ;
in [ 30 ] = _mm_srai_epi16 ( in [ 30 ] , 6 ) ;
in [ 31 ] = _mm_srai_epi16 ( in [ 31 ] , 6 ) ;
RECON_AND_STORE ( dest , in [ 0 ] ) ;
RECON_AND_STORE ( dest , in [ 1 ] ) ;
RECON_AND_STORE ( dest , in [ 2 ] ) ;
RECON_AND_STORE ( dest , in [ 3 ] ) ;
RECON_AND_STORE ( dest , in [ 4 ] ) ;
RECON_AND_STORE ( dest , in [ 5 ] ) ;
RECON_AND_STORE ( dest , in [ 6 ] ) ;
RECON_AND_STORE ( dest , in [ 7 ] ) ;
RECON_AND_STORE ( dest , in [ 8 ] ) ;
RECON_AND_STORE ( dest , in [ 9 ] ) ;
RECON_AND_STORE ( dest , in [ 10 ] ) ;
RECON_AND_STORE ( dest , in [ 11 ] ) ;
RECON_AND_STORE ( dest , in [ 12 ] ) ;
RECON_AND_STORE ( dest , in [ 13 ] ) ;
RECON_AND_STORE ( dest , in [ 14 ] ) ;
RECON_AND_STORE ( dest , in [ 15 ] ) ;
RECON_AND_STORE ( dest , in [ 16 ] ) ;
RECON_AND_STORE ( dest , in [ 17 ] ) ;
RECON_AND_STORE ( dest , in [ 18 ] ) ;
RECON_AND_STORE ( dest , in [ 19 ] ) ;
RECON_AND_STORE ( dest , in [ 20 ] ) ;
RECON_AND_STORE ( dest , in [ 21 ] ) ;
RECON_AND_STORE ( dest , in [ 22 ] ) ;
RECON_AND_STORE ( dest , in [ 23 ] ) ;
RECON_AND_STORE ( dest , in [ 24 ] ) ;
RECON_AND_STORE ( dest , in [ 25 ] ) ;
RECON_AND_STORE ( dest , in [ 26 ] ) ;
RECON_AND_STORE ( dest , in [ 27 ] ) ;
RECON_AND_STORE ( dest , in [ 28 ] ) ;
RECON_AND_STORE ( dest , in [ 29 ] ) ;
RECON_AND_STORE ( dest , in [ 30 ] ) ;
RECON_AND_STORE ( dest , in [ 31 ] ) ;
dest += 8 - ( stride * 32 ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static unsigned long get_pfxmatch ( char * * s , struct masks * m ) {
while ( m -> name ) {
if ( strncmp ( * s , m -> name , strlen ( m -> name ) ) == 0 ) {
* s += strlen ( m -> name ) ;
return m -> mask ;
}
else {
m ++ ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bug10794 ( ) {
MYSQL_STMT * stmt , * stmt1 ;
MYSQL_BIND my_bind [ 2 ] ;
char a [ 21 ] ;
int id_val ;
ulong a_len ;
int rc ;
const char * stmt_text ;
int i = 0 ;
ulong type ;
myheader ( "test_bug10794" ) ;
mysql_query ( mysql , "drop table if exists t1" ) ;
mysql_query ( mysql , "create table t1 (id integer not null primary key," "name varchar(20) not null)" ) ;
stmt = mysql_stmt_init ( mysql ) ;
stmt_text = "insert into t1 (id, name) values (?, ?)" ;
rc = mysql_stmt_prepare ( stmt , stmt_text , strlen ( stmt_text ) ) ;
check_execute ( stmt , rc ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_LONG ;
my_bind [ 0 ] . buffer = ( void * ) & id_val ;
my_bind [ 1 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 1 ] . buffer = ( void * ) a ;
my_bind [ 1 ] . length = & a_len ;
rc = mysql_stmt_bind_param ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
for ( i = 0 ;
i < 42 ;
i ++ ) {
id_val = ( i + 1 ) * 10 ;
sprintf ( a , "a%d" , i ) ;
a_len = strlen ( a ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
}
stmt_text = "select name from t1" ;
rc = mysql_stmt_prepare ( stmt , stmt_text , strlen ( stmt_text ) ) ;
type = ( ulong ) CURSOR_TYPE_READ_ONLY ;
mysql_stmt_attr_set ( stmt , STMT_ATTR_CURSOR_TYPE , ( const void * ) & type ) ;
stmt1 = mysql_stmt_init ( mysql ) ;
mysql_stmt_attr_set ( stmt1 , STMT_ATTR_CURSOR_TYPE , ( const void * ) & type ) ;
memset ( my_bind , 0 , sizeof ( my_bind ) ) ;
my_bind [ 0 ] . buffer_type = MYSQL_TYPE_STRING ;
my_bind [ 0 ] . buffer = ( void * ) a ;
my_bind [ 0 ] . buffer_length = sizeof ( a ) ;
my_bind [ 0 ] . length = & a_len ;
rc = mysql_stmt_bind_result ( stmt , my_bind ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = mysql_stmt_fetch ( stmt ) ;
check_execute ( stmt , rc ) ;
if ( ! opt_silent ) printf ( "Fetched row from stmt: %s\n" , a ) ;
mysql_stmt_free_result ( stmt ) ;
mysql_stmt_reset ( stmt ) ;
stmt_text = "select name from t1 where id=10" ;
rc = mysql_stmt_prepare ( stmt1 , stmt_text , strlen ( stmt_text ) ) ;
check_execute ( stmt1 , rc ) ;
rc = mysql_stmt_bind_result ( stmt1 , my_bind ) ;
check_execute ( stmt1 , rc ) ;
rc = mysql_stmt_execute ( stmt1 ) ;
while ( 1 ) {
rc = mysql_stmt_fetch ( stmt1 ) ;
if ( rc == MYSQL_NO_DATA ) {
if ( ! opt_silent ) printf ( "End of data in stmt1\n" ) ;
break ;
}
check_execute ( stmt1 , rc ) ;
if ( ! opt_silent ) printf ( "Fetched row from stmt1: %s\n" , a ) ;
}
mysql_stmt_close ( stmt ) ;
mysql_stmt_close ( stmt1 ) ;
rc = mysql_query ( mysql , "drop table t1" ) ;
myquery ( rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void write_partition ( const VP9_COMMON * const cm , const MACROBLOCKD * const xd , int hbs , int mi_row , int mi_col , PARTITION_TYPE p , BLOCK_SIZE bsize , vp9_writer * w ) {
const int ctx = partition_plane_context ( xd , mi_row , mi_col , bsize ) ;
const vp9_prob * const probs = get_partition_probs ( cm , ctx ) ;
const int has_rows = ( mi_row + hbs ) < cm -> mi_rows ;
const int has_cols = ( mi_col + hbs ) < cm -> mi_cols ;
if ( has_rows && has_cols ) {
vp9_write_token ( w , vp9_partition_tree , probs , & partition_encodings [ p ] ) ;
}
else if ( ! has_rows && has_cols ) {
assert ( p == PARTITION_SPLIT || p == PARTITION_HORZ ) ;
vp9_write ( w , p == PARTITION_SPLIT , probs [ 1 ] ) ;
}
else if ( has_rows && ! has_cols ) {
assert ( p == PARTITION_SPLIT || p == PARTITION_VERT ) ;
vp9_write ( w , p == PARTITION_SPLIT , probs [ 2 ] ) ;
}
else {
assert ( p == PARTITION_SPLIT ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int mem_close ( jas_stream_obj_t * obj ) {
jas_stream_memobj_t * m = ( jas_stream_memobj_t * ) obj ;
if ( m -> myalloc_ && m -> buf_ ) {
jas_free ( m -> buf_ ) ;
m -> buf_ = 0 ;
}
jas_free ( obj ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * qio_channel_websock_find_header ( QIOChannelWebsockHTTPHeader * hdrs , size_t nhdrs , const char * name ) {
size_t i ;
for ( i = 0 ;
i < nhdrs ;
i ++ ) {
if ( g_str_equal ( hdrs [ i ] . name , name ) ) {
return hdrs [ i ] . value ;
}
}
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void config_setvar ( config_tree * ptree ) {
setvar_node * my_node ;
size_t varlen , vallen , octets ;
char * str ;
str = NULL ;
my_node = HEAD_PFIFO ( ptree -> setvar ) ;
for ( ;
my_node != NULL ;
my_node = my_node -> link ) {
varlen = strlen ( my_node -> var ) ;
vallen = strlen ( my_node -> val ) ;
octets = varlen + vallen + 1 + 1 ;
str = erealloc ( str , octets ) ;
snprintf ( str , octets , "%s=%s" , my_node -> var , my_node -> val ) ;
set_sys_var ( str , octets , ( my_node -> isdefault ) ? DEF : 0 ) ;
}
if ( str != NULL ) free ( str ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
inline static void _slurm_rpc_kill_job ( slurm_msg_t * msg ) {
static int active_rpc_cnt = 0 ;
DEF_TIMERS ;
job_step_kill_msg_t * kill ;
slurmctld_lock_t fed_job_read_lock = {
NO_LOCK , READ_LOCK , NO_LOCK , NO_LOCK , READ_LOCK }
;
slurmctld_lock_t lock = {
READ_LOCK , WRITE_LOCK , WRITE_LOCK , NO_LOCK , READ_LOCK }
;
uid_t uid ;
int cc ;
kill = ( job_step_kill_msg_t * ) msg -> data ;
uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
lock_slurmctld ( fed_job_read_lock ) ;
if ( fed_mgr_fed_rec ) {
uint32_t job_id , origin_id ;
struct job_record * job_ptr ;
slurmdb_cluster_rec_t * origin ;
job_id = strtol ( kill -> sjob_id , NULL , 10 ) ;
origin_id = fed_mgr_get_cluster_id ( job_id ) ;
origin = fed_mgr_get_cluster_by_id ( origin_id ) ;
if ( origin && origin -> fed . send && ( ( ( slurm_persist_conn_t * ) origin -> fed . send ) -> fd != - 1 ) && ( origin != fed_mgr_cluster_rec ) && ( ! ( job_ptr = find_job_record ( job_id ) ) || ( job_ptr && job_ptr -> fed_details && ( job_ptr -> fed_details -> cluster_lock != fed_mgr_cluster_rec -> fed . id ) ) ) ) {
slurmdb_cluster_rec_t * dst = fed_mgr_get_cluster_by_id ( origin_id ) ;
if ( ! dst ) {
error ( "couldn't find cluster by cluster id %d" , origin_id ) ;
slurm_send_rc_msg ( msg , SLURM_ERROR ) ;
}
else {
slurm_send_reroute_msg ( msg , dst ) ;
info ( "%s: REQUEST_KILL_JOB job %s uid %d routed to %s" , __func__ , kill -> sjob_id , uid , dst -> name ) ;
}
unlock_slurmctld ( fed_job_read_lock ) ;
return ;
}
}
unlock_slurmctld ( fed_job_read_lock ) ;
START_TIMER ;
info ( "%s: REQUEST_KILL_JOB job %s uid %d" , __func__ , kill -> sjob_id , uid ) ;
_throttle_start ( & active_rpc_cnt ) ;
lock_slurmctld ( lock ) ;
if ( kill -> sibling ) {
uint32_t job_id = strtol ( kill -> sjob_id , NULL , 10 ) ;
cc = fed_mgr_remove_active_sibling ( job_id , kill -> sibling ) ;
}
else {
cc = job_str_signal ( kill -> sjob_id , kill -> signal , kill -> flags , uid , 0 ) ;
}
unlock_slurmctld ( lock ) ;
_throttle_fini ( & active_rpc_cnt ) ;
if ( cc == ESLURM_ALREADY_DONE ) {
debug2 ( "%s: job_str_signal() job %s sig %d returned %s" , __func__ , kill -> sjob_id , kill -> signal , slurm_strerror ( cc ) ) ;
}
else if ( cc != SLURM_SUCCESS ) {
info ( "%s: job_str_signal() job %s sig %d returned %s" , __func__ , kill -> sjob_id , kill -> signal , slurm_strerror ( cc ) ) ;
}
else {
slurmctld_diag_stats . jobs_canceled ++ ;
}
slurm_send_rc_msg ( msg , cc ) ;
END_TIMER2 ( "_slurm_rpc_kill_job" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_run_MP ( fz_context * ctx , pdf_processor * proc , const char * tag ) {
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_numberOfRetransmissions ( 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_T_numberOfRetransmissions , T_numberOfRetransmissions_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool equality_ops_are_compatible ( Oid opno1 , Oid opno2 ) {
bool result ;
CatCList * catlist ;
int i ;
if ( opno1 == opno2 ) return true ;
catlist = SearchSysCacheList1 ( AMOPOPID , ObjectIdGetDatum ( opno1 ) ) ;
result = false ;
for ( i = 0 ;
i < catlist -> n_members ;
i ++ ) {
HeapTuple op_tuple = & catlist -> members [ i ] -> tuple ;
Form_pg_amop op_form = ( Form_pg_amop ) GETSTRUCT ( op_tuple ) ;
if ( op_form -> amopmethod == BTREE_AM_OID || op_form -> amopmethod == HASH_AM_OID ) {
if ( op_in_opfamily ( opno2 , op_form -> amopfamily ) ) {
result = true ;
break ;
}
}
}
ReleaseSysCacheList ( catlist ) ;
return result ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void PNGAPI png_set_gAMA_fixed ( png_structp png_ptr , png_infop info_ptr , png_fixed_point int_gamma ) {
png_fixed_point png_gamma ;
png_debug1 ( 1 , "in %s storage function" , "gAMA" ) ;
if ( png_ptr == NULL || info_ptr == NULL ) return ;
if ( int_gamma > ( png_fixed_point ) PNG_UINT_31_MAX ) {
png_warning ( png_ptr , "Limiting gamma to 21474.83" ) ;
png_gamma = PNG_UINT_31_MAX ;
}
else {
if ( int_gamma < 0 ) {
png_warning ( png_ptr , "Setting negative gamma to zero" ) ;
png_gamma = 0 ;
}
else png_gamma = int_gamma ;
}
# ifdef PNG_FLOATING_POINT_SUPPORTED info_ptr -> gamma = ( float ) ( png_gamma / 100000. ) ;
# endif # ifdef PNG_FIXED_POINT_SUPPORTED info_ptr -> int_gamma = png_gamma ;
# endif info_ptr -> valid |= PNG_INFO_gAMA ;
if ( png_gamma == 0 ) png_warning ( png_ptr , "Setting gamma=0" ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.