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
|
TSReturnCode TSUrlPathSet ( TSMBuffer bufp , TSMLoc obj , const char * value , int length ) {
return URLPartSet ( bufp , obj , value , length , & URL : : path_set ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_coap_opt_uint ( tvbuff_t * tvb , proto_item * head_item , proto_tree * subtree , gint offset , gint opt_length , int hf ) {
guint i = 0 ;
if ( opt_length != 0 ) {
i = coap_get_opt_uint ( tvb , offset , opt_length ) ;
}
proto_tree_add_uint ( subtree , hf , tvb , offset , opt_length , i ) ;
proto_item_append_text ( head_item , ": %u" , i ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _moveBefore ( ArchiveHandle * AH , TocEntry * pos , TocEntry * te ) {
te -> prev -> next = te -> next ;
te -> next -> prev = te -> prev ;
te -> prev = pos -> prev ;
te -> next = pos ;
pos -> prev -> next = te ;
pos -> prev = te ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( AppApiTest , ClientRedirectToAppFromExtension ) {
LoadExtension ( test_data_dir_ . AppendASCII ( "app_process" ) ) ;
const Extension * launcher = LoadExtension ( test_data_dir_ . AppendASCII ( "app_launcher" ) ) ;
content : : TestNavigationObserver test_navigation_observer ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , 3 ) ;
test_navigation_observer . StartWatchingNewWebContents ( ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , launcher -> GetResourceURL ( "client_redirect.html" ) ) ;
test_navigation_observer . Wait ( ) ;
bool is_installed = false ;
ASSERT_TRUE ( content : : ExecuteScriptAndExtractBool ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , "window.domAutomationController.send(chrome.app.isInstalled)" , & is_installed ) ) ;
ASSERT_TRUE ( is_installed ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
char get_rel_relkind ( Oid relid ) {
HeapTuple tp ;
tp = SearchSysCache1 ( RELOID , ObjectIdGetDatum ( relid ) ) ;
if ( HeapTupleIsValid ( tp ) ) {
Form_pg_class reltup = ( Form_pg_class ) GETSTRUCT ( tp ) ;
char result ;
result = reltup -> relkind ;
ReleaseSysCache ( tp ) ;
return result ;
}
else return '\0' ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static struct cgroup_hierarchy * lxc_cgroup_find_hierarchy ( struct cgroup_meta_data * meta_data , const char * subsystem ) {
size_t i ;
for ( i = 0 ;
i <= meta_data -> maximum_hierarchy ;
i ++ ) {
struct cgroup_hierarchy * h = meta_data -> hierarchies [ i ] ;
if ( h && lxc_string_in_array ( subsystem , ( const char * * ) h -> subsystems ) ) return h ;
}
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int32_t u_printf_pointer_handler ( const u_printf_stream_handler * handler , void * context , ULocaleBundle * formatBundle , const u_printf_spec_info * info , const ufmt_args * args ) {
( void ) formatBundle ;
UChar result [ UPRINTF_BUFFER_SIZE ] ;
int32_t len = UPRINTF_BUFFER_SIZE ;
ufmt_ptou ( result , & len , args [ 0 ] . ptrValue , TRUE ) ;
return handler -> pad_and_justify ( context , info , result , len ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static hb_ ## name ## _t * _hb_ ## name ## _reference ( const hb_ ## name ## _t * l ) {
hb_ ## name ## _t * c = ( hb_ ## name ## _t * ) calloc ( 1 , sizeof ( hb_ ## name ## _t ) ) ;
if ( unlikely ( ! c ) ) return NULL ;
* c = * l ;
return c ;
}
static void _hb_ ## name ## _destroy ( hb_ ## name ## _t * l ) {
free ( l ) ;
}
HB_DEFINE_BOXED_TYPE ( name , _hb_ ## name ## _reference , _hb_ ## name ## _destroy ) ;
HB_DEFINE_OBJECT_TYPE ( buffer ) HB_DEFINE_OBJECT_TYPE ( blob ) HB_DEFINE_OBJECT_TYPE ( face ) HB_DEFINE_OBJECT_TYPE ( font ) HB_DEFINE_OBJECT_TYPE ( font_funcs ) HB_DEFINE_OBJECT_TYPE ( set ) HB_DEFINE_OBJECT_TYPE ( shape_plan ) HB_DEFINE_OBJECT_TYPE ( unicode_funcs ) HB_DEFINE_VALUE_TYPE ( feature ) HB_DEFINE_VALUE_TYPE ( glyph_info ) HB_DEFINE_VALUE_TYPE ( glyph_position )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void decode_power_conf_batt_AHr ( gchar * s , guint32 value ) {
g_snprintf ( s , ITEM_LABEL_LENGTH , "%d [mAHr]" , value * 10 ) ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_DisplayName ( 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_DisplayName , DisplayName_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static pid_t name2pid ( char * name ) {
pid_t pid = - 1 ;
int lokke ;
int num_procs = 0 ;
struct das_proclist * proclist = get_proclist ( & num_procs ) ;
for ( lokke = 0 ;
lokke < num_procs ;
lokke ++ ) {
glibtop_proc_state state ;
glibtop_get_proc_state ( & state , proclist [ lokke ] . pid ) ;
if ( ! strcmp ( state . cmd , name ) ) {
pid = proclist [ lokke ] . pid ;
break ;
}
}
free ( proclist ) ;
return pid ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_TBCD_STRING ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 912 "./asn1/h225/h225.cnf" int min_len , max_len ;
gboolean has_extension ;
get_size_constraint_from_stack ( actx , "TBCD_STRING" , & min_len , & max_len , & has_extension ) ;
offset = dissect_per_restricted_character_string ( tvb , offset , actx , tree , hf_index , min_len , max_len , has_extension , "0123456789#*abc" , 15 , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ssl_choose_client_version ( SSL * s , int version ) {
const version_info * vent ;
const version_info * table ;
switch ( s -> method -> version ) {
default : if ( version != s -> version ) return SSL_R_WRONG_SSL_VERSION ;
return 0 ;
case TLS_ANY_VERSION : table = tls_version_table ;
break ;
case DTLS_ANY_VERSION : table = dtls_version_table ;
break ;
}
for ( vent = table ;
vent -> version != 0 ;
++ vent ) {
const SSL_METHOD * method ;
int err ;
if ( version != vent -> version ) continue ;
if ( vent -> cmeth == NULL ) break ;
method = vent -> cmeth ( ) ;
err = ssl_method_error ( s , method ) ;
if ( err != 0 ) return err ;
s -> method = method ;
s -> version = version ;
return 0 ;
}
return SSL_R_UNSUPPORTED_PROTOCOL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pdf_run_i ( fz_context * ctx , pdf_processor * proc , float flatness ) {
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static gid_t add_supp_group ( const char * name , gid_t * * groups , size_t * ngroups ) {
struct group * gr ;
if ( * ngroups >= NGROUPS_MAX ) errx ( EXIT_FAILURE , P_ ( "specifying more than %d supplemental group is not possible" , "specifying more than %d supplemental groups is not possible" , NGROUPS_MAX - 1 ) , NGROUPS_MAX - 1 ) ;
gr = getgrnam ( name ) ;
if ( ! gr ) errx ( EXIT_FAILURE , _ ( "group %s does not exist" ) , name ) ;
* groups = xrealloc ( * groups , sizeof ( gid_t ) * ( * ngroups + 1 ) ) ;
( * groups ) [ * ngroups ] = gr -> gr_gid ;
( * ngroups ) ++ ;
return gr -> gr_gid ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void do_vm_stop ( RunState state ) {
if ( runstate_is_running ( ) ) {
cpu_disable_ticks ( ) ;
pause_all_vcpus ( ) ;
runstate_set ( state ) ;
vm_state_notify ( 0 , state ) ;
bdrv_drain_all ( ) ;
bdrv_flush_all ( ) ;
monitor_protocol_event ( QEVENT_STOP , NULL ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( WebFrameSimTest , TickmarksDocumentRelative ) {
WebView ( ) . Resize ( WebSize ( 500 , 300 ) ) ;
WebView ( ) . GetPage ( ) -> GetSettings ( ) . SetTextAutosizingEnabled ( false ) ;
SimRequest request ( "https://example.com/test.html" , "text/html" ) ;
LoadURL ( "https://example.com/test.html" ) ;
request . Complete ( R "HTML( < ! DOCTYPE html > < style > body , html {
width : 4000px ;
height : 4000px ;
margin : 0 ;
}
div {
position : absolute ;
left : 800px ;
top : 2000px ;
}
< / style > < div > test < / div > ) HTML ");
Compositor ( ) . BeginFrame ( ) ;
WebLocalFrameImpl * frame = ToWebLocalFrameImpl ( WebView ( ) . MainFrame ( ) ) ;
LocalFrameView * frame_view = ToLocalFrame ( WebView ( ) . GetPage ( ) -> MainFrame ( ) ) -> View ( ) ;
frame_view -> GetScrollableArea ( ) -> SetScrollOffset ( ScrollOffset ( 3000 , 1000 ) , kProgrammaticScroll ) ;
WebFindOptions options ;
WebString search_text = WebString : : FromUTF8 ( "test" ) ;
const int kFindIdentifier = 12345 ;
EXPECT_TRUE ( frame -> Find ( kFindIdentifier , search_text , options , false ) ) ;
frame -> EnsureTextFinder ( ) . ResetMatchCount ( ) ;
frame -> EnsureTextFinder ( ) . StartScopingStringMatches ( kFindIdentifier , search_text , options ) ;
RunPendingTasks ( ) ;
Vector < IntRect > original_tickmarks ;
frame_view -> LayoutViewport ( ) -> GetTickmarks ( original_tickmarks ) ;
EXPECT_EQ ( 1u , original_tickmarks . size ( ) ) ;
EXPECT_EQ ( IntPoint ( 800 , 2000 ) , original_tickmarks [ 0 ] . Location ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( SoundContentSettingObserverTest , MuteByDefaultAndExceptionRecordsException ) {
ChangeSoundContentSettingTo ( CONTENT_SETTING_BLOCK ) ;
ChangeDefaultSoundContentSettingTo ( CONTENT_SETTING_BLOCK ) ;
SimulateAudioStarting ( ) ;
EXPECT_TRUE ( RecordedSiteMuted ( ) ) ;
ExpectRecordedForReason ( SoundContentSettingObserver : : MuteReason : : kSiteException ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int evdns_resolve_reverse_ipv6 ( const struct in6_addr * in , int flags , evdns_callback_type callback , void * ptr ) {
char buf [ 73 ] ;
char * cp ;
struct request * req ;
int i ;
assert ( in ) ;
cp = buf ;
for ( i = 15 ;
i >= 0 ;
-- i ) {
u8 byte = in -> s6_addr [ i ] ;
* cp ++ = "0123456789abcdef" [ byte & 0x0f ] ;
* cp ++ = '.' ;
* cp ++ = "0123456789abcdef" [ byte >> 4 ] ;
* cp ++ = '.' ;
}
assert ( cp + strlen ( "ip6.arpa" ) < buf + sizeof ( buf ) ) ;
memcpy ( cp , "ip6.arpa" , strlen ( "ip6.arpa" ) + 1 ) ;
log ( EVDNS_LOG_DEBUG , "Resolve requested for %s (reverse)" , buf ) ;
req = request_new ( TYPE_PTR , buf , flags , callback , ptr ) ;
if ( ! req ) return 1 ;
request_submit ( req ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int set_str_utf16be ( struct archive_write * a , unsigned char * p , const char * s , size_t l , uint16_t uf , enum vdc vdc ) {
size_t size , i ;
int onepad ;
if ( s == NULL ) s = "" ;
if ( l & 0x01 ) {
onepad = 1 ;
l &= ~ 1 ;
}
else onepad = 0 ;
if ( vdc == VDC_UCS2 ) {
struct iso9660 * iso9660 = a -> format_data ;
if ( archive_strncpy_l ( & iso9660 -> utf16be , s , strlen ( s ) , iso9660 -> sconv_to_utf16be ) != 0 && errno == ENOMEM ) {
archive_set_error ( & a -> archive , ENOMEM , "Can't allocate memory for UTF-16BE" ) ;
return ( ARCHIVE_FATAL ) ;
}
size = iso9660 -> utf16be . length ;
if ( size > l ) size = l ;
memcpy ( p , iso9660 -> utf16be . s , size ) ;
}
else {
const uint16_t * u16 = ( const uint16_t * ) s ;
size = 0 ;
while ( * u16 ++ ) size += 2 ;
if ( size > l ) size = l ;
memcpy ( p , s , size ) ;
}
for ( i = 0 ;
i < size ;
i += 2 , p += 2 ) {
if ( ! joliet_allowed_char ( p [ 0 ] , p [ 1 ] ) ) archive_be16enc ( p , 0x005F ) ;
}
l -= size ;
while ( l > 0 ) {
archive_be16enc ( p , uf ) ;
p += 2 ;
l -= 2 ;
}
if ( onepad ) * p = 0 ;
return ( ARCHIVE_OK ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void init_util ( void ) {
filegen_register ( statsdir , "peerstats" , & peerstats ) ;
filegen_register ( statsdir , "loopstats" , & loopstats ) ;
filegen_register ( statsdir , "clockstats" , & clockstats ) ;
filegen_register ( statsdir , "rawstats" , & rawstats ) ;
filegen_register ( statsdir , "sysstats" , & sysstats ) ;
filegen_register ( statsdir , "protostats" , & protostats ) ;
filegen_register ( statsdir , "cryptostats" , & cryptostats ) ;
filegen_register ( statsdir , "timingstats" , & timingstats ) ;
step_callback = & ntpd_time_stepped ;
# ifdef DEBUG atexit ( & uninit_util ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int X509_verify ( X509 * a , EVP_PKEY * r ) {
if ( X509_ALGOR_cmp ( a -> sig_alg , a -> cert_info -> signature ) ) return 0 ;
return ( ASN1_item_verify ( ASN1_ITEM_rptr ( X509_CINF ) , a -> sig_alg , a -> signature , a -> cert_info , r ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static hb_user_data_key_t user_data_key_reference ( hb_user_data_key_t l ) {
return l ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int y4m_input_fetch_frame ( y4m_input * _y4m , FILE * _fin , vpx_image_t * _img ) {
char frame [ 6 ] ;
int pic_sz ;
int c_w ;
int c_h ;
int c_sz ;
int bytes_per_sample = _y4m -> bit_depth > 8 ? 2 : 1 ;
if ( ! file_read ( frame , 6 , _fin ) ) return 0 ;
if ( memcmp ( frame , "FRAME" , 5 ) ) {
fprintf ( stderr , "Loss of framing in Y4M input data\n" ) ;
return - 1 ;
}
if ( frame [ 5 ] != '\n' ) {
char c ;
int j ;
for ( j = 0 ;
j < 79 && file_read ( & c , 1 , _fin ) && c != '\n' ;
j ++ ) {
}
if ( j == 79 ) {
fprintf ( stderr , "Error parsing Y4M frame header\n" ) ;
return - 1 ;
}
}
if ( ! file_read ( _y4m -> dst_buf , _y4m -> dst_buf_read_sz , _fin ) ) {
fprintf ( stderr , "Error reading Y4M frame data.\n" ) ;
return - 1 ;
}
if ( ! file_read ( _y4m -> aux_buf , _y4m -> aux_buf_read_sz , _fin ) ) {
fprintf ( stderr , "Error reading Y4M frame data.\n" ) ;
return - 1 ;
}
( * _y4m -> convert ) ( _y4m , _y4m -> dst_buf , _y4m -> aux_buf ) ;
memset ( _img , 0 , sizeof ( * _img ) ) ;
_img -> fmt = _y4m -> vpx_fmt ;
_img -> w = _img -> d_w = _y4m -> pic_w ;
_img -> h = _img -> d_h = _y4m -> pic_h ;
_img -> x_chroma_shift = _y4m -> dst_c_dec_h >> 1 ;
_img -> y_chroma_shift = _y4m -> dst_c_dec_v >> 1 ;
_img -> bps = _y4m -> bps ;
pic_sz = _y4m -> pic_w * _y4m -> pic_h * bytes_per_sample ;
c_w = ( _y4m -> pic_w + _y4m -> dst_c_dec_h - 1 ) / _y4m -> dst_c_dec_h ;
c_w *= bytes_per_sample ;
c_h = ( _y4m -> pic_h + _y4m -> dst_c_dec_v - 1 ) / _y4m -> dst_c_dec_v ;
c_sz = c_w * c_h ;
_img -> stride [ VPX_PLANE_Y ] = _img -> stride [ VPX_PLANE_ALPHA ] = _y4m -> pic_w * bytes_per_sample ;
_img -> stride [ VPX_PLANE_U ] = _img -> stride [ VPX_PLANE_V ] = c_w ;
_img -> planes [ VPX_PLANE_Y ] = _y4m -> dst_buf ;
_img -> planes [ VPX_PLANE_U ] = _y4m -> dst_buf + pic_sz ;
_img -> planes [ VPX_PLANE_V ] = _y4m -> dst_buf + pic_sz + c_sz ;
_img -> planes [ VPX_PLANE_ALPHA ] = _y4m -> dst_buf + pic_sz + 2 * c_sz ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void qemuAgentClose ( qemuAgentPtr mon ) {
if ( ! mon ) return ;
VIR_DEBUG ( "mon=%p" , mon ) ;
virObjectLock ( mon ) ;
if ( mon -> fd >= 0 ) {
if ( mon -> watch ) virEventRemoveHandle ( mon -> watch ) ;
VIR_FORCE_CLOSE ( mon -> fd ) ;
}
qemuAgentNotifyCloseLocked ( mon ) ;
virObjectUnlock ( mon ) ;
virObjectUnref ( mon ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static double rfc1867_size ( tvbuff_t * tvb , int offset ) {
guint8 val ;
double size ;
guint32 exponent ;
val = tvb_get_guint8 ( tvb , offset ) ;
size = ( val & 0xF0 ) >> 4 ;
exponent = ( val & 0x0F ) ;
while ( exponent != 0 ) {
size *= 10 ;
exponent -- ;
}
return size / 100 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int SpoolssSetJob_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
offset = dissect_doserror ( tvb , offset , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void qio_channel_websock_handshake ( QIOChannelWebsock * ioc , QIOTaskFunc func , gpointer opaque , GDestroyNotify destroy ) {
QIOTask * task ;
task = qio_task_new ( OBJECT ( ioc ) , func , opaque , destroy ) ;
trace_qio_channel_websock_handshake_start ( ioc ) ;
trace_qio_channel_websock_handshake_pending ( ioc , G_IO_IN ) ;
qio_channel_add_watch ( ioc -> master , G_IO_IN , qio_channel_websock_handshake_io , task , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dtap_tp_test_interface ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) {
guint32 curr_offset ;
guint32 consumed ;
guint curr_len ;
curr_len = len ;
curr_offset = offset ;
ELEM_MAND_V ( GSM_A_PDU_TYPE_DTAP , DE_TP_TESTED_DEVICE , NULL ) ;
EXTRANEOUS_DATA_CHECK ( curr_len , 0 , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int aout_update_format ( decoder_t * p_dec ) {
decoder_owner_sys_t * p_owner = p_dec -> p_owner ;
if ( p_owner -> p_aout && ( ! AOUT_FMTS_IDENTICAL ( & p_dec -> fmt_out . audio , & p_owner -> audio ) || p_dec -> fmt_out . i_codec != p_dec -> fmt_out . audio . i_format ) ) {
audio_output_t * p_aout = p_owner -> p_aout ;
vlc_mutex_lock ( & p_owner -> lock ) ;
aout_DecDelete ( p_owner -> p_aout ) ;
p_owner -> p_aout = NULL ;
vlc_mutex_unlock ( & p_owner -> lock ) ;
input_resource_PutAout ( p_owner -> p_resource , p_aout ) ;
}
if ( p_owner -> p_aout == NULL ) {
const int i_force_dolby = var_InheritInteger ( p_dec , "force-dolby-surround" ) ;
audio_sample_format_t format ;
audio_output_t * p_aout ;
aout_request_vout_t request_vout ;
p_dec -> fmt_out . audio . i_format = p_dec -> fmt_out . i_codec ;
p_owner -> audio = p_dec -> fmt_out . audio ;
aout_FormatPrepare ( & p_owner -> audio ) ;
memcpy ( & format , & p_owner -> audio , sizeof ( audio_sample_format_t ) ) ;
if ( i_force_dolby && ( format . i_original_channels & AOUT_CHAN_PHYSMASK ) == ( AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT ) ) {
if ( i_force_dolby == 1 ) {
format . i_original_channels = format . i_original_channels | AOUT_CHAN_DOLBYSTEREO ;
}
else {
format . i_original_channels = format . i_original_channels & ~ AOUT_CHAN_DOLBYSTEREO ;
}
}
request_vout . pf_request_vout = aout_request_vout ;
request_vout . p_private = p_dec ;
assert ( p_owner -> p_aout == NULL ) ;
p_aout = input_resource_GetAout ( p_owner -> p_resource ) ;
if ( p_aout ) {
if ( aout_DecNew ( p_aout , & format , & p_dec -> fmt_out . audio_replay_gain , & request_vout ) ) {
input_resource_PutAout ( p_owner -> p_resource , p_aout ) ;
p_aout = NULL ;
}
}
vlc_mutex_lock ( & p_owner -> lock ) ;
p_owner -> p_aout = p_aout ;
DecoderUpdateFormatLocked ( p_dec ) ;
if ( unlikely ( p_owner -> b_paused ) && p_aout != NULL ) aout_DecChangePause ( p_aout , true , mdate ( ) ) ;
vlc_mutex_unlock ( & p_owner -> lock ) ;
if ( p_owner -> p_input != NULL ) input_SendEventAout ( p_owner -> p_input ) ;
if ( p_aout == NULL ) {
msg_Err ( p_dec , "failed to create audio output" ) ;
p_dec -> b_error = true ;
return - 1 ;
}
p_dec -> fmt_out . audio . i_bytes_per_frame = p_owner -> audio . i_bytes_per_frame ;
p_dec -> fmt_out . audio . i_frame_length = p_owner -> audio . i_frame_length ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int afx_init1 ( SysBusDevice * dev ) {
AFXState * s = FROM_SYSBUS ( AFXState , dev ) ;
memory_region_init_ram ( & s -> mem , OBJECT ( s ) , "sun4m.afx" , 4 ) ;
vmstate_register_ram_global ( & s -> mem ) ;
sysbus_init_mmio ( dev , & s -> mem ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_ResourcesAvailableConfirm ( 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_ResourcesAvailableConfirm , ResourcesAvailableConfirm_sequence ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void test_bug29687 ( ) {
const int NUM_ITERATIONS = 40 ;
int i ;
int rc ;
MYSQL_STMT * stmt = NULL ;
DBUG_ENTER ( "test_bug29687" ) ;
myheader ( "test_bug29687" ) ;
stmt = mysql_simple_prepare ( mysql , "SELECT 1 FROM dual WHERE 0=2" ) ;
DIE_UNLESS ( stmt ) ;
for ( i = 0 ;
i < NUM_ITERATIONS ;
i ++ ) {
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
mysql_stmt_store_result ( stmt ) ;
while ( mysql_stmt_fetch ( stmt ) == 0 ) ;
mysql_stmt_free_result ( stmt ) ;
}
mysql_stmt_close ( stmt ) ;
DBUG_VOID_RETURN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * Type_Data_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
cmsICCData * BinData ;
cmsUInt32Number LenOfData ;
* nItems = 0 ;
if ( SizeOfTag < sizeof ( cmsUInt32Number ) ) return NULL ;
LenOfData = SizeOfTag - sizeof ( cmsUInt32Number ) ;
if ( LenOfData > INT_MAX ) return NULL ;
BinData = ( cmsICCData * ) _cmsMalloc ( self -> ContextID , sizeof ( cmsICCData ) + LenOfData - 1 ) ;
if ( BinData == NULL ) return NULL ;
BinData -> len = LenOfData ;
if ( ! _cmsReadUInt32Number ( io , & BinData -> flag ) ) {
_cmsFree ( self -> ContextID , BinData ) ;
return NULL ;
}
if ( io -> Read ( io , BinData -> data , sizeof ( cmsUInt8Number ) , LenOfData ) != LenOfData ) {
_cmsFree ( self -> ContextID , BinData ) ;
return NULL ;
}
* nItems = 1 ;
return ( void * ) BinData ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mbfl_buffer_converter_feed ( mbfl_buffer_converter * convd , mbfl_string * string ) {
return mbfl_buffer_converter_feed2 ( convd , string , NULL ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_tilehdr ( WMAProDecodeCtx * s ) {
uint16_t num_samples [ WMAPRO_MAX_CHANNELS ] = {
0 }
;
uint8_t contains_subframe [ WMAPRO_MAX_CHANNELS ] ;
int channels_for_cur_subframe = s -> avctx -> channels ;
int fixed_channel_layout = 0 ;
int min_channel_len = 0 ;
int c ;
for ( c = 0 ;
c < s -> avctx -> channels ;
c ++ ) s -> channel [ c ] . num_subframes = 0 ;
if ( s -> max_num_subframes == 1 || get_bits1 ( & s -> gb ) ) fixed_channel_layout = 1 ;
do {
int subframe_len ;
for ( c = 0 ;
c < s -> avctx -> channels ;
c ++ ) {
if ( num_samples [ c ] == min_channel_len ) {
if ( fixed_channel_layout || channels_for_cur_subframe == 1 || ( min_channel_len == s -> samples_per_frame - s -> min_samples_per_subframe ) ) contains_subframe [ c ] = 1 ;
else contains_subframe [ c ] = get_bits1 ( & s -> gb ) ;
}
else contains_subframe [ c ] = 0 ;
}
if ( ( subframe_len = decode_subframe_length ( s , min_channel_len ) ) <= 0 ) return AVERROR_INVALIDDATA ;
min_channel_len += subframe_len ;
for ( c = 0 ;
c < s -> avctx -> channels ;
c ++ ) {
WMAProChannelCtx * chan = & s -> channel [ c ] ;
if ( contains_subframe [ c ] ) {
if ( chan -> num_subframes >= MAX_SUBFRAMES ) {
av_log ( s -> avctx , AV_LOG_ERROR , "broken frame: num subframes > 31\n" ) ;
return AVERROR_INVALIDDATA ;
}
chan -> subframe_len [ chan -> num_subframes ] = subframe_len ;
num_samples [ c ] += subframe_len ;
++ chan -> num_subframes ;
if ( num_samples [ c ] > s -> samples_per_frame ) {
av_log ( s -> avctx , AV_LOG_ERROR , "broken frame: " "channel len > samples_per_frame\n" ) ;
return AVERROR_INVALIDDATA ;
}
}
else if ( num_samples [ c ] <= min_channel_len ) {
if ( num_samples [ c ] < min_channel_len ) {
channels_for_cur_subframe = 0 ;
min_channel_len = num_samples [ c ] ;
}
++ channels_for_cur_subframe ;
}
}
}
while ( min_channel_len < s -> samples_per_frame ) ;
for ( c = 0 ;
c < s -> avctx -> channels ;
c ++ ) {
int i ;
int offset = 0 ;
for ( i = 0 ;
i < s -> channel [ c ] . num_subframes ;
i ++ ) {
av_dlog ( s -> avctx , "frame[%i] channel[%i] subframe[%i]" " len %i\n" , s -> frame_num , c , i , s -> channel [ c ] . subframe_len [ i ] ) ;
s -> channel [ c ] . subframe_offset [ i ] = offset ;
offset += s -> channel [ c ] . subframe_len [ i ] ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int arith2_get_prob ( ArithCoder * c , int16_t * probs ) {
int range = c -> high - c -> low + 1 , n = * probs ;
int scale = av_log2 ( range ) - av_log2 ( n ) ;
int i = 0 , val ;
if ( n << scale > range ) scale -- ;
n <<= scale ;
val = arith2_get_scaled_value ( c -> value - c -> low , n , range ) >> scale ;
while ( probs [ ++ i ] > val ) ;
arith2_rescale_interval ( c , range , probs [ i ] << scale , probs [ i - 1 ] << scale , n ) ;
return i ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int _route_msg_to_origin ( slurm_msg_t * msg , char * src_job_id_str , uint32_t src_job_id , uid_t uid ) {
xassert ( msg ) ;
if ( ! msg -> conn && fed_mgr_fed_rec ) {
uint32_t job_id , origin_id ;
if ( src_job_id_str ) job_id = strtol ( src_job_id_str , NULL , 10 ) ;
else job_id = src_job_id ;
origin_id = fed_mgr_get_cluster_id ( job_id ) ;
if ( origin_id && ( origin_id != 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: %s job %d uid %d routed to %s" , __func__ , rpc_num2string ( msg -> msg_type ) , job_id , uid , dst -> name ) ;
}
return SLURM_SUCCESS ;
}
}
return SLURM_ERROR ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int s_aos_flush ( stream * s ) {
s -> position = ( ( aos_state_t * ) s -> state ) -> file_sz ;
s -> srptr = s -> srlimit = s -> cbuf - 1 ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int32_t u_scanf_skip_leading_ws ( UFILE * input , UChar pad ) {
UChar c ;
int32_t count = 0 ;
UBool isNotEOF ;
while ( ( isNotEOF = ufile_getch ( input , & c ) ) && ( c == pad || u_isWhitespace ( c ) ) ) {
count ++ ;
}
if ( isNotEOF ) u_fungetc ( c , input ) ;
return count ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void set_result_format_version ( ulong new_version ) {
switch ( new_version ) {
case 1 : break ;
case 2 : break ;
default : die ( "Version format %lu has not yet been implemented" , new_version ) ;
break ;
}
opt_result_format_version = new_version ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp8_denoiser_set_parameters ( VP8_DENOISER * denoiser , int mode ) {
assert ( mode > 0 ) ;
if ( mode == 1 ) {
denoiser -> denoiser_mode = kDenoiserOnYOnly ;
}
else if ( mode == 2 ) {
denoiser -> denoiser_mode = kDenoiserOnYUV ;
}
else if ( mode == 3 ) {
denoiser -> denoiser_mode = kDenoiserOnYUVAggressive ;
}
else {
denoiser -> denoiser_mode = kDenoiserOnAdaptive ;
}
if ( denoiser -> denoiser_mode != kDenoiserOnYUVAggressive ) {
denoiser -> denoise_pars . scale_sse_thresh = 1 ;
denoiser -> denoise_pars . scale_motion_thresh = 8 ;
denoiser -> denoise_pars . scale_increase_filter = 0 ;
denoiser -> denoise_pars . denoise_mv_bias = 95 ;
denoiser -> denoise_pars . pickmode_mv_bias = 100 ;
denoiser -> denoise_pars . qp_thresh = 0 ;
denoiser -> denoise_pars . consec_zerolast = UINT_MAX ;
}
else {
denoiser -> denoise_pars . scale_sse_thresh = 2 ;
denoiser -> denoise_pars . scale_motion_thresh = 16 ;
denoiser -> denoise_pars . scale_increase_filter = 1 ;
denoiser -> denoise_pars . denoise_mv_bias = 60 ;
denoiser -> denoise_pars . pickmode_mv_bias = 60 ;
denoiser -> denoise_pars . qp_thresh = 100 ;
denoiser -> denoise_pars . consec_zerolast = 10 ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * _conf_to_memberp ( TSOverridableConfigKey conf , OverridableHttpConfigParams * overridableHttpConfig , OverridableDataType * typep ) {
OverridableDataType typ = OVERRIDABLE_TYPE_BYTE ;
void * ret = nullptr ;
switch ( conf ) {
case TS_CONFIG_URL_REMAP_PRISTINE_HOST_HDR : ret = & overridableHttpConfig -> maintain_pristine_host_hdr ;
break ;
case TS_CONFIG_HTTP_CHUNKING_ENABLED : ret = & overridableHttpConfig -> chunking_enabled ;
break ;
case TS_CONFIG_HTTP_NEGATIVE_CACHING_ENABLED : ret = & overridableHttpConfig -> negative_caching_enabled ;
break ;
case TS_CONFIG_HTTP_NEGATIVE_CACHING_LIFETIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> negative_caching_lifetime ;
break ;
case TS_CONFIG_HTTP_CACHE_WHEN_TO_REVALIDATE : ret = & overridableHttpConfig -> cache_when_to_revalidate ;
break ;
case TS_CONFIG_HTTP_KEEP_ALIVE_ENABLED_IN : ret = & overridableHttpConfig -> keep_alive_enabled_in ;
break ;
case TS_CONFIG_HTTP_KEEP_ALIVE_ENABLED_OUT : ret = & overridableHttpConfig -> keep_alive_enabled_out ;
break ;
case TS_CONFIG_HTTP_KEEP_ALIVE_POST_OUT : ret = & overridableHttpConfig -> keep_alive_post_out ;
break ;
case TS_CONFIG_HTTP_SERVER_SESSION_SHARING_MATCH : ret = & overridableHttpConfig -> server_session_sharing_match ;
break ;
case TS_CONFIG_NET_SOCK_RECV_BUFFER_SIZE_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> sock_recv_buffer_size_out ;
break ;
case TS_CONFIG_NET_SOCK_SEND_BUFFER_SIZE_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> sock_send_buffer_size_out ;
break ;
case TS_CONFIG_NET_SOCK_OPTION_FLAG_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> sock_option_flag_out ;
break ;
case TS_CONFIG_HTTP_FORWARD_PROXY_AUTH_TO_PARENT : ret = & overridableHttpConfig -> fwd_proxy_auth_to_parent ;
break ;
case TS_CONFIG_HTTP_ANONYMIZE_REMOVE_FROM : ret = & overridableHttpConfig -> anonymize_remove_from ;
break ;
case TS_CONFIG_HTTP_ANONYMIZE_REMOVE_REFERER : ret = & overridableHttpConfig -> anonymize_remove_referer ;
break ;
case TS_CONFIG_HTTP_ANONYMIZE_REMOVE_USER_AGENT : ret = & overridableHttpConfig -> anonymize_remove_user_agent ;
break ;
case TS_CONFIG_HTTP_ANONYMIZE_REMOVE_COOKIE : ret = & overridableHttpConfig -> anonymize_remove_cookie ;
break ;
case TS_CONFIG_HTTP_ANONYMIZE_REMOVE_CLIENT_IP : ret = & overridableHttpConfig -> anonymize_remove_client_ip ;
break ;
case TS_CONFIG_HTTP_ANONYMIZE_INSERT_CLIENT_IP : ret = & overridableHttpConfig -> anonymize_insert_client_ip ;
break ;
case TS_CONFIG_HTTP_RESPONSE_SERVER_ENABLED : ret = & overridableHttpConfig -> proxy_response_server_enabled ;
break ;
case TS_CONFIG_HTTP_INSERT_SQUID_X_FORWARDED_FOR : ret = & overridableHttpConfig -> insert_squid_x_forwarded_for ;
break ;
case TS_CONFIG_HTTP_SERVER_TCP_INIT_CWND : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> server_tcp_init_cwnd ;
break ;
case TS_CONFIG_HTTP_SEND_HTTP11_REQUESTS : ret = & overridableHttpConfig -> send_http11_requests ;
break ;
case TS_CONFIG_HTTP_CACHE_HTTP : ret = & overridableHttpConfig -> cache_http ;
break ;
case TS_CONFIG_HTTP_CACHE_CLUSTER_CACHE_LOCAL : ret = & overridableHttpConfig -> cache_cluster_cache_local ;
break ;
case TS_CONFIG_HTTP_CACHE_IGNORE_CLIENT_NO_CACHE : ret = & overridableHttpConfig -> cache_ignore_client_no_cache ;
break ;
case TS_CONFIG_HTTP_CACHE_IGNORE_CLIENT_CC_MAX_AGE : ret = & overridableHttpConfig -> cache_ignore_client_cc_max_age ;
break ;
case TS_CONFIG_HTTP_CACHE_IMS_ON_CLIENT_NO_CACHE : ret = & overridableHttpConfig -> cache_ims_on_client_no_cache ;
break ;
case TS_CONFIG_HTTP_CACHE_IGNORE_SERVER_NO_CACHE : ret = & overridableHttpConfig -> cache_ignore_server_no_cache ;
break ;
case TS_CONFIG_HTTP_CACHE_CACHE_RESPONSES_TO_COOKIES : ret = & overridableHttpConfig -> cache_responses_to_cookies ;
break ;
case TS_CONFIG_HTTP_CACHE_IGNORE_AUTHENTICATION : ret = & overridableHttpConfig -> cache_ignore_auth ;
break ;
case TS_CONFIG_HTTP_CACHE_CACHE_URLS_THAT_LOOK_DYNAMIC : ret = & overridableHttpConfig -> cache_urls_that_look_dynamic ;
break ;
case TS_CONFIG_HTTP_CACHE_REQUIRED_HEADERS : ret = & overridableHttpConfig -> cache_required_headers ;
break ;
case TS_CONFIG_HTTP_INSERT_REQUEST_VIA_STR : ret = & overridableHttpConfig -> insert_request_via_string ;
break ;
case TS_CONFIG_HTTP_INSERT_RESPONSE_VIA_STR : ret = & overridableHttpConfig -> insert_response_via_string ;
break ;
case TS_CONFIG_HTTP_CACHE_HEURISTIC_MIN_LIFETIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_heuristic_min_lifetime ;
break ;
case TS_CONFIG_HTTP_CACHE_HEURISTIC_MAX_LIFETIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_heuristic_max_lifetime ;
break ;
case TS_CONFIG_HTTP_CACHE_GUARANTEED_MIN_LIFETIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_guaranteed_min_lifetime ;
break ;
case TS_CONFIG_HTTP_CACHE_GUARANTEED_MAX_LIFETIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_guaranteed_max_lifetime ;
break ;
case TS_CONFIG_HTTP_CACHE_MAX_STALE_AGE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_max_stale_age ;
break ;
case TS_CONFIG_HTTP_KEEP_ALIVE_NO_ACTIVITY_TIMEOUT_IN : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> keep_alive_no_activity_timeout_in ;
break ;
case TS_CONFIG_HTTP_KEEP_ALIVE_NO_ACTIVITY_TIMEOUT_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> keep_alive_no_activity_timeout_out ;
break ;
case TS_CONFIG_HTTP_TRANSACTION_NO_ACTIVITY_TIMEOUT_IN : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> transaction_no_activity_timeout_in ;
break ;
case TS_CONFIG_HTTP_TRANSACTION_NO_ACTIVITY_TIMEOUT_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> transaction_no_activity_timeout_out ;
break ;
case TS_CONFIG_HTTP_TRANSACTION_ACTIVE_TIMEOUT_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> transaction_active_timeout_out ;
break ;
case TS_CONFIG_HTTP_ORIGIN_MAX_CONNECTIONS : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> origin_max_connections ;
break ;
case TS_CONFIG_HTTP_CONNECT_ATTEMPTS_MAX_RETRIES : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> connect_attempts_max_retries ;
break ;
case TS_CONFIG_HTTP_CONNECT_ATTEMPTS_MAX_RETRIES_DEAD_SERVER : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> connect_attempts_max_retries_dead_server ;
break ;
case TS_CONFIG_HTTP_CONNECT_ATTEMPTS_RR_RETRIES : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> connect_attempts_rr_retries ;
break ;
case TS_CONFIG_HTTP_CONNECT_ATTEMPTS_TIMEOUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> connect_attempts_timeout ;
break ;
case TS_CONFIG_HTTP_POST_CONNECT_ATTEMPTS_TIMEOUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> post_connect_attempts_timeout ;
break ;
case TS_CONFIG_HTTP_DOWN_SERVER_CACHE_TIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> down_server_timeout ;
break ;
case TS_CONFIG_HTTP_DOWN_SERVER_ABORT_THRESHOLD : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> client_abort_threshold ;
break ;
case TS_CONFIG_HTTP_CACHE_FUZZ_TIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> freshness_fuzz_time ;
break ;
case TS_CONFIG_HTTP_CACHE_FUZZ_MIN_TIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> freshness_fuzz_min_time ;
break ;
case TS_CONFIG_HTTP_DOC_IN_CACHE_SKIP_DNS : ret = & overridableHttpConfig -> doc_in_cache_skip_dns ;
break ;
case TS_CONFIG_HTTP_BACKGROUND_FILL_ACTIVE_TIMEOUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> background_fill_active_timeout ;
break ;
case TS_CONFIG_HTTP_RESPONSE_SERVER_STR : typ = OVERRIDABLE_TYPE_STRING ;
ret = & overridableHttpConfig -> proxy_response_server_string ;
break ;
case TS_CONFIG_HTTP_CACHE_HEURISTIC_LM_FACTOR : typ = OVERRIDABLE_TYPE_FLOAT ;
ret = & overridableHttpConfig -> cache_heuristic_lm_factor ;
break ;
case TS_CONFIG_HTTP_CACHE_FUZZ_PROBABILITY : typ = OVERRIDABLE_TYPE_FLOAT ;
ret = & overridableHttpConfig -> freshness_fuzz_prob ;
break ;
case TS_CONFIG_HTTP_BACKGROUND_FILL_COMPLETED_THRESHOLD : typ = OVERRIDABLE_TYPE_FLOAT ;
ret = & overridableHttpConfig -> background_fill_threshold ;
break ;
case TS_CONFIG_NET_SOCK_PACKET_MARK_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> sock_packet_mark_out ;
break ;
case TS_CONFIG_NET_SOCK_PACKET_TOS_OUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> sock_packet_tos_out ;
break ;
case TS_CONFIG_HTTP_INSERT_AGE_IN_RESPONSE : ret = & overridableHttpConfig -> insert_age_in_response ;
break ;
case TS_CONFIG_HTTP_CHUNKING_SIZE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> http_chunking_size ;
break ;
case TS_CONFIG_HTTP_FLOW_CONTROL_ENABLED : ret = & overridableHttpConfig -> flow_control_enabled ;
break ;
case TS_CONFIG_HTTP_FLOW_CONTROL_LOW_WATER_MARK : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> flow_low_water_mark ;
break ;
case TS_CONFIG_HTTP_FLOW_CONTROL_HIGH_WATER_MARK : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> flow_high_water_mark ;
break ;
case TS_CONFIG_HTTP_CACHE_RANGE_LOOKUP : ret = & overridableHttpConfig -> cache_range_lookup ;
break ;
case TS_CONFIG_HTTP_NORMALIZE_AE_GZIP : ret = & overridableHttpConfig -> normalize_ae_gzip ;
break ;
case TS_CONFIG_HTTP_DEFAULT_BUFFER_SIZE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> default_buffer_size_index ;
break ;
case TS_CONFIG_HTTP_DEFAULT_BUFFER_WATER_MARK : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> default_buffer_water_mark ;
break ;
case TS_CONFIG_HTTP_REQUEST_HEADER_MAX_SIZE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> request_hdr_max_size ;
break ;
case TS_CONFIG_HTTP_RESPONSE_HEADER_MAX_SIZE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> response_hdr_max_size ;
break ;
case TS_CONFIG_HTTP_NEGATIVE_REVALIDATING_ENABLED : ret = & overridableHttpConfig -> negative_revalidating_enabled ;
break ;
case TS_CONFIG_HTTP_NEGATIVE_REVALIDATING_LIFETIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> negative_revalidating_lifetime ;
break ;
case TS_CONFIG_SSL_HSTS_MAX_AGE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> proxy_response_hsts_max_age ;
break ;
case TS_CONFIG_SSL_HSTS_INCLUDE_SUBDOMAINS : ret = & overridableHttpConfig -> proxy_response_hsts_include_subdomains ;
break ;
case TS_CONFIG_HTTP_CACHE_OPEN_READ_RETRY_TIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_open_read_retry_time ;
break ;
case TS_CONFIG_HTTP_CACHE_MAX_OPEN_READ_RETRIES : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> max_cache_open_read_retries ;
break ;
case TS_CONFIG_HTTP_CACHE_RANGE_WRITE : ret = & overridableHttpConfig -> cache_range_write ;
break ;
case TS_CONFIG_HTTP_POST_CHECK_CONTENT_LENGTH_ENABLED : ret = & overridableHttpConfig -> post_check_content_length_enabled ;
break ;
case TS_CONFIG_HTTP_GLOBAL_USER_AGENT_HEADER : typ = OVERRIDABLE_TYPE_STRING ;
ret = & overridableHttpConfig -> global_user_agent_header ;
break ;
case TS_CONFIG_HTTP_AUTH_SERVER_SESSION_PRIVATE : ret = & overridableHttpConfig -> auth_server_session_private ;
break ;
case TS_CONFIG_HTTP_SLOW_LOG_THRESHOLD : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> slow_log_threshold ;
break ;
case TS_CONFIG_HTTP_CACHE_GENERATION : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> cache_generation_number ;
break ;
case TS_CONFIG_BODY_FACTORY_TEMPLATE_BASE : typ = OVERRIDABLE_TYPE_STRING ;
ret = & overridableHttpConfig -> body_factory_template_base ;
break ;
case TS_CONFIG_HTTP_CACHE_OPEN_WRITE_FAIL_ACTION : ret = & overridableHttpConfig -> cache_open_write_fail_action ;
break ;
case TS_CONFIG_HTTP_ENABLE_REDIRECTION : ret = & overridableHttpConfig -> redirection_enabled ;
break ;
case TS_CONFIG_HTTP_NUMBER_OF_REDIRECTIONS : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> number_of_redirections ;
break ;
case TS_CONFIG_HTTP_CACHE_MAX_OPEN_WRITE_RETRIES : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> max_cache_open_write_retries ;
break ;
case TS_CONFIG_HTTP_REDIRECT_USE_ORIG_CACHE_KEY : ret = & overridableHttpConfig -> redirect_use_orig_cache_key ;
break ;
case TS_CONFIG_HTTP_ATTACH_SERVER_SESSION_TO_CLIENT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> attach_server_session_to_client ;
break ;
case TS_CONFIG_HTTP_SAFE_REQUESTS_RETRYABLE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> safe_requests_retryable ;
break ;
case TS_CONFIG_HTTP_ORIGIN_MAX_CONNECTIONS_QUEUE : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> origin_max_connections_queue ;
break ;
case TS_CONFIG_WEBSOCKET_NO_ACTIVITY_TIMEOUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> websocket_inactive_timeout ;
break ;
case TS_CONFIG_WEBSOCKET_ACTIVE_TIMEOUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> websocket_active_timeout ;
break ;
case TS_CONFIG_HTTP_UNCACHEABLE_REQUESTS_BYPASS_PARENT : ret = & overridableHttpConfig -> uncacheable_requests_bypass_parent ;
break ;
case TS_CONFIG_HTTP_PARENT_PROXY_TOTAL_CONNECT_ATTEMPTS : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> parent_connect_attempts ;
break ;
case TS_CONFIG_HTTP_TRANSACTION_ACTIVE_TIMEOUT_IN : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> transaction_active_timeout_in ;
break ;
case TS_CONFIG_SRV_ENABLED : ret = & overridableHttpConfig -> srv_enabled ;
break ;
case TS_CONFIG_HTTP_FORWARD_CONNECT_METHOD : ret = & overridableHttpConfig -> forward_connect_method ;
break ;
case TS_CONFIG_SSL_CERT_FILENAME : typ = OVERRIDABLE_TYPE_STRING ;
ret = & overridableHttpConfig -> client_cert_filename ;
break ;
case TS_CONFIG_SSL_CERT_FILEPATH : typ = OVERRIDABLE_TYPE_STRING ;
ret = & overridableHttpConfig -> client_cert_filepath ;
break ;
case TS_CONFIG_PARENT_FAILURES_UPDATE_HOSTDB : ret = & overridableHttpConfig -> parent_failures_update_hostdb ;
break ;
case TS_CONFIG_SSL_CLIENT_VERIFY_SERVER : ret = & overridableHttpConfig -> ssl_client_verify_server ;
break ;
case TS_CONFIG_HTTP_PARENT_PROXY_FAIL_THRESHOLD : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> parent_fail_threshold ;
break ;
case TS_CONFIG_HTTP_PARENT_PROXY_RETRY_TIME : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> parent_retry_time ;
break ;
case TS_CONFIG_HTTP_PER_PARENT_CONNECT_ATTEMPTS : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> per_parent_connect_attempts ;
break ;
case TS_CONFIG_HTTP_PARENT_CONNECT_ATTEMPT_TIMEOUT : typ = OVERRIDABLE_TYPE_INT ;
ret = & overridableHttpConfig -> parent_connect_timeout ;
break ;
case TS_CONFIG_HTTP_ALLOW_MULTI_RANGE : ret = & overridableHttpConfig -> allow_multi_range ;
break ;
case TS_CONFIG_NULL : case TS_CONFIG_LAST_ENTRY : typ = OVERRIDABLE_TYPE_NULL ;
ret = nullptr ;
break ;
}
* typep = typ ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
SPL_METHOD ( SplFileInfo , func_name ) \ {
\ spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
\ zend_error_handling error_handling ;
\ if ( zend_parse_parameters_none ( ) == FAILURE ) {
\ return ;
\ }
\ \ zend_replace_error_handling ( EH_THROW , spl_ce_RuntimeException , & error_handling TSRMLS_CC ) ;
\ spl_filesystem_object_get_file_name ( intern TSRMLS_CC ) ;
\ php_stat ( intern -> file_name , intern -> file_name_len , func_num , return_value TSRMLS_CC ) ;
\ zend_restore_error_handling ( & error_handling TSRMLS_CC ) ;
\ }
FileInfoFunction ( getPerms , FS_PERMS )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cmd_window_move_dleft ( void ) {
MAIN_WINDOW_REC * rec ;
rec = mainwindows_find_left ( active_mainwin , FALSE ) ;
if ( rec == NULL ) rec = mainwindows_find_left ( active_mainwin , TRUE ) ;
if ( rec != NULL ) window_reparent ( active_win , rec ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int SpoolssEnumPrinterKey_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
offset = dissect_spoolss_keybuffer ( tvb , offset , pinfo , tree , di , drep ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_needed , NULL ) ;
offset = dissect_doserror ( tvb , offset , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int dissect_h225_GenericData ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 828 "./asn1/h225/h225.cnf" void * priv_data = actx -> private_data ;
gef_ctx_t * gefx ;
gefx = gef_ctx_get ( actx -> private_data ) ;
if ( ! gefx ) {
gefx = gef_ctx_alloc ( NULL , "GenericData" ) ;
actx -> private_data = gefx ;
}
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_GenericData , GenericData_sequence ) ;
# line 838 "./asn1/h225/h225.cnf" actx -> private_data = priv_data ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
GType hb_gobject_ ## name ## _get_type ( void ) \ {
static gsize type_id = 0 ;
if ( g_once_init_enter ( & type_id ) ) {
GType id = g_boxed_type_register_static ( g_intern_static_string ( "hb_" # name "_t" ) , ( GBoxedCopyFunc ) copy_func , ( GBoxedFreeFunc ) free_func ) ;
g_once_init_leave ( & type_id , id ) ;
}
return type_id ;
\ }
# define HB_DEFINE_OBJECT_TYPE ( name ) HB_DEFINE_BOXED_TYPE ( name , hb_ ## name ## _reference , hb_ ## name ## _destroy ) ;
# define HB_DEFINE_VALUE_TYPE ( name ) static hb_ ## name ## _t * _hb_ ## name ## _reference ( const hb_ ## name ## _t * l ) {
hb_ ## name ## _t * c = ( hb_ ## name ## _t * ) calloc ( 1 , sizeof ( hb_ ## name ## _t ) ) ;
if ( unlikely ( ! c ) ) return NULL ;
* c = * l ;
return c ;
}
static void _hb_ ## name ## _destroy ( hb_ ## name ## _t * l ) {
free ( l ) ;
}
HB_DEFINE_BOXED_TYPE ( name , _hb_ ## name ## _reference , _hb_ ## name ## _destroy ) ;
HB_DEFINE_OBJECT_TYPE ( buffer ) HB_DEFINE_OBJECT_TYPE ( blob ) HB_DEFINE_OBJECT_TYPE ( face ) HB_DEFINE_OBJECT_TYPE ( font ) HB_DEFINE_OBJECT_TYPE ( font_funcs ) HB_DEFINE_OBJECT_TYPE ( set ) HB_DEFINE_OBJECT_TYPE ( shape_plan ) HB_DEFINE_OBJECT_TYPE ( unicode_funcs ) HB_DEFINE_VALUE_TYPE ( feature ) HB_DEFINE_VALUE_TYPE ( glyph_info ) HB_DEFINE_VALUE_TYPE ( glyph_position ) HB_DEFINE_VALUE_TYPE ( segment_properties ) HB_DEFINE_VALUE_TYPE ( user_data_key )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void add_dequant_dct ( MpegEncContext * s , int16_t * block , int i , uint8_t * dest , int line_size , int qscale ) {
if ( s -> block_last_index [ i ] >= 0 ) {
s -> dct_unquantize_inter ( s , block , i , qscale ) ;
s -> dsp . idct_add ( dest , line_size , block ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int jas_image_addfmt ( int id , char * name , char * ext , char * desc , jas_image_fmtops_t * ops ) {
jas_image_fmtinfo_t * fmtinfo ;
assert ( id >= 0 && name && ext && ops ) ;
if ( jas_image_numfmts >= JAS_IMAGE_MAXFMTS ) {
return - 1 ;
}
fmtinfo = & jas_image_fmtinfos [ jas_image_numfmts ] ;
fmtinfo -> id = id ;
if ( ! ( fmtinfo -> name = jas_strdup ( name ) ) ) {
return - 1 ;
}
if ( ! ( fmtinfo -> ext = jas_strdup ( ext ) ) ) {
jas_free ( fmtinfo -> name ) ;
return - 1 ;
}
if ( ! ( fmtinfo -> desc = jas_strdup ( desc ) ) ) {
jas_free ( fmtinfo -> name ) ;
jas_free ( fmtinfo -> ext ) ;
return - 1 ;
}
fmtinfo -> ops = * ops ;
++ jas_image_numfmts ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_rc_get_one_pass_cbr_params ( VP9_COMP * cpi ) {
VP9_COMMON * const cm = & cpi -> common ;
RATE_CONTROL * const rc = & cpi -> rc ;
int target ;
if ( ( cm -> current_video_frame == 0 || ( cpi -> frame_flags & FRAMEFLAGS_KEY ) || rc -> frames_to_key == 0 || ( cpi -> oxcf . auto_key && 0 ) ) ) {
cm -> frame_type = KEY_FRAME ;
rc -> this_key_frame_forced = cm -> current_video_frame != 0 && rc -> frames_to_key == 0 ;
rc -> frames_to_key = cpi -> oxcf . key_freq ;
rc -> kf_boost = DEFAULT_KF_BOOST ;
rc -> source_alt_ref_active = 0 ;
target = calc_iframe_target_size_one_pass_cbr ( cpi ) ;
}
else {
cm -> frame_type = INTER_FRAME ;
target = calc_pframe_target_size_one_pass_cbr ( cpi ) ;
}
vp9_rc_set_frame_target ( cpi , target ) ;
rc -> frames_till_gf_update_due = INT_MAX ;
rc -> baseline_gf_interval = INT_MAX ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * rsvp_conv_get_filter_type ( conv_item_t * conv , conv_filter_type_e filter _U_ ) {
if ( ( filter == CONV_FT_SRC_ADDRESS ) && ( conv -> src_address . type == AT_IPv4 ) ) return "ip.src" ;
if ( ( filter == CONV_FT_DST_ADDRESS ) && ( conv -> dst_address . type == AT_IPv4 ) ) return "ip.dst" ;
if ( ( filter == CONV_FT_ANY_ADDRESS ) && ( conv -> src_address . type == AT_IPv4 ) ) return "ip.addr" ;
return CONV_FILTER_INVALID ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void nautilus_directory_schedule_dequeue_pending ( NautilusDirectory * directory ) {
if ( directory -> details -> dequeue_pending_idle_id == 0 ) {
directory -> details -> dequeue_pending_idle_id = g_idle_add ( dequeue_pending_idle_callback , directory ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ss20_init ( QEMUMachineInitArgs * args ) {
ram_addr_t RAM_size = args -> ram_size ;
const char * cpu_model = args -> cpu_model ;
const char * kernel_filename = args -> kernel_filename ;
const char * kernel_cmdline = args -> kernel_cmdline ;
const char * initrd_filename = args -> initrd_filename ;
const char * boot_device = args -> boot_device ;
sun4m_hw_init ( & sun4m_hwdefs [ 3 ] , RAM_size , boot_device , kernel_filename , kernel_cmdline , initrd_filename , cpu_model ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
inline const UChar * toUCharPtr ( const char16_t * p ) {
# ifdef U_ALIASING_BARRIER U_ALIASING_BARRIER ( p ) ;
# endif return reinterpret_cast < const UChar * > ( p ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void vga_draw_line24_be ( VGACommonState * vga , uint8_t * d , uint32_t addr , int width ) {
int w ;
uint32_t r , g , b ;
w = width ;
do {
r = vga_read_byte ( vga , addr + 0 ) ;
g = vga_read_byte ( vga , addr + 1 ) ;
b = vga_read_byte ( vga , addr + 2 ) ;
( ( uint32_t * ) d ) [ 0 ] = rgb_to_pixel32 ( r , g , b ) ;
addr += 3 ;
d += 4 ;
}
while ( -- w != 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void free_months ( UChar * months [ ] ) {
free_symbols ( months , MONTH_COUNT - 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
long dtls1_ctrl ( SSL * s , int cmd , long larg , void * parg ) {
int ret = 0 ;
switch ( cmd ) {
case DTLS_CTRL_GET_TIMEOUT : if ( dtls1_get_timeout ( s , ( struct timeval * ) parg ) != NULL ) {
ret = 1 ;
}
break ;
case DTLS_CTRL_HANDLE_TIMEOUT : ret = dtls1_handle_timeout ( s ) ;
break ;
case DTLS_CTRL_SET_LINK_MTU : if ( larg < ( long ) dtls1_link_min_mtu ( ) ) return 0 ;
s -> d1 -> link_mtu = larg ;
return 1 ;
case DTLS_CTRL_GET_LINK_MIN_MTU : return ( long ) dtls1_link_min_mtu ( ) ;
case SSL_CTRL_SET_MTU : if ( larg < ( long ) dtls1_link_min_mtu ( ) - DTLS1_MAX_MTU_OVERHEAD ) return 0 ;
s -> d1 -> mtu = larg ;
return larg ;
default : ret = ssl3_ctrl ( s , cmd , larg , parg ) ;
break ;
}
return ( ret ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void * Type_MLU_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
cmsMLU * mlu ;
cmsUInt32Number Count , RecLen , NumOfWchar ;
cmsUInt32Number SizeOfHeader ;
cmsUInt32Number Len , Offset ;
cmsUInt32Number i ;
wchar_t * Block ;
cmsUInt32Number BeginOfThisString , EndOfThisString , LargestPosition ;
* nItems = 0 ;
if ( ! _cmsReadUInt32Number ( io , & Count ) ) return NULL ;
if ( ! _cmsReadUInt32Number ( io , & RecLen ) ) return NULL ;
if ( RecLen != 12 ) {
cmsSignalError ( self -> ContextID , cmsERROR_UNKNOWN_EXTENSION , "multiLocalizedUnicodeType of len != 12 is not supported." ) ;
return NULL ;
}
mlu = cmsMLUalloc ( self -> ContextID , Count ) ;
if ( mlu == NULL ) return NULL ;
mlu -> UsedEntries = Count ;
SizeOfHeader = 12 * Count + sizeof ( _cmsTagBase ) ;
LargestPosition = 0 ;
for ( i = 0 ;
i < Count ;
i ++ ) {
if ( ! _cmsReadUInt16Number ( io , & mlu -> Entries [ i ] . Language ) ) goto Error ;
if ( ! _cmsReadUInt16Number ( io , & mlu -> Entries [ i ] . Country ) ) goto Error ;
if ( ! _cmsReadUInt32Number ( io , & Len ) ) goto Error ;
if ( ! _cmsReadUInt32Number ( io , & Offset ) ) goto Error ;
if ( Offset < ( SizeOfHeader + 8 ) ) goto Error ;
if ( ( Offset + Len ) > SizeOfTag + 8 ) goto Error ;
BeginOfThisString = Offset - SizeOfHeader - 8 ;
mlu -> Entries [ i ] . Len = ( Len * sizeof ( wchar_t ) ) / sizeof ( cmsUInt16Number ) ;
mlu -> Entries [ i ] . StrW = ( BeginOfThisString * sizeof ( wchar_t ) ) / sizeof ( cmsUInt16Number ) ;
EndOfThisString = BeginOfThisString + Len ;
if ( EndOfThisString > LargestPosition ) LargestPosition = EndOfThisString ;
}
SizeOfTag = ( LargestPosition * sizeof ( wchar_t ) ) / sizeof ( cmsUInt16Number ) ;
if ( SizeOfTag == 0 ) {
Block = NULL ;
NumOfWchar = 0 ;
}
else {
Block = ( wchar_t * ) _cmsMalloc ( self -> ContextID , SizeOfTag ) ;
if ( Block == NULL ) goto Error ;
NumOfWchar = SizeOfTag / sizeof ( wchar_t ) ;
if ( ! _cmsReadWCharArray ( io , NumOfWchar , Block ) ) goto Error ;
}
mlu -> MemPool = Block ;
mlu -> PoolSize = SizeOfTag ;
mlu -> PoolUsed = SizeOfTag ;
* nItems = 1 ;
return ( void * ) mlu ;
Error : if ( mlu ) cmsMLUfree ( mlu ) ;
return NULL ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
Selectivity booltestsel ( PlannerInfo * root , BoolTestType booltesttype , Node * arg , int varRelid , JoinType jointype , SpecialJoinInfo * sjinfo ) {
VariableStatData vardata ;
double selec ;
examine_variable ( root , arg , varRelid , & vardata ) ;
if ( HeapTupleIsValid ( vardata . statsTuple ) ) {
Form_pg_statistic stats ;
double freq_null ;
Datum * values ;
int nvalues ;
float4 * numbers ;
int nnumbers ;
stats = ( Form_pg_statistic ) GETSTRUCT ( vardata . statsTuple ) ;
freq_null = stats -> stanullfrac ;
if ( get_attstatsslot ( vardata . statsTuple , vardata . atttype , vardata . atttypmod , STATISTIC_KIND_MCV , InvalidOid , NULL , & values , & nvalues , & numbers , & nnumbers ) && nnumbers > 0 ) {
double freq_true ;
double freq_false ;
if ( DatumGetBool ( values [ 0 ] ) ) freq_true = numbers [ 0 ] ;
else freq_true = 1.0 - numbers [ 0 ] - freq_null ;
freq_false = 1.0 - freq_true - freq_null ;
switch ( booltesttype ) {
case IS_UNKNOWN : selec = freq_null ;
break ;
case IS_NOT_UNKNOWN : selec = 1.0 - freq_null ;
break ;
case IS_TRUE : selec = freq_true ;
break ;
case IS_NOT_TRUE : selec = 1.0 - freq_true ;
break ;
case IS_FALSE : selec = freq_false ;
break ;
case IS_NOT_FALSE : selec = 1.0 - freq_false ;
break ;
default : elog ( ERROR , "unrecognized booltesttype: %d" , ( int ) booltesttype ) ;
selec = 0.0 ;
break ;
}
free_attstatsslot ( vardata . atttype , values , nvalues , numbers , nnumbers ) ;
}
else {
switch ( booltesttype ) {
case IS_UNKNOWN : selec = freq_null ;
break ;
case IS_NOT_UNKNOWN : selec = 1.0 - freq_null ;
break ;
case IS_TRUE : case IS_FALSE : selec = ( 1.0 - freq_null ) / 2.0 ;
break ;
case IS_NOT_TRUE : case IS_NOT_FALSE : selec = ( freq_null + 1.0 ) / 2.0 ;
break ;
default : elog ( ERROR , "unrecognized booltesttype: %d" , ( int ) booltesttype ) ;
selec = 0.0 ;
break ;
}
}
}
else {
switch ( booltesttype ) {
case IS_UNKNOWN : selec = DEFAULT_UNK_SEL ;
break ;
case IS_NOT_UNKNOWN : selec = DEFAULT_NOT_UNK_SEL ;
break ;
case IS_TRUE : case IS_NOT_FALSE : selec = ( double ) clause_selectivity ( root , arg , varRelid , jointype , sjinfo ) ;
break ;
case IS_FALSE : case IS_NOT_TRUE : selec = 1.0 - ( double ) clause_selectivity ( root , arg , varRelid , jointype , sjinfo ) ;
break ;
default : elog ( ERROR , "unrecognized booltesttype: %d" , ( int ) booltesttype ) ;
selec = 0.0 ;
break ;
}
}
ReleaseVariableStats ( vardata ) ;
CLAMP_PROBABILITY ( selec ) ;
return ( Selectivity ) selec ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mi_repair_by_sort ( MI_CHECK * param , register MI_INFO * info , const char * name , int rep_quick ) {
int got_error ;
uint i ;
ulong length ;
ha_rows start_records ;
my_off_t new_header_length , del ;
File new_file ;
MI_SORT_PARAM sort_param ;
MYISAM_SHARE * share = info -> s ;
HA_KEYSEG * keyseg ;
ulong * rec_per_key_part ;
char llbuff [ 22 ] ;
SORT_INFO sort_info ;
ulonglong UNINIT_VAR ( key_map ) ;
DBUG_ENTER ( "mi_repair_by_sort" ) ;
start_records = info -> state -> records ;
got_error = 1 ;
new_file = - 1 ;
new_header_length = ( param -> testflag & T_UNPACK ) ? 0 : share -> pack . header_length ;
if ( ! ( param -> testflag & T_SILENT ) ) {
printf ( "- recovering (with sort) MyISAM-table '%s'\n" , name ) ;
printf ( "Data records: %s\n" , llstr ( start_records , llbuff ) ) ;
}
param -> testflag |= T_REP ;
if ( info -> s -> options & ( HA_OPTION_CHECKSUM | HA_OPTION_COMPRESS_RECORD ) ) param -> testflag |= T_CALC_CHECKSUM ;
bzero ( ( char * ) & sort_info , sizeof ( sort_info ) ) ;
bzero ( ( char * ) & sort_param , sizeof ( sort_param ) ) ;
if ( ! ( sort_info . key_block = alloc_key_blocks ( param , ( uint ) param -> sort_key_blocks , share -> base . max_key_block_length ) ) || init_io_cache ( & param -> read_cache , info -> dfile , ( uint ) param -> read_buffer_length , READ_CACHE , share -> pack . header_length , 1 , MYF ( MY_WME ) ) || ( ! rep_quick && init_io_cache ( & info -> rec_cache , info -> dfile , ( uint ) param -> write_buffer_length , WRITE_CACHE , new_header_length , 1 , MYF ( MY_WME | MY_WAIT_IF_FULL ) & param -> myf_rw ) ) ) goto err ;
sort_info . key_block_end = sort_info . key_block + param -> sort_key_blocks ;
info -> opt_flag |= WRITE_CACHE_USED ;
info -> rec_cache . file = info -> dfile ;
if ( ! mi_alloc_rec_buff ( info , - 1 , & sort_param . record ) || ! mi_alloc_rec_buff ( info , - 1 , & sort_param . rec_buff ) ) {
mi_check_print_error ( param , "Not enough memory for extra record" ) ;
goto err ;
}
if ( ! rep_quick ) {
if ( ( new_file = mysql_file_create ( mi_key_file_datatmp , fn_format ( param -> temp_filename , share -> data_file_name , "" , DATA_TMP_EXT , 2 + 4 ) , 0 , param -> tmpfile_createflag , MYF ( 0 ) ) ) < 0 ) {
mi_check_print_error ( param , "Can't create new tempfile: '%s'" , param -> temp_filename ) ;
goto err ;
}
if ( new_header_length && filecopy ( param , new_file , info -> dfile , 0L , new_header_length , "datafile-header" ) ) goto err ;
if ( param -> testflag & T_UNPACK ) {
share -> options &= ~ HA_OPTION_COMPRESS_RECORD ;
mi_int2store ( share -> state . header . options , share -> options ) ;
}
share -> state . dellink = HA_OFFSET_ERROR ;
info -> rec_cache . file = new_file ;
}
info -> update = ( short ) ( HA_STATE_CHANGED | HA_STATE_ROW_CHANGED ) ;
mi_drop_all_indexes ( param , info , FALSE ) ;
key_map = share -> state . key_map ;
if ( param -> testflag & T_CREATE_MISSING_KEYS ) {
key_map = ~ key_map ;
}
sort_info . info = info ;
sort_info . param = param ;
set_data_file_type ( & sort_info , share ) ;
sort_param . filepos = new_header_length ;
sort_info . dupp = 0 ;
sort_info . buff = 0 ;
param -> read_cache . end_of_file = sort_info . filelength = mysql_file_seek ( param -> read_cache . file , 0L , MY_SEEK_END , MYF ( 0 ) ) ;
sort_param . wordlist = NULL ;
init_alloc_root ( & sort_param . wordroot , FTPARSER_MEMROOT_ALLOC_SIZE , 0 ) ;
if ( share -> data_file_type == DYNAMIC_RECORD ) length = max ( share -> base . min_pack_length + 1 , share -> base . min_block_length ) ;
else if ( share -> data_file_type == COMPRESSED_RECORD ) length = share -> base . min_block_length ;
else length = share -> base . pack_reclength ;
sort_info . max_records = ( ( param -> testflag & T_CREATE_MISSING_KEYS ) ? info -> state -> records : ( ha_rows ) ( sort_info . filelength / length + 1 ) ) ;
sort_param . key_cmp = sort_key_cmp ;
sort_param . lock_in_memory = lock_memory ;
sort_param . tmpdir = param -> tmpdir ;
sort_param . sort_info = & sort_info ;
sort_param . fix_datafile = ( my_bool ) ( ! rep_quick ) ;
sort_param . master = 1 ;
del = info -> state -> del ;
param -> glob_crc = 0 ;
if ( param -> testflag & T_CALC_CHECKSUM ) sort_param . calc_checksum = 1 ;
rec_per_key_part = param -> rec_per_key_part ;
for ( sort_param . key = 0 ;
sort_param . key < share -> base . keys ;
rec_per_key_part += sort_param . keyinfo -> keysegs , sort_param . key ++ ) {
sort_param . read_cache = param -> read_cache ;
sort_param . keyinfo = share -> keyinfo + sort_param . key ;
sort_param . seg = sort_param . keyinfo -> seg ;
if ( ! mi_is_key_active ( key_map , sort_param . key ) ) {
memcpy ( ( char * ) rec_per_key_part , ( char * ) ( share -> state . rec_per_key_part + ( uint ) ( rec_per_key_part - param -> rec_per_key_part ) ) , sort_param . keyinfo -> keysegs * sizeof ( * rec_per_key_part ) ) ;
DBUG_PRINT ( "repair" , ( "skipping seemingly disabled index #: %u" , sort_param . key ) ) ;
continue ;
}
if ( ( ! ( param -> testflag & T_SILENT ) ) ) printf ( "- Fixing index %d\n" , sort_param . key + 1 ) ;
sort_param . max_pos = sort_param . pos = share -> pack . header_length ;
keyseg = sort_param . seg ;
bzero ( ( char * ) sort_param . unique , sizeof ( sort_param . unique ) ) ;
sort_param . key_length = share -> rec_reflength ;
for ( i = 0 ;
keyseg [ i ] . type != HA_KEYTYPE_END ;
i ++ ) {
sort_param . key_length += keyseg [ i ] . length ;
if ( keyseg [ i ] . flag & HA_SPACE_PACK ) sort_param . key_length += get_pack_length ( keyseg [ i ] . length ) ;
if ( keyseg [ i ] . flag & ( HA_BLOB_PART | HA_VAR_LENGTH_PART ) ) sort_param . key_length += 2 + test ( keyseg [ i ] . length >= 127 ) ;
if ( keyseg [ i ] . flag & HA_NULL_PART ) sort_param . key_length ++ ;
}
info -> state -> records = info -> state -> del = share -> state . split = 0 ;
info -> state -> empty = 0 ;
if ( sort_param . keyinfo -> flag & HA_FULLTEXT ) {
uint ft_max_word_len_for_sort = FT_MAX_WORD_LEN_FOR_SORT * sort_param . keyinfo -> seg -> charset -> mbmaxlen ;
sort_param . key_length += ft_max_word_len_for_sort - HA_FT_MAXBYTELEN ;
if ( sort_param . keyinfo -> parser == & ft_default_parser ) {
sort_info . max_records = ( ha_rows ) ( sort_info . filelength / ft_min_word_len + 1 ) ;
}
else {
sort_info . max_records = 10 * max ( param -> sort_buffer_length , MIN_SORT_BUFFER ) / sort_param . key_length ;
}
sort_param . key_read = sort_ft_key_read ;
sort_param . key_write = sort_ft_key_write ;
}
else {
sort_param . key_read = sort_key_read ;
sort_param . key_write = sort_key_write ;
}
if ( _create_index_by_sort ( & sort_param , ( my_bool ) ( ! ( param -> testflag & T_VERBOSE ) ) , param -> sort_buffer_length ) ) {
param -> retry_repair = 1 ;
goto err ;
}
sort_param . calc_checksum = 0 ;
free_root ( & sort_param . wordroot , MYF ( 0 ) ) ;
sort_info . max_records = ( ha_rows ) info -> state -> records ;
if ( param -> testflag & T_STATISTICS ) update_key_parts ( sort_param . keyinfo , rec_per_key_part , sort_param . unique , param -> stats_method == MI_STATS_METHOD_IGNORE_NULLS ? sort_param . notnull : NULL , ( ulonglong ) info -> state -> records ) ;
mi_set_key_active ( share -> state . key_map , sort_param . key ) ;
DBUG_PRINT ( "repair" , ( "set enabled index #: %u" , sort_param . key ) ) ;
if ( sort_param . fix_datafile ) {
param -> read_cache . end_of_file = sort_param . filepos ;
if ( write_data_suffix ( & sort_info , 1 ) || end_io_cache ( & info -> rec_cache ) ) goto err ;
if ( param -> testflag & T_SAFE_REPAIR ) {
if ( info -> state -> records + 1 < start_records ) {
info -> state -> records = start_records ;
goto err ;
}
}
share -> state . state . data_file_length = info -> state -> data_file_length = sort_param . filepos ;
share -> state . version = ( ulong ) time ( ( time_t * ) 0 ) ;
mysql_file_close ( info -> dfile , MYF ( 0 ) ) ;
info -> dfile = new_file ;
share -> data_file_type = sort_info . new_data_file_type ;
share -> pack . header_length = ( ulong ) new_header_length ;
sort_param . fix_datafile = 0 ;
}
else info -> state -> data_file_length = sort_param . max_pos ;
param -> read_cache . file = info -> dfile ;
reinit_io_cache ( & param -> read_cache , READ_CACHE , share -> pack . header_length , 1 , 1 ) ;
}
if ( param -> testflag & T_WRITE_LOOP ) {
( void ) fputs ( " \r" , stdout ) ;
( void ) fflush ( stdout ) ;
}
if ( rep_quick && del + sort_info . dupp != info -> state -> del ) {
mi_check_print_error ( param , "Couldn't fix table with quick recovery: Found wrong number of deleted records" ) ;
mi_check_print_error ( param , "Run recovery again without -q" ) ;
got_error = 1 ;
param -> retry_repair = 1 ;
param -> testflag |= T_RETRY_WITHOUT_QUICK ;
goto err ;
}
if ( rep_quick & T_FORCE_UNIQUENESS ) {
my_off_t skr = info -> state -> data_file_length + ( share -> options & HA_OPTION_COMPRESS_RECORD ? MEMMAP_EXTRA_MARGIN : 0 ) ;
# ifdef USE_RELOC if ( share -> data_file_type == STATIC_RECORD && skr < share -> base . reloc * share -> base . min_pack_length ) skr = share -> base . reloc * share -> base . min_pack_length ;
# endif if ( skr != sort_info . filelength ) if ( mysql_file_chsize ( info -> dfile , skr , 0 , MYF ( 0 ) ) ) mi_check_print_warning ( param , "Can't change size of datafile, error: %d" , my_errno ) ;
}
if ( param -> testflag & T_CALC_CHECKSUM ) info -> state -> checksum = param -> glob_crc ;
if ( mysql_file_chsize ( share -> kfile , info -> state -> key_file_length , 0 , MYF ( 0 ) ) ) mi_check_print_warning ( param , "Can't change size of indexfile, error: %d" , my_errno ) ;
if ( ! ( param -> testflag & T_SILENT ) ) {
if ( start_records != info -> state -> records ) printf ( "Data records: %s\n" , llstr ( info -> state -> records , llbuff ) ) ;
if ( sort_info . dupp ) mi_check_print_warning ( param , "%s records have been removed" , llstr ( sort_info . dupp , llbuff ) ) ;
}
got_error = 0 ;
if ( & share -> state . state != info -> state ) memcpy ( & share -> state . state , info -> state , sizeof ( * info -> state ) ) ;
err : got_error |= flush_blocks ( param , share -> key_cache , share -> kfile ) ;
( void ) end_io_cache ( & info -> rec_cache ) ;
if ( ! got_error ) {
if ( new_file >= 0 ) {
mysql_file_close ( new_file , MYF ( 0 ) ) ;
info -> dfile = new_file = - 1 ;
if ( change_to_newfile ( share -> data_file_name , MI_NAME_DEXT , DATA_TMP_EXT , ( param -> testflag & T_BACKUP_DATA ? MYF ( MY_REDEL_MAKE_BACKUP ) : MYF ( 0 ) ) ) || mi_open_datafile ( info , share , name , - 1 ) ) got_error = 1 ;
}
}
if ( got_error ) {
if ( ! param -> error_printed ) mi_check_print_error ( param , "%d when fixing table" , my_errno ) ;
if ( new_file >= 0 ) {
( void ) mysql_file_close ( new_file , MYF ( 0 ) ) ;
( void ) mysql_file_delete ( mi_key_file_datatmp , param -> temp_filename , MYF ( MY_WME ) ) ;
if ( info -> dfile == new_file ) if ( unlikely ( mi_open_datafile ( info , share , name , - 1 ) ) ) param -> retry_repair = 0 ;
}
mi_mark_crashed_on_repair ( info ) ;
}
else if ( key_map == share -> state . key_map ) share -> state . changed &= ~ STATE_NOT_OPTIMIZED_KEYS ;
share -> state . changed |= STATE_NOT_SORTED_PAGES ;
my_free ( mi_get_rec_buff_ptr ( info , sort_param . rec_buff ) ) ;
my_free ( mi_get_rec_buff_ptr ( info , sort_param . record ) ) ;
my_free ( sort_info . key_block ) ;
my_free ( sort_info . ft_buf ) ;
my_free ( sort_info . buff ) ;
( void ) end_io_cache ( & param -> read_cache ) ;
info -> opt_flag &= ~ ( READ_CACHE_USED | WRITE_CACHE_USED ) ;
if ( ! got_error && ( param -> testflag & T_UNPACK ) ) {
share -> state . header . options [ 0 ] &= ( uchar ) ~ HA_OPTION_COMPRESS_RECORD ;
share -> pack . header_length = 0 ;
}
DBUG_RETURN ( got_error ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int x ( struct vcache * avc , int afun , struct vrequest * areq , \ struct afs_pdata * ain , struct afs_pdata * aout , \ afs_ucred_t * * acred ) DECL_PIOCTL ( PGetFID ) ;
DECL_PIOCTL ( PSetAcl ) ;
DECL_PIOCTL ( PStoreBehind ) ;
DECL_PIOCTL ( PGCPAGs ) ;
DECL_PIOCTL ( PGetAcl ) ;
DECL_PIOCTL ( PNoop ) ;
DECL_PIOCTL ( PBogus ) ;
DECL_PIOCTL ( PGetFileCell ) ;
DECL_PIOCTL ( PGetWSCell ) ;
DECL_PIOCTL ( PGetUserCell ) ;
DECL_PIOCTL ( PSetTokens ) ;
DECL_PIOCTL ( PGetVolumeStatus ) ;
DECL_PIOCTL ( PSetVolumeStatus ) ;
DECL_PIOCTL ( PFlush ) ;
DECL_PIOCTL ( PNewStatMount ) ;
DECL_PIOCTL ( PGetTokens ) ;
DECL_PIOCTL ( PUnlog ) ;
DECL_PIOCTL ( PMariner ) ;
DECL_PIOCTL ( PCheckServers ) ;
DECL_PIOCTL ( PCheckVolNames ) ;
DECL_PIOCTL ( PCheckAuth ) ;
DECL_PIOCTL ( PFindVolume ) ;
DECL_PIOCTL ( PViceAccess ) ;
DECL_PIOCTL ( PSetCacheSize ) ;
DECL_PIOCTL ( PGetCacheSize ) ;
DECL_PIOCTL ( PRemoveCallBack ) ;
DECL_PIOCTL ( PNewCell ) ;
DECL_PIOCTL ( PNewAlias ) ;
DECL_PIOCTL ( PListCells ) ;
DECL_PIOCTL ( PListAliases ) ;
DECL_PIOCTL ( PRemoveMount ) ;
DECL_PIOCTL ( PGetCellStatus ) ;
DECL_PIOCTL ( PSetCellStatus )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static cmsBool Type_ProfileSequenceDesc_Write ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , void * Ptr , cmsUInt32Number nItems ) {
cmsSEQ * Seq = ( cmsSEQ * ) Ptr ;
cmsUInt32Number i ;
if ( ! _cmsWriteUInt32Number ( io , Seq -> n ) ) return FALSE ;
for ( i = 0 ;
i < Seq -> n ;
i ++ ) {
cmsPSEQDESC * sec = & Seq -> seq [ i ] ;
if ( ! _cmsWriteUInt32Number ( io , sec -> deviceMfg ) ) return FALSE ;
if ( ! _cmsWriteUInt32Number ( io , sec -> deviceModel ) ) return FALSE ;
if ( ! _cmsWriteUInt64Number ( io , & sec -> attributes ) ) return FALSE ;
if ( ! _cmsWriteUInt32Number ( io , sec -> technology ) ) return FALSE ;
if ( ! SaveDescription ( self , io , sec -> Manufacturer ) ) return FALSE ;
if ( ! SaveDescription ( self , io , sec -> Model ) ) return FALSE ;
}
return TRUE ;
cmsUNUSED_PARAMETER ( nItems ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void s390_init ( ram_addr_t ram_size , const char * boot_device , const char * kernel_filename , const char * kernel_cmdline , const char * initrd_filename , const char * cpu_model ) {
CPUState * env = NULL ;
ram_addr_t ram_addr ;
ram_addr_t kernel_size = 0 ;
ram_addr_t initrd_offset ;
ram_addr_t initrd_size = 0 ;
int i ;
if ( ! kvm_enabled ( ) ) {
fprintf ( stderr , "The S390 target only works with KVM enabled\n" ) ;
exit ( 1 ) ;
}
s390_bus = s390_virtio_bus_init ( & ram_size ) ;
ram_addr = qemu_ram_alloc ( ram_size ) ;
cpu_register_physical_memory ( 0 , ram_size , ram_addr ) ;
if ( cpu_model == NULL ) {
cpu_model = "host" ;
}
ipi_states = qemu_malloc ( sizeof ( CPUState * ) * smp_cpus ) ;
for ( i = 0 ;
i < smp_cpus ;
i ++ ) {
CPUState * tmp_env ;
tmp_env = cpu_init ( cpu_model ) ;
if ( ! env ) {
env = tmp_env ;
}
ipi_states [ i ] = tmp_env ;
tmp_env -> halted = 1 ;
tmp_env -> exception_index = EXCP_HLT ;
}
env -> halted = 0 ;
env -> exception_index = 0 ;
if ( kernel_filename ) {
kernel_size = load_image ( kernel_filename , qemu_get_ram_ptr ( 0 ) ) ;
if ( lduw_phys ( KERN_IMAGE_START ) != 0x0dd0 ) {
fprintf ( stderr , "Specified image is not an s390 boot image\n" ) ;
exit ( 1 ) ;
}
cpu_synchronize_state ( env ) ;
env -> psw . addr = KERN_IMAGE_START ;
env -> psw . mask = 0x0000000180000000ULL ;
}
if ( initrd_filename ) {
initrd_offset = INITRD_START ;
while ( kernel_size + 0x100000 > initrd_offset ) {
initrd_offset += 0x100000 ;
}
initrd_size = load_image ( initrd_filename , qemu_get_ram_ptr ( initrd_offset ) ) ;
stq_phys ( INITRD_PARM_START , initrd_offset ) ;
stq_phys ( INITRD_PARM_SIZE , initrd_size ) ;
}
if ( kernel_cmdline ) {
cpu_physical_memory_rw ( KERN_PARM_AREA , ( uint8_t * ) kernel_cmdline , strlen ( kernel_cmdline ) , 1 ) ;
}
for ( i = 0 ;
i < MAX_VIRTIO_CONSOLES ;
i ++ ) {
if ( virtcon_hds [ i ] ) {
qdev_init_nofail ( qdev_create ( ( BusState * ) s390_bus , "virtio-console-s390" ) ) ;
}
}
for ( i = 0 ;
i < nb_nics ;
i ++ ) {
NICInfo * nd = & nd_table [ i ] ;
DeviceState * dev ;
if ( ! nd -> model ) {
nd -> model = qemu_strdup ( "virtio" ) ;
}
if ( strcmp ( nd -> model , "virtio" ) ) {
fprintf ( stderr , "S390 only supports VirtIO nics\n" ) ;
exit ( 1 ) ;
}
dev = qdev_create ( ( BusState * ) s390_bus , "virtio-net-s390" ) ;
qdev_set_nic_properties ( dev , nd ) ;
qdev_init_nofail ( dev ) ;
}
for ( i = 0 ;
i < MAX_BLK_DEVS ;
i ++ ) {
DriveInfo * dinfo ;
DeviceState * dev ;
dinfo = drive_get ( IF_IDE , 0 , i ) ;
if ( ! dinfo ) {
continue ;
}
dev = qdev_create ( ( BusState * ) s390_bus , "virtio-blk-s390" ) ;
qdev_prop_set_drive ( dev , "drive" , dinfo ) ;
qdev_init_nofail ( dev ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _slurm_rpc_step_complete ( slurm_msg_t * msg , bool running_composite ) {
static int active_rpc_cnt = 0 ;
int error_code = SLURM_SUCCESS , rc , rem ;
uint32_t step_rc ;
DEF_TIMERS ;
step_complete_msg_t * req = ( step_complete_msg_t * ) msg -> data ;
slurmctld_lock_t job_write_lock = {
NO_LOCK , WRITE_LOCK , WRITE_LOCK , NO_LOCK , READ_LOCK }
;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
bool dump_job = false ;
START_TIMER ;
if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "Processing RPC: REQUEST_STEP_COMPLETE for %u.%u " "nodes %u-%u rc=%u uid=%d" , req -> job_id , req -> job_step_id , req -> range_first , req -> range_last , req -> step_rc , uid ) ;
if ( ! running_composite ) {
_throttle_start ( & active_rpc_cnt ) ;
lock_slurmctld ( job_write_lock ) ;
}
rc = step_partial_comp ( req , uid , & rem , & step_rc ) ;
if ( rc || rem ) {
if ( ! running_composite ) {
unlock_slurmctld ( job_write_lock ) ;
_throttle_fini ( & active_rpc_cnt ) ;
}
slurm_send_rc_msg ( msg , rc ) ;
if ( ! rc ) schedule_job_save ( ) ;
return ;
}
if ( req -> job_step_id == SLURM_BATCH_SCRIPT ) {
error_code = job_complete ( req -> job_id , uid , false , false , step_rc ) ;
if ( ! running_composite ) {
unlock_slurmctld ( job_write_lock ) ;
_throttle_fini ( & active_rpc_cnt ) ;
}
END_TIMER2 ( "_slurm_rpc_step_complete" ) ;
if ( error_code ) {
if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "%s JobId=%u: %s" , __func__ , req -> job_id , slurm_strerror ( error_code ) ) ;
slurm_send_rc_msg ( msg , error_code ) ;
}
else {
if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "sched: %s JobId=%u: %s" , __func__ , req -> job_id , TIME_STR ) ;
slurm_send_rc_msg ( msg , SLURM_SUCCESS ) ;
dump_job = true ;
}
}
else {
error_code = job_step_complete ( req -> job_id , req -> job_step_id , uid , false , step_rc ) ;
if ( ! running_composite ) {
unlock_slurmctld ( job_write_lock ) ;
_throttle_fini ( & active_rpc_cnt ) ;
}
END_TIMER2 ( "_slurm_rpc_step_complete" ) ;
if ( error_code ) {
if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "%s 1 StepId=%u.%u %s" , __func__ , req -> job_id , req -> job_step_id , slurm_strerror ( error_code ) ) ;
slurm_send_rc_msg ( msg , error_code ) ;
}
else {
if ( slurmctld_conf . debug_flags & DEBUG_FLAG_STEPS ) info ( "sched: %s StepId=%u.%u %s" , __func__ , req -> job_id , req -> job_step_id , TIME_STR ) ;
slurm_send_rc_msg ( msg , SLURM_SUCCESS ) ;
dump_job = true ;
}
}
if ( dump_job ) ( void ) schedule_job_save ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int64_t vp9_rd_pick_inter_mode_sb_seg_skip ( VP9_COMP * cpi , MACROBLOCK * x , int * returnrate , int64_t * returndistortion , BLOCK_SIZE bsize , PICK_MODE_CONTEXT * ctx , int64_t best_rd_so_far ) {
VP9_COMMON * const cm = & cpi -> common ;
RD_OPT * const rd_opt = & cpi -> rd ;
MACROBLOCKD * const xd = & x -> e_mbd ;
MB_MODE_INFO * const mbmi = & xd -> mi [ 0 ] -> mbmi ;
unsigned char segment_id = mbmi -> segment_id ;
const int comp_pred = 0 ;
int i ;
int64_t best_tx_diff [ TX_MODES ] ;
int64_t best_pred_diff [ REFERENCE_MODES ] ;
int64_t best_filter_diff [ SWITCHABLE_FILTER_CONTEXTS ] ;
unsigned int ref_costs_single [ MAX_REF_FRAMES ] , ref_costs_comp [ MAX_REF_FRAMES ] ;
vp9_prob comp_mode_p ;
INTERP_FILTER best_filter = SWITCHABLE ;
int64_t this_rd = INT64_MAX ;
int rate2 = 0 ;
const int64_t distortion2 = 0 ;
x -> skip_encode = cpi -> sf . skip_encode_frame && x -> q_index < QIDX_SKIP_THRESH ;
estimate_ref_frame_costs ( cm , xd , segment_id , ref_costs_single , ref_costs_comp , & comp_mode_p ) ;
for ( i = 0 ;
i < MAX_REF_FRAMES ;
++ i ) x -> pred_sse [ i ] = INT_MAX ;
for ( i = LAST_FRAME ;
i < MAX_REF_FRAMES ;
++ i ) x -> pred_mv_sad [ i ] = INT_MAX ;
* returnrate = INT_MAX ;
assert ( vp9_segfeature_active ( & cm -> seg , segment_id , SEG_LVL_SKIP ) ) ;
mbmi -> mode = ZEROMV ;
mbmi -> uv_mode = DC_PRED ;
mbmi -> ref_frame [ 0 ] = LAST_FRAME ;
mbmi -> ref_frame [ 1 ] = NONE ;
mbmi -> mv [ 0 ] . as_int = 0 ;
x -> skip = 1 ;
rd_opt -> mask_filter = 0 ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
++ i ) rd_opt -> filter_cache [ i ] = INT64_MAX ;
if ( cm -> interp_filter != BILINEAR ) {
best_filter = EIGHTTAP ;
if ( cm -> interp_filter == SWITCHABLE && x -> source_variance >= cpi -> sf . disable_filter_search_var_thresh ) {
int rs ;
int best_rs = INT_MAX ;
for ( i = 0 ;
i < SWITCHABLE_FILTERS ;
++ i ) {
mbmi -> interp_filter = i ;
rs = vp9_get_switchable_rate ( cpi ) ;
if ( rs < best_rs ) {
best_rs = rs ;
best_filter = mbmi -> interp_filter ;
}
}
}
}
if ( cm -> interp_filter == SWITCHABLE ) {
mbmi -> interp_filter = best_filter ;
rate2 += vp9_get_switchable_rate ( cpi ) ;
}
else {
mbmi -> interp_filter = cm -> interp_filter ;
}
if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) rate2 += vp9_cost_bit ( comp_mode_p , comp_pred ) ;
rate2 += ref_costs_single [ LAST_FRAME ] ;
this_rd = RDCOST ( x -> rdmult , x -> rddiv , rate2 , distortion2 ) ;
* returnrate = rate2 ;
* returndistortion = distortion2 ;
if ( this_rd >= best_rd_so_far ) return INT64_MAX ;
assert ( ( cm -> interp_filter == SWITCHABLE ) || ( cm -> interp_filter == mbmi -> interp_filter ) ) ;
update_rd_thresh_fact ( cpi , bsize , THR_ZEROMV ) ;
vp9_zero ( best_pred_diff ) ;
vp9_zero ( best_filter_diff ) ;
vp9_zero ( best_tx_diff ) ;
if ( ! x -> select_tx_size ) swap_block_ptr ( x , ctx , 1 , 0 , 0 , MAX_MB_PLANE ) ;
store_coding_context ( x , ctx , THR_ZEROMV , best_pred_diff , best_tx_diff , best_filter_diff , 0 ) ;
return this_rd ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
vpx_codec_err_t vpx_svc_init ( SvcContext * svc_ctx , vpx_codec_ctx_t * codec_ctx , vpx_codec_iface_t * iface , vpx_codec_enc_cfg_t * enc_cfg ) {
vpx_codec_err_t res ;
int i ;
SvcInternal * const si = get_svc_internal ( svc_ctx ) ;
if ( svc_ctx == NULL || codec_ctx == NULL || iface == NULL || enc_cfg == NULL ) {
return VPX_CODEC_INVALID_PARAM ;
}
if ( si == NULL ) return VPX_CODEC_MEM_ERROR ;
si -> codec_ctx = codec_ctx ;
si -> width = enc_cfg -> g_w ;
si -> height = enc_cfg -> g_h ;
if ( enc_cfg -> kf_max_dist < 2 ) {
svc_log ( svc_ctx , SVC_LOG_ERROR , "key frame distance too small: %d\n" , enc_cfg -> kf_max_dist ) ;
return VPX_CODEC_INVALID_PARAM ;
}
si -> kf_dist = enc_cfg -> kf_max_dist ;
if ( svc_ctx -> spatial_layers == 0 ) svc_ctx -> spatial_layers = VPX_SS_DEFAULT_LAYERS ;
if ( svc_ctx -> spatial_layers < 1 || svc_ctx -> spatial_layers > VPX_SS_MAX_LAYERS ) {
svc_log ( svc_ctx , SVC_LOG_ERROR , "spatial layers: invalid value: %d\n" , svc_ctx -> spatial_layers ) ;
return VPX_CODEC_INVALID_PARAM ;
}
res = parse_quantizer_values ( svc_ctx , si -> quantizers ) ;
if ( res != VPX_CODEC_OK ) return res ;
res = parse_scale_factors ( svc_ctx , si -> scale_factors ) ;
if ( res != VPX_CODEC_OK ) return res ;
res = parse_options ( svc_ctx , si -> options ) ;
if ( res != VPX_CODEC_OK ) return res ;
if ( svc_ctx -> spatial_layers < 1 ) svc_ctx -> spatial_layers = 1 ;
if ( svc_ctx -> spatial_layers > VPX_SS_MAX_LAYERS ) svc_ctx -> spatial_layers = VPX_SS_MAX_LAYERS ;
if ( svc_ctx -> temporal_layers < 1 ) svc_ctx -> temporal_layers = 1 ;
if ( svc_ctx -> temporal_layers > VPX_TS_MAX_LAYERS ) svc_ctx -> temporal_layers = VPX_TS_MAX_LAYERS ;
si -> layers = svc_ctx -> spatial_layers ;
if ( si -> layers > 1 ) {
float total = 0 ;
float alloc_ratio [ VPX_SS_MAX_LAYERS ] = {
0 }
;
assert ( si -> layers <= VPX_SS_MAX_LAYERS ) ;
for ( i = 0 ;
i < si -> layers ;
++ i ) {
int pos = i + VPX_SS_MAX_LAYERS - svc_ctx -> spatial_layers ;
if ( pos < VPX_SS_MAX_LAYERS && si -> scaling_factor_den [ pos ] > 0 ) {
alloc_ratio [ i ] = ( float ) ( si -> scaling_factor_num [ pos ] * 1.0 / si -> scaling_factor_den [ pos ] ) ;
alloc_ratio [ i ] *= alloc_ratio [ i ] ;
total += alloc_ratio [ i ] ;
}
}
for ( i = 0 ;
i < si -> layers ;
++ i ) {
if ( total > 0 ) {
enc_cfg -> ss_target_bitrate [ i ] = ( unsigned int ) ( enc_cfg -> rc_target_bitrate * alloc_ratio [ i ] / total ) ;
}
}
}
# if CONFIG_SPATIAL_SVC for ( i = 0 ;
i < si -> layers ;
++ i ) enc_cfg -> ss_enable_auto_alt_ref [ i ] = si -> enable_auto_alt_ref [ i ] ;
# endif if ( svc_ctx -> temporal_layers > 1 ) {
int i ;
for ( i = 0 ;
i < svc_ctx -> temporal_layers ;
++ i ) {
enc_cfg -> ts_target_bitrate [ i ] = enc_cfg -> rc_target_bitrate / svc_ctx -> temporal_layers ;
enc_cfg -> ts_rate_decimator [ i ] = 1 << ( svc_ctx -> temporal_layers - 1 - i ) ;
}
}
enc_cfg -> ss_number_layers = si -> layers ;
enc_cfg -> ts_number_layers = svc_ctx -> temporal_layers ;
enc_cfg -> rc_dropframe_thresh = 0 ;
enc_cfg -> rc_resize_allowed = 0 ;
if ( enc_cfg -> g_pass == VPX_RC_ONE_PASS ) {
enc_cfg -> rc_min_quantizer = 33 ;
enc_cfg -> rc_max_quantizer = 33 ;
}
enc_cfg -> rc_undershoot_pct = 100 ;
enc_cfg -> rc_overshoot_pct = 15 ;
enc_cfg -> rc_buf_initial_sz = 500 ;
enc_cfg -> rc_buf_optimal_sz = 600 ;
enc_cfg -> rc_buf_sz = 1000 ;
if ( enc_cfg -> g_error_resilient == 0 && si -> use_multiple_frame_contexts == 0 ) enc_cfg -> g_error_resilient = 1 ;
res = vpx_codec_enc_init ( codec_ctx , iface , enc_cfg , VPX_CODEC_USE_PSNR ) ;
if ( res != VPX_CODEC_OK ) {
svc_log ( svc_ctx , SVC_LOG_ERROR , "svc_enc_init error\n" ) ;
return res ;
}
vpx_codec_control ( codec_ctx , VP9E_SET_SVC , 1 ) ;
vpx_codec_control ( codec_ctx , VP8E_SET_TOKEN_PARTITIONS , 1 ) ;
return VPX_CODEC_OK ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint find_tail ( body_parts * * body_parts_array , guint16 tsn ) {
guint length = 0 ;
for ( tsn = ( tsn + 1 ) % MAX_TSN ;
body_parts_array [ tsn ] -> middle != NULL ;
tsn = ( tsn + 1 ) % MAX_TSN ) length += body_parts_array [ tsn ] -> middle -> length ;
if ( body_parts_array [ tsn ] -> tail != NULL ) return length + body_parts_array [ tsn ] -> tail -> length ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int vbf_allocobj ( struct busyobj * bo , unsigned l ) {
struct objcore * oc ;
const struct stevedore * stv ;
double lifetime ;
CHECK_OBJ_NOTNULL ( bo , BUSYOBJ_MAGIC ) ;
oc = bo -> fetch_objcore ;
CHECK_OBJ_NOTNULL ( oc , OBJCORE_MAGIC ) ;
lifetime = oc -> ttl + oc -> grace + oc -> keep ;
if ( bo -> uncacheable || lifetime < cache_param -> shortlived ) stv = stv_transient ;
else stv = bo -> storage ;
bo -> storage = NULL ;
bo -> storage_hint = NULL ;
if ( stv == NULL ) return ( 0 ) ;
if ( STV_NewObject ( bo -> wrk , bo -> fetch_objcore , stv , l ) ) return ( 1 ) ;
if ( stv == stv_transient ) return ( 0 ) ;
if ( oc -> ttl > cache_param -> shortlived ) oc -> ttl = cache_param -> shortlived ;
oc -> grace = 0.0 ;
oc -> keep = 0.0 ;
return ( STV_NewObject ( bo -> wrk , bo -> fetch_objcore , stv_transient , l ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline void sk_ ## t1 ## _zero ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_zero ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete ( STACK_OF ( t1 ) * sk , int i ) {
return ( t2 * ) OPENSSL_sk_delete ( ( OPENSSL_STACK * ) sk , i ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void exsltMathRegister ( void ) {
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "min" , EXSLT_MATH_NAMESPACE , exsltMathMinFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "max" , EXSLT_MATH_NAMESPACE , exsltMathMaxFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "highest" , EXSLT_MATH_NAMESPACE , exsltMathHighestFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "lowest" , EXSLT_MATH_NAMESPACE , exsltMathLowestFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "constant" , EXSLT_MATH_NAMESPACE , exsltMathConstantFunction ) ;
# ifdef HAVE_STDLIB_H xsltRegisterExtModuleFunction ( ( const xmlChar * ) "random" , EXSLT_MATH_NAMESPACE , exsltMathRandomFunction ) ;
# endif # if HAVE_MATH_H xsltRegisterExtModuleFunction ( ( const xmlChar * ) "abs" , EXSLT_MATH_NAMESPACE , exsltMathAbsFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "sqrt" , EXSLT_MATH_NAMESPACE , exsltMathSqrtFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "power" , EXSLT_MATH_NAMESPACE , exsltMathPowerFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "log" , EXSLT_MATH_NAMESPACE , exsltMathLogFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "sin" , EXSLT_MATH_NAMESPACE , exsltMathSinFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "cos" , EXSLT_MATH_NAMESPACE , exsltMathCosFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "tan" , EXSLT_MATH_NAMESPACE , exsltMathTanFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "asin" , EXSLT_MATH_NAMESPACE , exsltMathAsinFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "acos" , EXSLT_MATH_NAMESPACE , exsltMathAcosFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "atan" , EXSLT_MATH_NAMESPACE , exsltMathAtanFunction ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "atan2" , EXSLT_MATH_NAMESPACE , exsltMathAtan2Function ) ;
xsltRegisterExtModuleFunction ( ( const xmlChar * ) "exp" , EXSLT_MATH_NAMESPACE , exsltMathExpFunction ) ;
# endif }
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void gtkui_inject_user ( int side ) {
size_t len ;
len = strescape ( injectbuf , injectbuf ) ;
if ( side == 1 || side == 2 ) {
user_inject ( injectbuf , len , curr_conn , side ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void nautilus_file_operations_new_file ( GtkWidget * parent_view , GdkPoint * target_point , const char * parent_dir , const char * target_filename , const char * initial_contents , int length , NautilusCreateCallback done_callback , gpointer done_callback_data ) {
GTask * task ;
CreateJob * job ;
GtkWindow * parent_window ;
parent_window = NULL ;
if ( parent_view ) {
parent_window = ( GtkWindow * ) gtk_widget_get_ancestor ( parent_view , GTK_TYPE_WINDOW ) ;
}
job = op_job_new ( CreateJob , parent_window ) ;
job -> done_callback = done_callback ;
job -> done_callback_data = done_callback_data ;
job -> dest_dir = g_file_new_for_uri ( parent_dir ) ;
if ( target_point != NULL ) {
job -> position = * target_point ;
job -> has_position = TRUE ;
}
job -> src_data = g_memdup ( initial_contents , length ) ;
job -> length = length ;
job -> filename = g_strdup ( target_filename ) ;
if ( ! nautilus_file_undo_manager_is_operating ( ) ) {
job -> common . undo_info = nautilus_file_undo_info_create_new ( NAUTILUS_FILE_UNDO_OP_CREATE_EMPTY_FILE ) ;
}
task = g_task_new ( NULL , job -> common . cancellable , create_task_done , job ) ;
g_task_set_task_data ( task , job , NULL ) ;
g_task_run_in_thread ( task , create_task_thread_func ) ;
g_object_unref ( task ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int i2d_PKCS8_fp ( FILE * fp , X509_SIG * p8 ) {
return ASN1_i2d_fp_of ( X509_SIG , i2d_X509_SIG , fp , p8 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int qemuMonitorJSONGetBlockJobInfoOne ( virJSONValuePtr entry , const char * device , virDomainBlockJobInfoPtr info ) {
const char * this_dev ;
const char * type ;
unsigned long long speed_bytes ;
if ( ( this_dev = virJSONValueObjectGetString ( entry , "device" ) ) == NULL ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "entry was missing 'device'" ) ) ;
return - 1 ;
}
if ( ! STREQ ( this_dev , device ) ) return - 1 ;
type = virJSONValueObjectGetString ( entry , "type" ) ;
if ( ! type ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "entry was missing 'type'" ) ) ;
return - 1 ;
}
if ( STREQ ( type , "stream" ) ) info -> type = VIR_DOMAIN_BLOCK_JOB_TYPE_PULL ;
else info -> type = VIR_DOMAIN_BLOCK_JOB_TYPE_UNKNOWN ;
if ( virJSONValueObjectGetNumberUlong ( entry , "speed" , & speed_bytes ) < 0 ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "entry was missing 'speed'" ) ) ;
return - 1 ;
}
info -> bandwidth = speed_bytes / 1024ULL / 1024ULL ;
if ( virJSONValueObjectGetNumberUlong ( entry , "offset" , & info -> cur ) < 0 ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "entry was missing 'offset'" ) ) ;
return - 1 ;
}
if ( virJSONValueObjectGetNumberUlong ( entry , "len" , & info -> end ) < 0 ) {
qemuReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "entry was missing 'len'" ) ) ;
return - 1 ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int zstopped ( i_ctx_t * i_ctx_p ) {
os_ptr op = osp ;
check_op ( 1 ) ;
check_estack ( 5 ) ;
push_mark_estack ( es_stopped , no_cleanup ) ;
++ esp ;
make_false ( esp ) ;
++ esp ;
make_int ( esp , 1 ) ;
push_op_estack ( stopped_push ) ;
push_op_estack ( zexec ) ;
return o_push_estack ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Datum ExecEvalAggref ( AggrefExprState * aggref , ExprContext * econtext , bool * isNull , ExprDoneCond * isDone ) {
if ( isDone ) * isDone = ExprSingleResult ;
if ( econtext -> ecxt_aggvalues == NULL ) elog ( ERROR , "no aggregates in this expression context" ) ;
* isNull = econtext -> ecxt_aggnulls [ aggref -> aggno ] ;
return econtext -> ecxt_aggvalues [ aggref -> aggno ] ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mbfl_strlen ( mbfl_string * string ) {
int len , n , m , k ;
unsigned char * p ;
const unsigned char * mbtab ;
const mbfl_encoding * encoding ;
encoding = mbfl_no2encoding ( string -> no_encoding ) ;
if ( encoding == NULL || string == NULL ) {
return - 1 ;
}
len = 0 ;
if ( encoding -> flag & MBFL_ENCTYPE_SBCS ) {
len = string -> len ;
}
else if ( encoding -> flag & ( MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE ) ) {
len = string -> len / 2 ;
}
else if ( encoding -> flag & ( MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE ) ) {
len = string -> len / 4 ;
}
else if ( encoding -> mblen_table != NULL ) {
mbtab = encoding -> mblen_table ;
n = 0 ;
p = string -> val ;
k = string -> len ;
if ( p != NULL ) {
while ( n < k ) {
m = mbtab [ * p ] ;
n += m ;
p += m ;
len ++ ;
}
;
}
}
else {
mbfl_convert_filter * filter = mbfl_convert_filter_new ( string -> no_encoding , mbfl_no_encoding_wchar , filter_count_output , 0 , & len ) ;
if ( filter == NULL ) {
return - 1 ;
}
n = string -> len ;
p = string -> val ;
if ( p != NULL ) {
while ( n > 0 ) {
( * filter -> filter_function ) ( * p ++ , filter ) ;
n -- ;
}
}
mbfl_convert_filter_delete ( filter ) ;
}
return len ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static jpc_enc_prc_t * prc_create ( jpc_enc_prc_t * prc , jpc_enc_cp_t * cp , jpc_enc_band_t * band ) {
uint_fast32_t prcno ;
uint_fast32_t prcxind ;
uint_fast32_t prcyind ;
uint_fast32_t cbgtlx ;
uint_fast32_t cbgtly ;
uint_fast32_t tlprctlx ;
uint_fast32_t tlprctly ;
uint_fast32_t tlcbgtlx ;
uint_fast32_t tlcbgtly ;
uint_fast16_t rlvlno ;
jpc_enc_rlvl_t * rlvl ;
uint_fast32_t tlcblktlx ;
uint_fast32_t tlcblktly ;
uint_fast32_t brcblkbrx ;
uint_fast32_t brcblkbry ;
uint_fast32_t cblkno ;
jpc_enc_cblk_t * cblk ;
jpc_enc_tcmpt_t * tcmpt ;
prc -> cblks = 0 ;
prc -> incltree = 0 ;
prc -> savincltree = 0 ;
prc -> nlibtree = 0 ;
prc -> savnlibtree = 0 ;
rlvl = band -> rlvl ;
tcmpt = rlvl -> tcmpt ;
rlvlno = rlvl - tcmpt -> rlvls ;
prcno = prc - band -> prcs ;
prcxind = prcno % rlvl -> numhprcs ;
prcyind = prcno / rlvl -> numhprcs ;
prc -> band = band ;
tlprctlx = JPC_FLOORTOMULTPOW2 ( rlvl -> tlx , rlvl -> prcwidthexpn ) ;
tlprctly = JPC_FLOORTOMULTPOW2 ( rlvl -> tly , rlvl -> prcheightexpn ) ;
if ( ! rlvlno ) {
tlcbgtlx = tlprctlx ;
tlcbgtly = tlprctly ;
}
else {
tlcbgtlx = JPC_CEILDIVPOW2 ( tlprctlx , 1 ) ;
tlcbgtly = JPC_CEILDIVPOW2 ( tlprctly , 1 ) ;
}
cbgtlx = tlcbgtlx + ( prcxind << rlvl -> cbgwidthexpn ) ;
cbgtly = tlcbgtly + ( prcyind << rlvl -> cbgheightexpn ) ;
prc -> tlx = JAS_MAX ( jas_seq2d_xstart ( band -> data ) , cbgtlx ) ;
prc -> tly = JAS_MAX ( jas_seq2d_ystart ( band -> data ) , cbgtly ) ;
prc -> brx = JAS_MIN ( jas_seq2d_xend ( band -> data ) , cbgtlx + ( 1 << rlvl -> cbgwidthexpn ) ) ;
prc -> bry = JAS_MIN ( jas_seq2d_yend ( band -> data ) , cbgtly + ( 1 << rlvl -> cbgheightexpn ) ) ;
if ( prc -> tlx < prc -> brx && prc -> tly < prc -> bry ) {
tlcblktlx = JPC_FLOORTOMULTPOW2 ( prc -> tlx , rlvl -> cblkwidthexpn ) ;
tlcblktly = JPC_FLOORTOMULTPOW2 ( prc -> tly , rlvl -> cblkheightexpn ) ;
brcblkbrx = JPC_CEILTOMULTPOW2 ( prc -> brx , rlvl -> cblkwidthexpn ) ;
brcblkbry = JPC_CEILTOMULTPOW2 ( prc -> bry , rlvl -> cblkheightexpn ) ;
prc -> numhcblks = JPC_FLOORDIVPOW2 ( brcblkbrx - tlcblktlx , rlvl -> cblkwidthexpn ) ;
prc -> numvcblks = JPC_FLOORDIVPOW2 ( brcblkbry - tlcblktly , rlvl -> cblkheightexpn ) ;
prc -> numcblks = prc -> numhcblks * prc -> numvcblks ;
if ( ! ( prc -> incltree = jpc_tagtree_create ( prc -> numhcblks , prc -> numvcblks ) ) ) {
goto error ;
}
if ( ! ( prc -> nlibtree = jpc_tagtree_create ( prc -> numhcblks , prc -> numvcblks ) ) ) {
goto error ;
}
if ( ! ( prc -> savincltree = jpc_tagtree_create ( prc -> numhcblks , prc -> numvcblks ) ) ) {
goto error ;
}
if ( ! ( prc -> savnlibtree = jpc_tagtree_create ( prc -> numhcblks , prc -> numvcblks ) ) ) {
goto error ;
}
if ( ! ( prc -> cblks = jas_alloc2 ( prc -> numcblks , sizeof ( jpc_enc_cblk_t ) ) ) ) {
goto error ;
}
for ( cblkno = 0 , cblk = prc -> cblks ;
cblkno < prc -> numcblks ;
++ cblkno , ++ cblk ) {
cblk -> passes = 0 ;
cblk -> stream = 0 ;
cblk -> mqenc = 0 ;
cblk -> data = 0 ;
cblk -> flags = 0 ;
cblk -> prc = prc ;
}
for ( cblkno = 0 , cblk = prc -> cblks ;
cblkno < prc -> numcblks ;
++ cblkno , ++ cblk ) {
if ( ! cblk_create ( cblk , cp , prc ) ) {
goto error ;
}
}
}
else {
prc -> tlx = prc -> brx ;
prc -> tly = prc -> bry ;
prc -> numcblks = 0 ;
prc -> numhcblks = 0 ;
prc -> numvcblks = 0 ;
prc -> cblks = 0 ;
prc -> incltree = 0 ;
prc -> nlibtree = 0 ;
prc -> savincltree = 0 ;
prc -> savnlibtree = 0 ;
}
return prc ;
error : prc_destroy ( prc ) ;
return 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
const EVP_CIPHER * EVP_aes_ ## keylen ## _ ## mode ( void ) \ {
return & aes_ ## keylen ## _ ## mode ;
}
# define BLOCK_CIPHER_custom ( nid , keylen , blocksize , ivlen , mode , MODE , flags ) static const EVP_CIPHER aes_ ## keylen ## _ ## mode = {
\ nid ## _ ## keylen ## _ ## mode , blocksize , \ ( EVP_CIPH_ ## MODE ## _MODE == EVP_CIPH_XTS_MODE ? 2 : 1 ) * keylen / 8 , ivlen , \ flags | EVP_CIPH_ ## MODE ## _MODE , \ aes_ ## mode ## _init_key , \ aes_ ## mode ## _cipher , \ aes_ ## mode ## _cleanup , \ sizeof ( EVP_AES_ ## MODE ## _CTX ) , \ NULL , NULL , aes_ ## mode ## _ctrl , NULL }
;
const EVP_CIPHER * EVP_aes_ ## keylen ## _ ## mode ( void ) \ {
return & aes_ ## keylen ## _ ## mode ;
}
# endif # if defined ( OPENSSL_CPUID_OBJ ) && ( defined ( __arm__ ) || defined ( __arm ) || defined ( __aarch64__ ) ) # include "arm_arch.h" # if __ARM_MAX_ARCH__ >= 7 # if defined ( BSAES_ASM ) # define BSAES_CAPABLE ( OPENSSL_armcap_P & ARMV7_NEON ) # endif # if defined ( VPAES_ASM ) # define VPAES_CAPABLE ( OPENSSL_armcap_P & ARMV7_NEON ) # endif # define HWAES_CAPABLE ( OPENSSL_armcap_P & ARMV8_AES ) # define HWAES_set_encrypt_key aes_v8_set_encrypt_key # define HWAES_set_decrypt_key aes_v8_set_decrypt_key # define HWAES_encrypt aes_v8_encrypt # define HWAES_decrypt aes_v8_decrypt # define HWAES_cbc_encrypt aes_v8_cbc_encrypt # define HWAES_ctr32_encrypt_blocks aes_v8_ctr32_encrypt_blocks # endif # endif # if defined ( HWAES_CAPABLE ) int HWAES_set_encrypt_key ( const unsigned char * userKey , const int bits , AES_KEY * key ) ;
int HWAES_set_decrypt_key ( const unsigned char * userKey , const int bits , AES_KEY * key ) ;
void HWAES_encrypt ( const unsigned char * in , unsigned char * out , const AES_KEY * key ) ;
void HWAES_decrypt ( const unsigned char * in , unsigned char * out , const AES_KEY * key ) ;
void HWAES_cbc_encrypt ( const unsigned char * in , unsigned char * out , size_t length , const AES_KEY * key , unsigned char * ivec , const int enc ) ;
void HWAES_ctr32_encrypt_blocks ( const unsigned char * in , unsigned char * out , size_t len , const AES_KEY * key , const unsigned char ivec [ 16 ] ) ;
void HWAES_xts_encrypt ( const unsigned char * inp , unsigned char * out , size_t len , const AES_KEY * key1 , const AES_KEY * key2 , const unsigned char iv [ 16 ] ) ;
void HWAES_xts_decrypt ( const unsigned char * inp , unsigned char * out , size_t len , const AES_KEY * key1 , const AES_KEY * key2 , const unsigned char iv [ 16 ] ) ;
# endif # define BLOCK_CIPHER_generic_pack ( nid , keylen , flags ) \ BLOCK_CIPHER_generic ( nid , keylen , 16 , 16 , cbc , cbc , CBC , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 16 , 0 , ecb , ecb , ECB , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , ofb128 , ofb , OFB , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , cfb128 , cfb , CFB , flags | EVP_CIPH_FLAG_DEFAULT_ASN1 ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , cfb1 , cfb1 , CFB , flags ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , cfb8 , cfb8 , CFB , flags ) \ BLOCK_CIPHER_generic ( nid , keylen , 1 , 16 , ctr , ctr , CTR , flags ) static int aes_init_key ( EVP_CIPHER_CTX * ctx , const unsigned char * key , const unsigned char * iv , int enc ) {
int ret , mode ;
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
mode = EVP_CIPHER_CTX_mode ( ctx ) ;
if ( ( mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE ) && ! enc ) {
# ifdef HWAES_CAPABLE if ( HWAES_CAPABLE ) {
ret = HWAES_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) HWAES_decrypt ;
dat -> stream . cbc = NULL ;
# ifdef HWAES_cbc_encrypt if ( mode == EVP_CIPH_CBC_MODE ) dat -> stream . cbc = ( cbc128_f ) HWAES_cbc_encrypt ;
# endif }
else # endif # ifdef BSAES_CAPABLE if ( BSAES_CAPABLE && mode == EVP_CIPH_CBC_MODE ) {
ret = AES_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_decrypt ;
dat -> stream . cbc = ( cbc128_f ) bsaes_cbc_encrypt ;
}
else # endif # ifdef VPAES_CAPABLE if ( VPAES_CAPABLE ) {
ret = vpaes_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) vpaes_decrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) vpaes_cbc_encrypt : NULL ;
}
else # endif {
ret = AES_set_decrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_decrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) AES_cbc_encrypt : NULL ;
}
}
else # ifdef HWAES_CAPABLE if ( HWAES_CAPABLE ) {
ret = HWAES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) HWAES_encrypt ;
dat -> stream . cbc = NULL ;
# ifdef HWAES_cbc_encrypt if ( mode == EVP_CIPH_CBC_MODE ) dat -> stream . cbc = ( cbc128_f ) HWAES_cbc_encrypt ;
else # endif # ifdef HWAES_ctr32_encrypt_blocks if ( mode == EVP_CIPH_CTR_MODE ) dat -> stream . ctr = ( ctr128_f ) HWAES_ctr32_encrypt_blocks ;
else # endif ( void ) 0 ;
}
else # endif # ifdef BSAES_CAPABLE if ( BSAES_CAPABLE && mode == EVP_CIPH_CTR_MODE ) {
ret = AES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_encrypt ;
dat -> stream . ctr = ( ctr128_f ) bsaes_ctr32_encrypt_blocks ;
}
else # endif # ifdef VPAES_CAPABLE if ( VPAES_CAPABLE ) {
ret = vpaes_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) vpaes_encrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) vpaes_cbc_encrypt : NULL ;
}
else # endif {
ret = AES_set_encrypt_key ( key , EVP_CIPHER_CTX_key_length ( ctx ) * 8 , & dat -> ks . ks ) ;
dat -> block = ( block128_f ) AES_encrypt ;
dat -> stream . cbc = mode == EVP_CIPH_CBC_MODE ? ( cbc128_f ) AES_cbc_encrypt : NULL ;
# ifdef AES_CTR_ASM if ( mode == EVP_CIPH_CTR_MODE ) dat -> stream . ctr = ( ctr128_f ) AES_ctr32_encrypt ;
# endif }
if ( ret < 0 ) {
EVPerr ( EVP_F_AES_INIT_KEY , EVP_R_AES_KEY_SETUP_FAILED ) ;
return 0 ;
}
return 1 ;
}
static int aes_cbc_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( dat -> stream . cbc ) ( * dat -> stream . cbc ) ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_encrypting ( ctx ) ) ;
else if ( EVP_CIPHER_CTX_encrypting ( ctx ) ) CRYPTO_cbc128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , dat -> block ) ;
else CRYPTO_cbc128_decrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , dat -> block ) ;
return 1 ;
}
static int aes_ecb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
size_t bl = EVP_CIPHER_CTX_block_size ( ctx ) ;
size_t i ;
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( len < bl ) return 1 ;
for ( i = 0 , len -= bl ;
i <= len ;
i += bl ) ( * dat -> block ) ( in + i , out + i , & dat -> ks ) ;
return 1 ;
}
static int aes_ofb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_ofb128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
static int aes_cfb_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
static int aes_cfb8_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_8_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
static int aes_cfb1_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( EVP_CIPHER_CTX_test_flags ( ctx , EVP_CIPH_FLAG_LENGTH_BITS ) ) {
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_1_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
while ( len >= MAXBITCHUNK ) {
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_1_encrypt ( in , out , MAXBITCHUNK * 8 , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
len -= MAXBITCHUNK ;
}
if ( len ) {
int num = EVP_CIPHER_CTX_num ( ctx ) ;
CRYPTO_cfb128_1_encrypt ( in , out , len * 8 , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , & num , EVP_CIPHER_CTX_encrypting ( ctx ) , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
}
return 1 ;
}
static int aes_ctr_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
unsigned int num = EVP_CIPHER_CTX_num ( ctx ) ;
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( dat -> stream . ctr ) CRYPTO_ctr128_encrypt_ctr32 ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_buf_noconst ( ctx ) , & num , dat -> stream . ctr ) ;
else CRYPTO_ctr128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_buf_noconst ( ctx ) , & num , dat -> block ) ;
EVP_CIPHER_CTX_set_num ( ctx , num ) ;
return 1 ;
}
BLOCK_CIPHER_generic_pack ( NID_aes , 128 , 0 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ProtocolHandlerRegistryTest , TestRemoveHandler ) {
ProtocolHandler ph1 = CreateProtocolHandler ( "test" , "test1" ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph1 ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph1 ) ;
registry ( ) -> RemoveHandler ( ph1 ) ;
ASSERT_FALSE ( registry ( ) -> IsRegistered ( ph1 ) ) ;
ASSERT_FALSE ( registry ( ) -> IsHandledProtocol ( "test" ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_cell_data ( Indeo3DecodeContext * ctx , Cell * cell , uint8_t * block , uint8_t * ref_block , int pitch , int h_zoom , int v_zoom , int mode , const vqEntry * delta [ 2 ] , int swap_quads [ 2 ] , const uint8_t * * data_ptr , const uint8_t * last_ptr ) {
int x , y , line , num_lines ;
int rle_blocks = 0 ;
uint8_t code , * dst , * ref ;
const vqEntry * delta_tab ;
unsigned int dyad1 , dyad2 ;
uint64_t pix64 ;
int skip_flag = 0 , is_top_of_cell , is_first_row = 1 ;
int row_offset , blk_row_offset , line_offset ;
row_offset = pitch ;
blk_row_offset = ( row_offset << ( 2 + v_zoom ) ) - ( cell -> width << 2 ) ;
line_offset = v_zoom ? row_offset : 0 ;
if ( cell -> height & v_zoom || cell -> width & h_zoom ) return IV3_BAD_DATA ;
for ( y = 0 ;
y < cell -> height ;
is_first_row = 0 , y += 1 + v_zoom ) {
for ( x = 0 ;
x < cell -> width ;
x += 1 + h_zoom ) {
ref = ref_block ;
dst = block ;
if ( rle_blocks > 0 ) {
if ( mode <= 4 ) {
RLE_BLOCK_COPY ;
}
else if ( mode == 10 && ! cell -> mv_ptr ) {
RLE_BLOCK_COPY_8 ;
}
rle_blocks -- ;
}
else {
for ( line = 0 ;
line < 4 ;
) {
num_lines = 1 ;
is_top_of_cell = is_first_row && ! line ;
if ( mode <= 4 ) delta_tab = delta [ line & 1 ] ;
else delta_tab = delta [ 1 ] ;
BUFFER_PRECHECK ;
code = bytestream_get_byte ( data_ptr ) ;
if ( code < 248 ) {
if ( code < delta_tab -> num_dyads ) {
BUFFER_PRECHECK ;
dyad1 = bytestream_get_byte ( data_ptr ) ;
dyad2 = code ;
if ( dyad1 >= delta_tab -> num_dyads || dyad1 >= 248 ) return IV3_BAD_DATA ;
}
else {
code -= delta_tab -> num_dyads ;
dyad1 = code / delta_tab -> quad_exp ;
dyad2 = code % delta_tab -> quad_exp ;
if ( swap_quads [ line & 1 ] ) FFSWAP ( unsigned int , dyad1 , dyad2 ) ;
}
if ( mode <= 4 ) {
APPLY_DELTA_4 ;
}
else if ( mode == 10 && ! cell -> mv_ptr ) {
APPLY_DELTA_8 ;
}
else {
APPLY_DELTA_1011_INTER ;
}
}
else {
switch ( code ) {
case RLE_ESC_FC : skip_flag = 0 ;
rle_blocks = 1 ;
code = 253 ;
case RLE_ESC_FF : case RLE_ESC_FE : case RLE_ESC_FD : num_lines = 257 - code - line ;
if ( num_lines <= 0 ) return IV3_BAD_RLE ;
if ( mode <= 4 ) {
RLE_LINES_COPY ;
}
else if ( mode == 10 && ! cell -> mv_ptr ) {
RLE_LINES_COPY_M10 ;
}
break ;
case RLE_ESC_FB : BUFFER_PRECHECK ;
code = bytestream_get_byte ( data_ptr ) ;
rle_blocks = ( code & 0x1F ) - 1 ;
if ( code >= 64 || rle_blocks < 0 ) return IV3_BAD_COUNTER ;
skip_flag = code & 0x20 ;
num_lines = 4 - line ;
if ( mode >= 10 || ( cell -> mv_ptr || ! skip_flag ) ) {
if ( mode <= 4 ) {
RLE_LINES_COPY ;
}
else if ( mode == 10 && ! cell -> mv_ptr ) {
RLE_LINES_COPY_M10 ;
}
}
break ;
case RLE_ESC_F9 : skip_flag = 1 ;
rle_blocks = 1 ;
case RLE_ESC_FA : if ( line ) return IV3_BAD_RLE ;
num_lines = 4 ;
if ( cell -> mv_ptr ) {
if ( mode <= 4 ) {
RLE_LINES_COPY ;
}
else if ( mode == 10 && ! cell -> mv_ptr ) {
RLE_LINES_COPY_M10 ;
}
}
break ;
default : return IV3_UNSUPPORTED ;
}
}
line += num_lines ;
ref += row_offset * ( num_lines << v_zoom ) ;
dst += row_offset * ( num_lines << v_zoom ) ;
}
}
block += 4 << h_zoom ;
ref_block += 4 << h_zoom ;
}
ref_block += blk_row_offset ;
block += blk_row_offset ;
}
return IV3_NOERR ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * unsigned32_avp ( diam_ctx_t * c , diam_avp_t * a , tvbuff_t * tvb , diam_sub_dis_t * diam_sub_dis_inf _U_ ) {
char * label = NULL ;
proto_item * pi ;
gint length = tvb_reported_length ( tvb ) ;
if ( length == 4 ) {
if ( c -> tree ) {
pi = proto_tree_add_item ( c -> tree , a -> hf_value , tvb , 0 , length , ENC_BIG_ENDIAN ) ;
label = ( char * ) wmem_alloc ( wmem_packet_scope ( ) , ITEM_LABEL_LENGTH + 1 ) ;
proto_item_fill_label ( PITEM_FINFO ( pi ) , label ) ;
label = strstr ( label , ": " ) + 2 ;
}
}
else {
pi = proto_tree_add_bytes_format ( c -> tree , hf_diameter_avp_data_wrong_length , tvb , 0 , length , NULL , "Error! Bad Unsigned32 Length" ) ;
expert_add_info_format ( c -> pinfo , pi , & ei_diameter_avp_len , "Bad Unsigned32 Length (%u)" , length ) ;
PROTO_ITEM_SET_GENERATED ( pi ) ;
}
return label ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static my_bool get_one_option ( int optid , const struct my_option * opt __attribute__ ( ( unused ) ) , char * argument ) {
switch ( optid ) {
case 'p' : if ( argument == disabled_my_option ) argument = ( char * ) "" ;
if ( argument ) {
char * start = argument ;
my_free ( opt_password ) ;
opt_password = my_strdup ( argument , MYF ( MY_FAE ) ) ;
while ( * argument ) * argument ++ = 'x' ;
if ( * start ) start [ 1 ] = 0 ;
tty_password = 0 ;
}
else tty_password = 1 ;
break ;
case 'r' : if ( ! ( md_result_file = my_fopen ( argument , O_WRONLY | FILE_BINARY , MYF ( MY_WME ) ) ) ) exit ( 1 ) ;
break ;
case 'W' : # ifdef __WIN__ opt_protocol = MYSQL_PROTOCOL_PIPE ;
# endif break ;
case 'N' : opt_set_charset = 0 ;
break ;
case 'T' : opt_disable_keys = 0 ;
if ( strlen ( argument ) >= FN_REFLEN ) {
die ( EX_USAGE , "Input filename too long: %s" , argument ) ;
}
break ;
case '#' : DBUG_PUSH ( argument ? argument : default_dbug_option ) ;
debug_check_flag = 1 ;
break ;
# include < sslopt - case . h > case 'V' : print_version ( ) ;
exit ( 0 ) ;
case 'X' : opt_xml = 1 ;
extended_insert = opt_drop = opt_lock = opt_disable_keys = opt_autocommit = opt_create_db = 0 ;
break ;
case 'i' : opt_comments_used = 1 ;
break ;
case 'I' : case '?' : usage ( ) ;
exit ( 0 ) ;
case ( int ) OPT_MASTER_DATA : if ( ! argument ) opt_master_data = MYSQL_OPT_MASTER_DATA_EFFECTIVE_SQL ;
break ;
case ( int ) OPT_MYSQLDUMP_SLAVE_DATA : if ( ! argument ) opt_slave_data = MYSQL_OPT_SLAVE_DATA_EFFECTIVE_SQL ;
break ;
case ( int ) OPT_OPTIMIZE : extended_insert = opt_drop = opt_lock = quick = create_options = opt_disable_keys = lock_tables = opt_set_charset = 1 ;
break ;
case ( int ) OPT_SKIP_OPTIMIZATION : extended_insert = opt_drop = opt_lock = quick = create_options = opt_disable_keys = lock_tables = opt_set_charset = 0 ;
break ;
case ( int ) OPT_COMPACT : if ( opt_compact ) {
opt_comments = opt_drop = opt_disable_keys = opt_lock = 0 ;
opt_set_charset = 0 ;
}
break ;
case ( int ) OPT_TABLES : opt_databases = 0 ;
break ;
case ( int ) OPT_IGNORE_TABLE : {
if ( ! strchr ( argument , '.' ) ) {
fprintf ( stderr , "Illegal use of option --ignore-table=<database>.<table>\n" ) ;
exit ( 1 ) ;
}
if ( my_hash_insert ( & ignore_table , ( uchar * ) my_strdup ( argument , MYF ( 0 ) ) ) ) exit ( EX_EOM ) ;
break ;
}
case ( int ) OPT_COMPATIBLE : {
char buff [ 255 ] ;
char * end = compatible_mode_normal_str ;
int i ;
ulong mode ;
uint err_len ;
opt_quoted = 1 ;
opt_set_charset = 0 ;
opt_compatible_mode_str = argument ;
opt_compatible_mode = find_set ( & compatible_mode_typelib , argument , strlen ( argument ) , & err_ptr , & err_len ) ;
if ( err_len ) {
strmake ( buff , err_ptr , min ( sizeof ( buff ) - 1 , err_len ) ) ;
fprintf ( stderr , "Invalid mode to --compatible: %s\n" , buff ) ;
exit ( 1 ) ;
}
# if ! defined ( DBUG_OFF ) {
size_t size_for_sql_mode = 0 ;
const char * * ptr ;
for ( ptr = compatible_mode_names ;
* ptr ;
ptr ++ ) size_for_sql_mode += strlen ( * ptr ) ;
size_for_sql_mode += sizeof ( compatible_mode_names ) - 1 ;
DBUG_ASSERT ( sizeof ( compatible_mode_normal_str ) >= size_for_sql_mode ) ;
}
# endif mode = opt_compatible_mode ;
for ( i = 0 , mode = opt_compatible_mode ;
mode ;
mode >>= 1 , i ++ ) {
if ( mode & 1 ) {
end = strmov ( end , compatible_mode_names [ i ] ) ;
end = strmov ( end , "," ) ;
}
}
if ( end != compatible_mode_normal_str ) end [ - 1 ] = 0 ;
if ( default_charset == mysql_universal_client_charset ) default_charset = ( char * ) MYSQL_DEFAULT_CHARSET_NAME ;
break ;
}
case ( int ) OPT_MYSQL_PROTOCOL : opt_protocol = find_type_or_exit ( argument , & sql_protocol_typelib , opt -> name ) ;
break ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_file_receive ( struct file * file ) {
const struct cred * cred = current_cred ( ) ;
return file_has_perm ( cred , file , file_to_av ( file ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _kill_job_on_msg_fail ( uint32_t job_id ) {
slurmctld_lock_t job_write_lock = {
NO_LOCK , WRITE_LOCK , WRITE_LOCK , NO_LOCK , READ_LOCK }
;
error ( "Job allocate response msg send failure, killing JobId=%u" , job_id ) ;
lock_slurmctld ( job_write_lock ) ;
job_complete ( job_id , slurmctld_conf . slurm_user_id , false , false , SIGTERM ) ;
unlock_slurmctld ( job_write_lock ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void walk_splay ( cmap_splay * tree , unsigned int node , void ( * fn ) ( cmap_splay * , void * ) , void * arg ) {
int from = TOP ;
while ( node != EMPTY ) {
switch ( from ) {
case TOP : if ( tree [ node ] . left != EMPTY ) {
node = tree [ node ] . left ;
from = TOP ;
break ;
}
case LEFT : fn ( & tree [ node ] , arg ) ;
if ( tree [ node ] . right != EMPTY ) {
node = tree [ node ] . right ;
from = TOP ;
break ;
}
case RIGHT : {
unsigned int parent = tree [ node ] . parent ;
if ( parent == EMPTY ) return ;
if ( tree [ parent ] . left == node ) from = LEFT ;
else {
assert ( tree [ parent ] . right == node ) ;
from = RIGHT ;
}
node = parent ;
}
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline dma_addr_t xhci_mask64 ( uint64_t addr ) {
if ( sizeof ( dma_addr_t ) == 4 ) {
return addr & 0xffffffff ;
}
else {
return addr ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint64_t nvic_sysreg_read ( void * opaque , hwaddr addr , unsigned size ) {
nvic_state * s = ( nvic_state * ) opaque ;
uint32_t offset = addr ;
int i ;
uint32_t val ;
switch ( offset ) {
case 0xd18 ... 0xd23 : val = 0 ;
for ( i = 0 ;
i < size ;
i ++ ) {
val |= s -> gic . priority1 [ ( offset - 0xd14 ) + i ] [ 0 ] << ( i * 8 ) ;
}
return val ;
case 0xfe0 ... 0xfff : if ( offset & 3 ) {
return 0 ;
}
return nvic_id [ ( offset - 0xfe0 ) >> 2 ] ;
}
if ( size == 4 ) {
return nvic_readl ( s , offset ) ;
}
qemu_log_mask ( LOG_GUEST_ERROR , "NVIC: Bad read of size %d at offset 0x%x\n" , size , offset ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionServiceSyncTest , ReenableDisabledExtensionFromSync ) {
InitializeEmptyExtensionService ( ) ;
browser_sync : : ProfileSyncService * sync_service = ProfileSyncServiceFactory : : GetForProfile ( profile ( ) ) ;
sync_service -> SetFirstSetupComplete ( ) ;
service ( ) -> Init ( ) ;
extensions : : ChromeTestExtensionLoader extension_loader ( profile ( ) ) ;
extension_loader . set_pack_extension ( true ) ;
scoped_refptr < const Extension > extension = extension_loader . LoadExtension ( data_dir ( ) . AppendASCII ( "simple_with_file" ) ) ;
ASSERT_TRUE ( extension ) ;
const std : : string kExtensionId = extension -> id ( ) ;
ASSERT_TRUE ( registry ( ) -> enabled_extensions ( ) . GetByID ( kExtensionId ) ) ;
syncer : : FakeSyncChangeProcessor * processor_raw = nullptr ;
{
auto processor = base : : MakeUnique < syncer : : FakeSyncChangeProcessor > ( ) ;
processor_raw = processor . get ( ) ;
extension_sync_service ( ) -> MergeDataAndStartSyncing ( syncer : : EXTENSIONS , syncer : : SyncDataList ( ) , std : : move ( processor ) , base : : MakeUnique < syncer : : SyncErrorFactoryMock > ( ) ) ;
}
processor_raw -> changes ( ) . clear ( ) ;
DisableExtensionFromSync ( * extension , extensions : : disable_reason : : DISABLE_USER_ACTION ) ;
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . GetByID ( kExtensionId ) ) ;
EXPECT_EQ ( extensions : : disable_reason : : DISABLE_USER_ACTION , ExtensionPrefs : : Get ( profile ( ) ) -> GetDisableReasons ( kExtensionId ) ) ;
EXPECT_TRUE ( processor_raw -> changes ( ) . empty ( ) ) ;
service ( ) -> EnableExtension ( kExtensionId ) ;
{
ASSERT_EQ ( 1u , processor_raw -> changes ( ) . size ( ) ) ;
const SyncChange & change = processor_raw -> changes ( ) [ 0 ] ;
EXPECT_EQ ( SyncChange : : ACTION_UPDATE , change . change_type ( ) ) ;
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncData ( change . sync_data ( ) ) ;
EXPECT_EQ ( kExtensionId , data -> id ( ) ) ;
EXPECT_EQ ( 0 , data -> disable_reasons ( ) ) ;
EXPECT_TRUE ( data -> enabled ( ) ) ;
}
processor_raw -> changes ( ) . clear ( ) ;
service ( ) -> DisableExtension ( kExtensionId , extensions : : disable_reason : : DISABLE_USER_ACTION ) ;
EXPECT_TRUE ( registry ( ) -> disabled_extensions ( ) . GetByID ( kExtensionId ) ) ;
{
ASSERT_EQ ( 1u , processor_raw -> changes ( ) . size ( ) ) ;
const SyncChange & change = processor_raw -> changes ( ) [ 0 ] ;
EXPECT_EQ ( SyncChange : : ACTION_UPDATE , change . change_type ( ) ) ;
std : : unique_ptr < ExtensionSyncData > data = ExtensionSyncData : : CreateFromSyncData ( change . sync_data ( ) ) ;
EXPECT_EQ ( kExtensionId , data -> id ( ) ) ;
EXPECT_EQ ( extensions : : disable_reason : : DISABLE_USER_ACTION , data -> disable_reasons ( ) ) ;
EXPECT_FALSE ( data -> enabled ( ) ) ;
}
processor_raw -> changes ( ) . clear ( ) ;
EnableExtensionFromSync ( * extension ) ;
EXPECT_TRUE ( registry ( ) -> enabled_extensions ( ) . GetByID ( kExtensionId ) ) ;
EXPECT_TRUE ( processor_raw -> changes ( ) . empty ( ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ivi_huff_desc_cmp ( const IVIHuffDesc * desc1 , const IVIHuffDesc * desc2 ) {
return desc1 -> num_rows != desc2 -> num_rows || memcmp ( desc1 -> xbits , desc2 -> xbits , desc1 -> num_rows ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ASN1_BIT_STRING * obj_to_asn1bstr ( VALUE obj , long unused_bits ) {
ASN1_BIT_STRING * bstr ;
if ( unused_bits < 0 ) unused_bits = 0 ;
StringValue ( obj ) ;
if ( ! ( bstr = ASN1_BIT_STRING_new ( ) ) ) ossl_raise ( eASN1Error , NULL ) ;
ASN1_BIT_STRING_set ( bstr , ( unsigned char * ) RSTRING_PTR ( obj ) , RSTRING_LENINT ( obj ) ) ;
bstr -> flags &= ~ ( ASN1_STRING_FLAG_BITS_LEFT | 0x07 ) ;
bstr -> flags |= ASN1_STRING_FLAG_BITS_LEFT | ( unused_bits & 0x07 ) ;
return bstr ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ACL_USER * find_acl_user ( const char * host , const char * user , my_bool exact ) {
DBUG_ENTER ( "find_acl_user" ) ;
DBUG_PRINT ( "enter" , ( "host: '%s' user: '%s'" , host , user ) ) ;
safe_mutex_assert_owner ( & acl_cache -> lock ) ;
for ( uint i = 0 ;
i < acl_users . elements ;
i ++ ) {
ACL_USER * acl_user = dynamic_element ( & acl_users , i , ACL_USER * ) ;
DBUG_PRINT ( "info" , ( "strcmp('%s','%s'), compare_hostname('%s','%s')," , user , acl_user -> user ? acl_user -> user : "" , host , acl_user -> host . hostname ? acl_user -> host . hostname : "" ) ) ;
if ( ( ! acl_user -> user && ! user [ 0 ] ) || ( acl_user -> user && ! strcmp ( user , acl_user -> user ) ) ) {
if ( exact ? ! my_strcasecmp ( system_charset_info , host , acl_user -> host . hostname ? acl_user -> host . hostname : "" ) : compare_hostname ( & acl_user -> host , host , host ) ) {
DBUG_RETURN ( acl_user ) ;
}
}
}
DBUG_RETURN ( 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int PEM_write_ ## name ( FILE * fp , const type * x ) ;
# define DECLARE_PEM_write_cb_fp ( name , type ) int PEM_write_ ## name ( FILE * fp , type * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cb , void * u ) ;
# endif # define DECLARE_PEM_read_bio ( name , type ) type * PEM_read_bio_ ## name ( BIO * bp , type * * x , pem_password_cb * cb , void * u ) ;
# define DECLARE_PEM_write_bio ( name , type ) int PEM_write_bio_ ## name ( BIO * bp , type * x ) ;
# define DECLARE_PEM_write_bio_const ( name , type ) int PEM_write_bio_ ## name ( BIO * bp , const type * x ) ;
# define DECLARE_PEM_write_cb_bio ( name , type ) int PEM_write_bio_ ## name ( BIO * bp , type * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cb , void * u ) ;
# define DECLARE_PEM_write ( name , type ) DECLARE_PEM_write_bio ( name , type ) DECLARE_PEM_write_fp ( name , type ) # define DECLARE_PEM_write_const ( name , type ) DECLARE_PEM_write_bio_const ( name , type ) DECLARE_PEM_write_fp_const ( name , type ) # define DECLARE_PEM_write_cb ( name , type ) DECLARE_PEM_write_cb_bio ( name , type ) DECLARE_PEM_write_cb_fp ( name , type ) # define DECLARE_PEM_read ( name , type ) DECLARE_PEM_read_bio ( name , type ) DECLARE_PEM_read_fp ( name , type ) # define DECLARE_PEM_rw ( name , type ) DECLARE_PEM_read ( name , type ) DECLARE_PEM_write ( name , type ) # define DECLARE_PEM_rw_const ( name , type ) DECLARE_PEM_read ( name , type ) DECLARE_PEM_write_const ( name , type ) # define DECLARE_PEM_rw_cb ( name , type ) DECLARE_PEM_read ( name , type ) DECLARE_PEM_write_cb ( name , type ) typedef int pem_password_cb ( char * buf , int size , int rwflag , void * userdata ) ;
int PEM_get_EVP_CIPHER_INFO ( char * header , EVP_CIPHER_INFO * cipher ) ;
int PEM_do_header ( EVP_CIPHER_INFO * cipher , unsigned char * data , long * len , pem_password_cb * callback , void * u ) ;
int PEM_read_bio ( BIO * bp , char * * name , char * * header , unsigned char * * data , long * len ) ;
# define PEM_FLAG_SECURE 0x1 # define PEM_FLAG_EAY_COMPATIBLE 0x2 # define PEM_FLAG_ONLY_B64 0x4 int PEM_read_bio_ex ( BIO * bp , char * * name , char * * header , unsigned char * * data , long * len , unsigned int flags ) ;
int PEM_bytes_read_bio_secmem ( unsigned char * * pdata , long * plen , char * * pnm , const char * name , BIO * bp , pem_password_cb * cb , void * u ) ;
int PEM_write_bio ( BIO * bp , const char * name , const char * hdr , const unsigned char * data , long len ) ;
int PEM_bytes_read_bio ( unsigned char * * pdata , long * plen , char * * pnm , const char * name , BIO * bp , pem_password_cb * cb , void * u ) ;
void * PEM_ASN1_read_bio ( d2i_of_void * d2i , const char * name , BIO * bp , void * * x , pem_password_cb * cb , void * u ) ;
int PEM_ASN1_write_bio ( i2d_of_void * i2d , const char * name , BIO * bp , void * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cb , void * u ) ;
STACK_OF ( X509_INFO ) * PEM_X509_INFO_read_bio ( BIO * bp , STACK_OF ( X509_INFO ) * sk , pem_password_cb * cb , void * u ) ;
int PEM_X509_INFO_write_bio ( BIO * bp , X509_INFO * xi , EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * cd , void * u ) ;
# ifndef OPENSSL_NO_STDIO int PEM_read ( FILE * fp , char * * name , char * * header , unsigned char * * data , long * len ) ;
int PEM_write ( FILE * fp , const char * name , const char * hdr , const unsigned char * data , long len ) ;
void * PEM_ASN1_read ( d2i_of_void * d2i , const char * name , FILE * fp , void * * x , pem_password_cb * cb , void * u ) ;
int PEM_ASN1_write ( i2d_of_void * i2d , const char * name , FILE * fp , void * x , const EVP_CIPHER * enc , unsigned char * kstr , int klen , pem_password_cb * callback , void * u ) ;
STACK_OF ( X509_INFO ) * PEM_X509_INFO_read ( FILE * fp , STACK_OF ( X509_INFO ) * sk , pem_password_cb * cb , void * u ) ;
# endif int PEM_SignInit ( EVP_MD_CTX * ctx , EVP_MD * type ) ;
int PEM_SignUpdate ( EVP_MD_CTX * ctx , unsigned char * d , unsigned int cnt ) ;
int PEM_SignFinal ( EVP_MD_CTX * ctx , unsigned char * sigret , unsigned int * siglen , EVP_PKEY * pkey ) ;
int PEM_def_callback ( char * buf , int num , int rwflag , void * userdata ) ;
void PEM_proc_type ( char * buf , int type ) ;
void PEM_dek_info ( char * buf , const char * type , int len , char * str ) ;
# include < openssl / symhacks . h > DECLARE_PEM_rw ( X509 , X509 ) DECLARE_PEM_rw ( X509_AUX , X509 ) DECLARE_PEM_rw ( X509_REQ , X509_REQ ) DECLARE_PEM_write ( X509_REQ_NEW , X509_REQ ) DECLARE_PEM_rw ( X509_CRL , X509_CRL ) DECLARE_PEM_rw ( PKCS7 , PKCS7 ) DECLARE_PEM_rw ( NETSCAPE_CERT_SEQUENCE , NETSCAPE_CERT_SEQUENCE ) DECLARE_PEM_rw ( PKCS8 , X509_SIG ) DECLARE_PEM_rw ( PKCS8_PRIV_KEY_INFO , PKCS8_PRIV_KEY_INFO ) # ifndef OPENSSL_NO_RSA DECLARE_PEM_rw_cb ( RSAPrivateKey , RSA ) DECLARE_PEM_rw_const ( RSAPublicKey , RSA ) DECLARE_PEM_rw ( RSA_PUBKEY , RSA ) # endif # ifndef OPENSSL_NO_DSA DECLARE_PEM_rw_cb ( DSAPrivateKey , DSA ) DECLARE_PEM_rw ( DSA_PUBKEY , DSA ) DECLARE_PEM_rw_const ( DSAparams , DSA ) # endif # ifndef OPENSSL_NO_EC DECLARE_PEM_rw_const ( ECPKParameters , EC_GROUP ) DECLARE_PEM_rw_cb ( ECPrivateKey , EC_KEY ) DECLARE_PEM_rw ( EC_PUBKEY , EC_KEY ) # endif # ifndef OPENSSL_NO_DH DECLARE_PEM_rw_const ( DHparams , DH )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void checkpoint ( void ) {
checkpoint_requested = 0 ;
if ( object_count ) {
cycle_packfile ( ) ;
dump_branches ( ) ;
dump_tags ( ) ;
dump_marks ( ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void input_DecoderDecode ( decoder_t * p_dec , block_t * p_block , bool b_do_pace ) {
decoder_owner_sys_t * p_owner = p_dec -> p_owner ;
if ( b_do_pace ) {
if ( ! p_owner -> b_waiting ) block_FifoPace ( p_owner -> p_fifo , 10 , SIZE_MAX ) ;
}
# ifdef __arm__ else if ( block_FifoSize ( p_owner -> p_fifo ) > 50 * 1024 * 1024 ) # else else if ( block_FifoSize ( p_owner -> p_fifo ) > 400 * 1024 * 1024 ) # endif {
msg_Warn ( p_dec , "decoder/packetizer fifo full (data not " "consumed quickly enough), resetting fifo!" ) ;
block_FifoEmpty ( p_owner -> p_fifo ) ;
}
block_FifoPut ( p_owner -> p_fifo , p_block ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void virtio_pci_reset ( DeviceState * d ) {
VirtIOPCIProxy * proxy = container_of ( d , VirtIOPCIProxy , pci_dev . qdev ) ;
virtio_reset ( proxy -> vdev ) ;
msix_reset ( & proxy -> pci_dev ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dissect_glabel_sdh ( proto_tree * ti _U_ , proto_tree * rsvp_object_tree , tvbuff_t * tvb , int offset ) {
guint16 s ;
guint8 u , k , l , m ;
proto_tree * sonet_tree ;
sonet_tree = proto_tree_add_subtree ( rsvp_object_tree , tvb , offset , 4 , TREE ( TT_SONET_SDH ) , NULL , "SONET/SDH Label" ) ;
proto_tree_add_item ( sonet_tree , hf_rsvp_sonet_s , tvb , offset , 2 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( sonet_tree , hf_rsvp_sonet_u , tvb , offset + 2 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( sonet_tree , hf_rsvp_sonet_k , tvb , offset + 2 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( sonet_tree , hf_rsvp_sonet_l , tvb , offset + 3 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( sonet_tree , hf_rsvp_sonet_m , tvb , offset + 3 , 1 , ENC_BIG_ENDIAN ) ;
s = tvb_get_ntohs ( tvb , offset ) ;
u = ( ( tvb_get_guint8 ( tvb , offset + 2 ) & 0xF0 ) >> 4 ) ;
k = ( ( tvb_get_guint8 ( tvb , offset + 2 ) & 0x0F ) >> 0 ) ;
l = ( ( tvb_get_guint8 ( tvb , offset + 3 ) & 0xF0 ) >> 4 ) ;
m = ( ( tvb_get_guint8 ( tvb , offset + 3 ) & 0x0F ) >> 0 ) ;
proto_item_append_text ( ti , ": SONET/SDH: S=%u, U=%u, K=%u, L=%u, M=%u" , s , u , k , l , m ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_decoder_remove ( VP9Decoder * pbi ) {
VP9_COMMON * const cm = & pbi -> common ;
int i ;
vp9_get_worker_interface ( ) -> end ( & pbi -> lf_worker ) ;
vpx_free ( pbi -> lf_worker . data1 ) ;
vpx_free ( pbi -> tile_data ) ;
for ( i = 0 ;
i < pbi -> num_tile_workers ;
++ i ) {
VP9Worker * const worker = & pbi -> tile_workers [ i ] ;
vp9_get_worker_interface ( ) -> end ( worker ) ;
vpx_free ( worker -> data1 ) ;
vpx_free ( worker -> data2 ) ;
}
vpx_free ( pbi -> tile_workers ) ;
if ( pbi -> num_tile_workers > 0 ) {
vp9_loop_filter_dealloc ( & pbi -> lf_row_sync ) ;
}
vp9_remove_common ( cm ) ;
vpx_free ( pbi ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VALUE ossl_asn1_ ## klass ( int argc , VALUE * argv , VALUE self ) \ {
return rb_funcall3 ( cASN1 ## klass , rb_intern ( "new" ) , argc , argv ) ;
}
OSSL_ASN1_IMPL_FACTORY_METHOD ( Boolean ) OSSL_ASN1_IMPL_FACTORY_METHOD ( Integer ) OSSL_ASN1_IMPL_FACTORY_METHOD ( Enumerated ) OSSL_ASN1_IMPL_FACTORY_METHOD ( BitString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( OctetString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( UTF8String ) OSSL_ASN1_IMPL_FACTORY_METHOD ( NumericString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( PrintableString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( T61String ) OSSL_ASN1_IMPL_FACTORY_METHOD ( VideotexString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( IA5String ) OSSL_ASN1_IMPL_FACTORY_METHOD ( GraphicString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( ISO64String ) OSSL_ASN1_IMPL_FACTORY_METHOD ( GeneralString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( UniversalString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( BMPString ) OSSL_ASN1_IMPL_FACTORY_METHOD ( Null ) OSSL_ASN1_IMPL_FACTORY_METHOD ( ObjectId )
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.