instruction
stringclasses 1
value | input
stringlengths 31
235k
| output
class label 2
classes |
|---|---|---|
Categorize the following code snippet as vulnerable or not. True or False
|
static void mips_pica61_init ( QEMUMachineInitArgs * args ) {
ram_addr_t ram_size = args -> ram_size ;
const char * cpu_model = args -> cpu_model ;
mips_jazz_init ( get_system_memory ( ) , get_system_io ( ) , ram_size , cpu_model , JAZZ_PICA61 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void abort_request ( ngx_http_request_t * r ) {
ngx_log_debug0 ( NGX_LOG_DEBUG_HTTP , r -> connection -> log , 0 , "abort Passenger request" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void more_files_callback ( GObject * source_object , GAsyncResult * res , gpointer user_data ) {
DirectoryLoadState * state ;
NautilusDirectory * directory ;
GError * error ;
GList * files , * l ;
GFileInfo * info ;
state = user_data ;
if ( state -> directory == NULL ) {
directory_load_state_free ( state ) ;
return ;
}
directory = nautilus_directory_ref ( state -> directory ) ;
g_assert ( directory -> details -> directory_load_in_progress != NULL ) ;
g_assert ( directory -> details -> directory_load_in_progress == state ) ;
error = NULL ;
files = g_file_enumerator_next_files_finish ( state -> enumerator , res , & error ) ;
for ( l = files ;
l != NULL ;
l = l -> next ) {
info = l -> data ;
directory_load_one ( directory , info ) ;
g_object_unref ( info ) ;
}
if ( files == NULL ) {
directory_load_done ( directory , error ) ;
directory_load_state_free ( state ) ;
}
else {
g_file_enumerator_next_files_async ( state -> enumerator , DIRECTORY_LOAD_ITEMS_PER_CALLBACK , G_PRIORITY_DEFAULT , state -> cancellable , more_files_callback , state ) ;
}
nautilus_directory_unref ( directory ) ;
if ( error ) {
g_error_free ( error ) ;
}
g_list_free ( files ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void s390_machine_init ( void ) {
qemu_register_machine ( & s390_machine ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int getulong ( const char * numstr , unsigned long int * result ) {
unsigned long int val ;
char * endptr ;
errno = 0 ;
val = strtoul ( numstr , & endptr , 0 ) ;
if ( ( '\0' == * numstr ) || ( '\0' != * endptr ) || ( ERANGE == errno ) ) {
return 0 ;
}
* result = val ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_type_bitmap ( proto_tree * rr_tree , tvbuff_t * tvb , int cur_offset , int rr_len ) {
int mask , blockbase , blocksize ;
int i , initial_offset , rr_type ;
guint8 bits ;
initial_offset = cur_offset ;
while ( rr_len != 0 ) {
blockbase = tvb_get_guint8 ( tvb , cur_offset ) ;
blocksize = tvb_get_guint8 ( tvb , cur_offset + 1 ) ;
cur_offset += 2 ;
rr_len -= 2 ;
rr_type = blockbase * 256 ;
for ( ;
blocksize ;
blocksize -- ) {
bits = tvb_get_guint8 ( tvb , cur_offset ) ;
mask = 1 << 7 ;
for ( i = 0 ;
i < 8 ;
i ++ ) {
if ( bits & mask ) {
proto_tree_add_uint_format ( rr_tree , hf_dns_rr_type , tvb , cur_offset , 1 , rr_type , "RR type in bit map: %s" , val_to_str_ext ( rr_type , & dns_types_description_vals_ext , "Unknown (%d)" ) ) ;
}
mask >>= 1 ;
rr_type ++ ;
}
cur_offset += 1 ;
rr_len -= 1 ;
}
}
return ( initial_offset - cur_offset ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void xsltDebug ( xsltTransformContextPtr ctxt , xmlNodePtr node ATTRIBUTE_UNUSED , xmlNodePtr inst ATTRIBUTE_UNUSED , xsltStylePreCompPtr comp ATTRIBUTE_UNUSED ) {
int i , j ;
xsltGenericError ( xsltGenericErrorContext , "Templates:\n" ) ;
for ( i = 0 , j = ctxt -> templNr - 1 ;
( ( i < 15 ) && ( j >= 0 ) ) ;
i ++ , j -- ) {
xsltGenericError ( xsltGenericErrorContext , "#%d " , i ) ;
if ( ctxt -> templTab [ j ] -> name != NULL ) xsltGenericError ( xsltGenericErrorContext , "name %s " , ctxt -> templTab [ j ] -> name ) ;
if ( ctxt -> templTab [ j ] -> match != NULL ) xsltGenericError ( xsltGenericErrorContext , "name %s " , ctxt -> templTab [ j ] -> match ) ;
if ( ctxt -> templTab [ j ] -> mode != NULL ) xsltGenericError ( xsltGenericErrorContext , "name %s " , ctxt -> templTab [ j ] -> mode ) ;
xsltGenericError ( xsltGenericErrorContext , "\n" ) ;
}
xsltGenericError ( xsltGenericErrorContext , "Variables:\n" ) ;
for ( i = 0 , j = ctxt -> varsNr - 1 ;
( ( i < 15 ) && ( j >= 0 ) ) ;
i ++ , j -- ) {
xsltStackElemPtr cur ;
if ( ctxt -> varsTab [ j ] == NULL ) continue ;
xsltGenericError ( xsltGenericErrorContext , "#%d\n" , i ) ;
cur = ctxt -> varsTab [ j ] ;
while ( cur != NULL ) {
if ( cur -> comp == NULL ) {
xsltGenericError ( xsltGenericErrorContext , "corrupted !!!\n" ) ;
}
else if ( cur -> comp -> type == XSLT_FUNC_PARAM ) {
xsltGenericError ( xsltGenericErrorContext , "param " ) ;
}
else if ( cur -> comp -> type == XSLT_FUNC_VARIABLE ) {
xsltGenericError ( xsltGenericErrorContext , "var " ) ;
}
if ( cur -> name != NULL ) xsltGenericError ( xsltGenericErrorContext , "%s " , cur -> name ) ;
else xsltGenericError ( xsltGenericErrorContext , "noname !!!!" ) ;
# ifdef LIBXML_DEBUG_ENABLED if ( cur -> value != NULL ) {
xmlXPathDebugDumpObject ( stdout , cur -> value , 1 ) ;
}
else {
xsltGenericError ( xsltGenericErrorContext , "NULL !!!!" ) ;
}
# endif xsltGenericError ( xsltGenericErrorContext , "\n" ) ;
cur = cur -> next ;
}
}
}
| 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 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t pointerTOCEntryCount ( const UDataMemory * pData ) {
const PointerTOC * toc = ( PointerTOC * ) pData -> toc ;
return ( uint32_t ) ( ( toc != NULL ) ? ( toc -> count ) : 0 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int read_dcs ( AVCodecContext * avctx , GetBitContext * gb , Bundle * b , int start_bits , int has_sign ) {
int i , j , len , len2 , bsize , sign , v , v2 ;
int16_t * dst = ( int16_t * ) b -> cur_dec ;
int16_t * dst_end = ( int16_t * ) b -> data_end ;
CHECK_READ_VAL ( gb , b , len ) ;
v = get_bits ( gb , start_bits - has_sign ) ;
if ( v && has_sign ) {
sign = - get_bits1 ( gb ) ;
v = ( v ^ sign ) - sign ;
}
if ( dst_end - dst < 1 ) return AVERROR_INVALIDDATA ;
* dst ++ = v ;
len -- ;
for ( i = 0 ;
i < len ;
i += 8 ) {
len2 = FFMIN ( len - i , 8 ) ;
if ( dst_end - dst < len2 ) return AVERROR_INVALIDDATA ;
bsize = get_bits ( gb , 4 ) ;
if ( bsize ) {
for ( j = 0 ;
j < len2 ;
j ++ ) {
v2 = get_bits ( gb , bsize ) ;
if ( v2 ) {
sign = - get_bits1 ( gb ) ;
v2 = ( v2 ^ sign ) - sign ;
}
v += v2 ;
* dst ++ = v ;
if ( v < - 32768 || v > 32767 ) {
av_log ( avctx , AV_LOG_ERROR , "DC value went out of bounds: %d\n" , v ) ;
return AVERROR_INVALIDDATA ;
}
}
}
else {
for ( j = 0 ;
j < len2 ;
j ++ ) * dst ++ = v ;
}
}
b -> cur_dec = ( uint8_t * ) dst ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void pcnet_transmit ( PCNetState * s ) {
hwaddr xmit_cxda = 0 ;
int count = CSR_XMTRL ( s ) - 1 ;
int add_crc = 0 ;
int bcnt ;
s -> xmit_pos = - 1 ;
if ( ! CSR_TXON ( s ) ) {
s -> csr [ 0 ] &= ~ 0x0008 ;
return ;
}
s -> tx_busy = 1 ;
txagain : if ( pcnet_tdte_poll ( s ) ) {
struct pcnet_TMD tmd ;
TMDLOAD ( & tmd , PHYSADDR ( s , CSR_CXDA ( s ) ) ) ;
# ifdef PCNET_DEBUG_TMD printf ( " TMDLOAD 0x%08x\n" , PHYSADDR ( s , CSR_CXDA ( s ) ) ) ;
PRINT_TMD ( & tmd ) ;
# endif if ( GET_FIELD ( tmd . status , TMDS , STP ) ) {
s -> xmit_pos = 0 ;
xmit_cxda = PHYSADDR ( s , CSR_CXDA ( s ) ) ;
if ( BCR_SWSTYLE ( s ) != 1 ) add_crc = GET_FIELD ( tmd . status , TMDS , ADDFCS ) ;
}
if ( s -> lnkst == 0 && ( ! CSR_LOOP ( s ) || ( ! CSR_INTL ( s ) && ! BCR_TMAULOOP ( s ) ) ) ) {
SET_FIELD ( & tmd . misc , TMDM , LCAR , 1 ) ;
SET_FIELD ( & tmd . status , TMDS , ERR , 1 ) ;
SET_FIELD ( & tmd . status , TMDS , OWN , 0 ) ;
s -> csr [ 0 ] |= 0xa000 ;
s -> xmit_pos = - 1 ;
goto txdone ;
}
if ( s -> xmit_pos < 0 ) {
goto txdone ;
}
bcnt = 4096 - GET_FIELD ( tmd . length , TMDL , BCNT ) ;
if ( s -> xmit_pos + bcnt > sizeof ( s -> buffer ) - 4 ) {
s -> xmit_pos = - 1 ;
goto txdone ;
}
s -> phys_mem_read ( s -> dma_opaque , PHYSADDR ( s , tmd . tbadr ) , s -> buffer + s -> xmit_pos , bcnt , CSR_BSWP ( s ) ) ;
s -> xmit_pos += bcnt ;
if ( ! GET_FIELD ( tmd . status , TMDS , ENP ) ) {
goto txdone ;
}
# ifdef PCNET_DEBUG printf ( "pcnet_transmit size=%d\n" , s -> xmit_pos ) ;
# endif if ( CSR_LOOP ( s ) ) {
if ( BCR_SWSTYLE ( s ) == 1 ) add_crc = ! GET_FIELD ( tmd . status , TMDS , NOFCS ) ;
s -> looptest = add_crc ? PCNET_LOOPTEST_CRC : PCNET_LOOPTEST_NOCRC ;
pcnet_receive ( qemu_get_queue ( s -> nic ) , s -> buffer , s -> xmit_pos ) ;
s -> looptest = 0 ;
}
else {
if ( s -> nic ) {
qemu_send_packet ( qemu_get_queue ( s -> nic ) , s -> buffer , s -> xmit_pos ) ;
}
}
s -> csr [ 0 ] &= ~ 0x0008 ;
s -> csr [ 4 ] |= 0x0004 ;
s -> xmit_pos = - 1 ;
txdone : SET_FIELD ( & tmd . status , TMDS , OWN , 0 ) ;
TMDSTORE ( & tmd , PHYSADDR ( s , CSR_CXDA ( s ) ) ) ;
if ( ! CSR_TOKINTD ( s ) || ( CSR_LTINTEN ( s ) && GET_FIELD ( tmd . status , TMDS , LTINT ) ) ) {
s -> csr [ 0 ] |= 0x0200 ;
}
if ( CSR_XMTRC ( s ) <= 1 ) {
CSR_XMTRC ( s ) = CSR_XMTRL ( s ) ;
}
else {
CSR_XMTRC ( s ) -- ;
}
if ( count -- ) {
goto txagain ;
}
}
else if ( s -> xmit_pos >= 0 ) {
struct pcnet_TMD tmd ;
TMDLOAD ( & tmd , xmit_cxda ) ;
SET_FIELD ( & tmd . misc , TMDM , BUFF , 1 ) ;
SET_FIELD ( & tmd . misc , TMDM , UFLO , 1 ) ;
SET_FIELD ( & tmd . status , TMDS , ERR , 1 ) ;
SET_FIELD ( & tmd . status , TMDS , OWN , 0 ) ;
TMDSTORE ( & tmd , xmit_cxda ) ;
s -> csr [ 0 ] |= 0x0200 ;
if ( ! CSR_DXSUFLO ( s ) ) {
s -> csr [ 0 ] &= ~ 0x0010 ;
}
else if ( count -- ) {
goto txagain ;
}
}
s -> tx_busy = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mem_draw_thin_line ( gx_device * dev , fixed fx0 , fixed fy0 , fixed fx1 , fixed fy1 , const gx_drawing_color * pdcolor , gs_logical_operation_t lop , fixed adjustx , fixed adjusty ) {
return gx_default_draw_thin_line ( dev , fx0 , fy0 , fx1 , fy1 , pdcolor , lop , adjustx , adjusty ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static cmsBool Type_Curve_Write ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , void * Ptr , cmsUInt32Number nItems ) {
cmsToneCurve * Curve = ( cmsToneCurve * ) Ptr ;
if ( Curve -> nSegments == 1 && Curve -> Segments [ 0 ] . Type == 1 ) {
cmsUInt16Number SingleGammaFixed = _cmsDoubleTo8Fixed8 ( Curve -> Segments [ 0 ] . Params [ 0 ] ) ;
if ( ! _cmsWriteUInt32Number ( io , 1 ) ) return FALSE ;
if ( ! _cmsWriteUInt16Number ( io , SingleGammaFixed ) ) return FALSE ;
return TRUE ;
}
if ( ! _cmsWriteUInt32Number ( io , Curve -> nEntries ) ) return FALSE ;
return _cmsWriteUInt16Array ( io , Curve -> nEntries , Curve -> Table16 ) ;
cmsUNUSED_PARAMETER ( nItems ) ;
cmsUNUSED_PARAMETER ( self ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int kex_agree_methods ( LIBSSH2_SESSION * session , unsigned char * data , unsigned data_len ) {
unsigned char * kex , * hostkey , * crypt_cs , * crypt_sc , * comp_cs , * comp_sc , * mac_cs , * mac_sc ;
size_t kex_len , hostkey_len , crypt_cs_len , crypt_sc_len , comp_cs_len ;
size_t comp_sc_len , mac_cs_len , mac_sc_len ;
unsigned char * s = data ;
s ++ ;
s += 16 ;
if ( kex_string_pair ( & s , data , data_len , & kex_len , & kex ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & hostkey_len , & hostkey ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & crypt_cs_len , & crypt_cs ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & crypt_sc_len , & crypt_sc ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & mac_cs_len , & mac_cs ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & mac_sc_len , & mac_sc ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & comp_cs_len , & comp_cs ) ) return - 1 ;
if ( kex_string_pair ( & s , data , data_len , & comp_sc_len , & comp_sc ) ) return - 1 ;
session -> burn_optimistic_kexinit = * ( s ++ ) ;
if ( data_len < ( unsigned ) ( s - data ) ) return - 1 ;
if ( kex_agree_kex_hostkey ( session , kex , kex_len , hostkey , hostkey_len ) ) {
return - 1 ;
}
if ( kex_agree_crypt ( session , & session -> local , crypt_cs , crypt_cs_len ) || kex_agree_crypt ( session , & session -> remote , crypt_sc , crypt_sc_len ) ) {
return - 1 ;
}
if ( kex_agree_mac ( session , & session -> local , mac_cs , mac_cs_len ) || kex_agree_mac ( session , & session -> remote , mac_sc , mac_sc_len ) ) {
return - 1 ;
}
if ( kex_agree_comp ( session , & session -> local , comp_cs , comp_cs_len ) || kex_agree_comp ( session , & session -> remote , comp_sc , comp_sc_len ) ) {
return - 1 ;
}
# if 0 if ( libssh2_kex_agree_lang ( session , & session -> local , lang_cs , lang_cs_len ) || libssh2_kex_agree_lang ( session , & session -> remote , lang_sc , lang_sc_len ) ) {
return - 1 ;
}
# endif _libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on KEX method: %s" , session -> kex -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on HOSTKEY method: %s" , session -> hostkey -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on CRYPT_CS method: %s" , session -> local . crypt -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on CRYPT_SC method: %s" , session -> remote . crypt -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on MAC_CS method: %s" , session -> local . mac -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on MAC_SC method: %s" , session -> remote . mac -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on COMP_CS method: %s" , session -> local . comp -> name ) ;
_libssh2_debug ( session , LIBSSH2_TRACE_KEX , "Agreed on COMP_SC method: %s" , session -> remote . comp -> name ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void s390_virtio_register ( void ) {
s390_virtio_bus_register_withprop ( & s390_virtio_console ) ;
s390_virtio_bus_register_withprop ( & s390_virtio_blk ) ;
s390_virtio_bus_register_withprop ( & s390_virtio_net ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExtensionWelcomeNotificationTest , WelcomeNotificationPreviouslyDismissedLocal ) {
StartPreferenceSyncing ( ) ;
SetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal , true ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
ShowChromeNowNotification ( ) ;
EXPECT_EQ ( message_center ( ) -> add_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> remove_notification_calls ( ) , 0 ) ;
EXPECT_EQ ( message_center ( ) -> notifications_with_shown_as_popup ( ) , 0 ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissed ) ) ;
EXPECT_TRUE ( GetBooleanPref ( prefs : : kWelcomeNotificationDismissedLocal ) ) ;
EXPECT_FALSE ( GetBooleanPref ( prefs : : kWelcomeNotificationPreviouslyPoppedUp ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( MultiBufferTest , ReadAllAdvanceFirst_NeverDefer2 ) {
multibuffer_ . SetMaxWriters ( 1 ) ;
size_t pos = 0 ;
size_t end = 10000 ;
multibuffer_ . SetFileSize ( 10000 ) ;
multibuffer_ . SetMustReadWholeFile ( true ) ;
multibuffer_ . SetMaxBlocksAfterDefer ( - 10000 ) ;
media : : MultiBufferReader reader ( & multibuffer_ , pos , end , base : : Callback < void ( int64_t , int64_t ) > ( ) ) ;
reader . SetMaxBuffer ( 2000 , 5000 ) ;
reader . SetPreload ( 1000 , 1000 ) ;
while ( pos < end ) {
unsigned char buffer [ 27 ] ;
buffer [ 17 ] = 17 ;
size_t to_read = std : : min < size_t > ( end - pos , 17 ) ;
while ( AdvanceAll ( ) ) ;
int64_t bytes = reader . TryRead ( buffer , to_read ) ;
EXPECT_GT ( bytes , 0 ) ;
EXPECT_EQ ( buffer [ 17 ] , 17 ) ;
for ( int64_t i = 0 ;
i < bytes ;
i ++ ) {
uint8_t expected = static_cast < uint8_t > ( ( pos * 15485863 ) >> 16 ) ;
EXPECT_EQ ( expected , buffer [ i ] ) << " pos = " << pos ;
pos ++ ;
}
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_Application ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 502 "../../asn1/h245/h245.cnf" gint32 value ;
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_Application , Application_choice , & value ) ;
codec_type = val_to_str ( value , h245_Application_vals , "<unknown>" ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void unistim_calls_init_tap ( void ) {
GString * error_string ;
if ( have_unistim_tap_listener == FALSE ) {
error_string = register_tap_listener ( "unistim" , & ( the_tapinfo_struct . unistim_dummy ) , NULL , 0 , voip_calls_dlg_reset , unistim_calls_packet , voip_calls_dlg_draw ) ;
if ( error_string != NULL ) {
simple_dialog ( ESD_TYPE_ERROR , ESD_BTN_OK , "%s" , error_string -> str ) ;
g_string_free ( error_string , TRUE ) ;
exit ( 1 ) ;
}
have_unistim_tap_listener = TRUE ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void chomp6 ( ChannelData * chd , int16_t * output , uint8_t val , int tab_idx ) {
int16_t current = read_table ( chd , val , tab_idx ) ;
if ( ( chd -> previous ^ current ) >= 0 ) {
chd -> factor = FFMIN ( chd -> factor + 506 , 32767 ) ;
}
else {
if ( chd -> factor - 314 < - 32768 ) chd -> factor = - 32767 ;
else chd -> factor -= 314 ;
}
current = mace_broken_clip_int16 ( current + chd -> level ) ;
chd -> level = ( current * chd -> factor ) >> 15 ;
current >>= 1 ;
output [ 0 ] = QT_8S_2_16S ( chd -> previous + chd -> prev2 - ( ( chd -> prev2 - current ) >> 2 ) ) ;
output [ 1 ] = QT_8S_2_16S ( chd -> previous + current + ( ( chd -> prev2 - current ) >> 2 ) ) ;
chd -> prev2 = chd -> previous ;
chd -> previous = current ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
proto_item * parseSByte ( proto_tree * tree , tvbuff_t * tvb , packet_info * pinfo _U_ , gint * pOffset , int hfIndex ) {
proto_item * item = proto_tree_add_item ( tree , hfIndex , tvb , * pOffset , 1 , ENC_LITTLE_ENDIAN ) ;
* pOffset += 1 ;
return item ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_pcp_message ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * tree , void * data _U_ ) {
proto_item * root_pcp_item ;
proto_tree * pcp_tree ;
conversation_t * conversation ;
pcp_conv_info_t * pcp_conv_info ;
guint32 packet_type ;
gint32 err_bytes ;
int offset = 0 ;
col_set_str ( pinfo -> cinfo , COL_PROTOCOL , "PCP" ) ;
col_clear ( pinfo -> cinfo , COL_INFO ) ;
conversation = find_or_create_conversation ( pinfo ) ;
pcp_conv_info = ( pcp_conv_info_t * ) conversation_get_proto_data ( conversation , proto_pcp ) ;
if ( pcp_conv_info == NULL ) {
pcp_conv_info = ( pcp_conv_info_t * ) wmem_alloc ( wmem_file_scope ( ) , sizeof ( pcp_conv_info_t ) ) ;
conversation_add_proto_data ( conversation , proto_pcp , pcp_conv_info ) ;
pcp_conv_info -> pmid_name_candidates = wmem_array_new ( wmem_file_scope ( ) , sizeof ( guint8 * ) ) ;
pcp_conv_info -> pmid_to_name = wmem_map_new ( wmem_file_scope ( ) , g_direct_hash , g_direct_equal ) ;
pcp_conv_info -> last_pmns_names_frame = 0 ;
pcp_conv_info -> last_processed_pmns_names_frame = 0 ;
}
root_pcp_item = proto_tree_add_item ( tree , proto_pcp , tvb , 0 , - 1 , ENC_NA ) ;
pcp_tree = proto_item_add_subtree ( root_pcp_item , ett_pcp ) ;
packet_type = tvb_get_ntohl ( tvb , 4 ) ;
if ( pinfo -> srcport == PCP_PORT || pinfo -> srcport == PMPROXY_PORT ) {
col_set_str ( pinfo -> cinfo , COL_INFO , "Server > Client " ) ;
}
else {
col_set_str ( pinfo -> cinfo , COL_INFO , "Client > Server " ) ;
}
proto_tree_add_item ( pcp_tree , hf_pcp_pdu_length , tvb , offset , 4 , ENC_BIG_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( pcp_tree , hf_pcp_pdu_type , tvb , offset , 4 , ENC_BIG_ENDIAN ) ;
offset += 4 ;
proto_tree_add_item ( pcp_tree , hf_pcp_pdu_pid , tvb , offset , 4 , ENC_BIG_ENDIAN ) ;
offset += 4 ;
switch ( packet_type ) {
case PCP_PDU_CREDS : dissect_pcp_message_creds ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_START_OR_ERROR : err_bytes = tvb_get_ntohl ( tvb , offset ) ;
if ( err_bytes < 0 ) {
dissect_pcp_message_error ( tvb , pinfo , pcp_tree , offset ) ;
}
else {
dissect_pcp_message_start ( tvb , pinfo , pcp_tree , offset ) ;
}
break ;
case PCP_PDU_PMNS_TRAVERSE : dissect_pcp_message_pmns_traverse ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PMNS_NAMES : dissect_pcp_message_pmns_names ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PMNS_CHILD : dissect_pcp_message_pmns_child ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PMNS_IDS : dissect_pcp_message_pmns_ids ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_PROFILE : dissect_pcp_message_profile ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_FETCH : dissect_pcp_message_fetch ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_RESULT : dissect_pcp_message_result ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_DESC_REQ : dissect_pcp_message_desc_req ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_DESC : dissect_pcp_message_desc ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_INSTANCE_REQ : dissect_pcp_message_instance_req ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_INSTANCE : dissect_pcp_message_instance ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_TEXT_REQ : dissect_pcp_message_text_req ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_TEXT : dissect_pcp_message_text ( tvb , pinfo , pcp_tree , offset ) ;
break ;
case PCP_PDU_USER_AUTH : dissect_pcp_message_user_auth ( tvb , pinfo , pcp_tree , offset ) ;
break ;
default : col_append_str ( pinfo -> cinfo , COL_INFO , "[UNIMPLEMENTED TYPE]" ) ;
expert_add_info ( pinfo , pcp_tree , & ei_pcp_unimplemented_packet_type ) ;
break ;
}
return tvb_captured_length ( tvb ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
xmlDeregisterNodeFunc xmlThrDefDeregisterNodeDefault ( xmlDeregisterNodeFunc func ) {
xmlDeregisterNodeFunc old ;
xmlMutexLock ( xmlThrDefMutex ) ;
old = xmlDeregisterNodeDefaultValueThrDef ;
__xmlRegisterCallbacks = 1 ;
xmlDeregisterNodeDefaultValueThrDef = func ;
xmlMutexUnlock ( xmlThrDefMutex ) ;
return ( old ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static hb_bool_t hb_font_get_glyph_nil ( hb_font_t * font , void * font_data HB_UNUSED , hb_codepoint_t unicode , hb_codepoint_t variation_selector , hb_codepoint_t * glyph , void * user_data HB_UNUSED ) {
if ( font -> parent ) return font -> parent -> get_glyph ( unicode , variation_selector , glyph ) ;
* glyph = 0 ;
return false ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void Type_ProfileSequenceDesc_Free ( struct _cms_typehandler_struct * self , void * Ptr ) {
cmsFreeProfileSequenceDescription ( ( cmsSEQ * ) Ptr ) ;
return ;
cmsUNUSED_PARAMETER ( self ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int test_make_inputs ( xd3_stream * stream , xoff_t * ss_out , xoff_t * ts_out ) {
usize_t ts = ( mt_random ( & static_mtrand ) % TEST_FILE_MEAN ) + TEST_FILE_MEAN / 2 ;
usize_t ss = ( mt_random ( & static_mtrand ) % TEST_FILE_MEAN ) + TEST_FILE_MEAN / 2 ;
uint8_t * buf = ( uint8_t * ) malloc ( ts + ss ) , * sbuf = buf , * tbuf = buf + ss ;
usize_t sadd = 0 , sadd_max = ( usize_t ) ( ss * TEST_ADD_RATIO ) ;
FILE * tf = NULL , * sf = NULL ;
usize_t i , j ;
int ret ;
if ( buf == NULL ) {
return ENOMEM ;
}
if ( ( tf = fopen ( TEST_TARGET_FILE , "w" ) ) == NULL || ( ss_out != NULL && ( sf = fopen ( TEST_SOURCE_FILE , "w" ) ) == NULL ) ) {
stream -> msg = "write failed" ;
ret = get_errno ( ) ;
goto failure ;
}
if ( ss_out != NULL ) {
for ( i = 0 ;
i < ss ;
) {
sbuf [ i ++ ] = ( uint8_t ) mt_random ( & static_mtrand ) ;
}
}
for ( i = 0 ;
i < ts ;
) {
usize_t left = ts - i ;
usize_t next = mt_exp_rand ( ( uint32_t ) TEST_ADD_MEAN , ( uint32_t ) TEST_ADD_MAX ) ;
usize_t add_left = sadd_max - sadd ;
double add_prob = ( left == 0 ) ? 0 : ( add_left / ( double ) left ) ;
int do_copy ;
next = min ( left , next ) ;
do_copy = ( next > add_left || ( mt_random ( & static_mtrand ) / ( double ) USIZE_T_MAX ) >= add_prob ) ;
if ( ss_out == NULL ) {
do_copy &= ( i > 0 ) ;
}
else {
do_copy &= ( ss - next ) > 0 ;
}
if ( do_copy ) {
size_t offset = mt_random ( & static_mtrand ) % ( ( ss_out == NULL ) ? i : ( ss - next ) ) ;
for ( j = 0 ;
j < next ;
j += 1 ) {
char c = ( ( ss_out == NULL ) ? tbuf : sbuf ) [ offset + j ] ;
tbuf [ i ++ ] = c ;
}
}
else {
for ( j = 0 ;
j < next ;
j += 1 ) {
char c = ( char ) mt_random ( & static_mtrand ) ;
tbuf [ i ++ ] = c ;
}
sadd += next ;
}
}
if ( ( fwrite ( tbuf , 1 , ts , tf ) != ts ) || ( ss_out != NULL && ( fwrite ( sbuf , 1 , ss , sf ) != ss ) ) ) {
stream -> msg = "write failed" ;
ret = get_errno ( ) ;
goto failure ;
}
if ( ( ret = fclose ( tf ) ) || ( ss_out != NULL && ( ret = fclose ( sf ) ) ) ) {
stream -> msg = "close failed" ;
ret = get_errno ( ) ;
goto failure ;
}
if ( ts_out ) {
( * ts_out ) = ts ;
}
if ( ss_out ) {
( * ss_out ) = ss ;
}
failure : free ( buf ) ;
return ret ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int mem_get_bits_rectangle ( gx_device * dev , const gs_int_rect * prect , gs_get_bits_params_t * params , gs_int_rect * * unread ) {
gx_device_memory * const mdev = ( gx_device_memory * ) dev ;
gs_get_bits_options_t options = params -> options ;
int x = prect -> p . x , w = prect -> q . x - x , y = prect -> p . y , h = prect -> q . y - y ;
if ( options == 0 ) {
params -> options = ( GB_ALIGN_STANDARD | GB_ALIGN_ANY ) | ( GB_RETURN_COPY | GB_RETURN_POINTER ) | ( GB_OFFSET_0 | GB_OFFSET_SPECIFIED | GB_OFFSET_ANY ) | ( GB_RASTER_STANDARD | GB_RASTER_SPECIFIED | GB_RASTER_ANY ) | GB_PACKING_CHUNKY | GB_COLORS_NATIVE | GB_ALPHA_NONE ;
return_error ( gs_error_rangecheck ) ;
}
if ( ( w <= 0 ) | ( h <= 0 ) ) {
if ( ( w | h ) < 0 ) return_error ( gs_error_rangecheck ) ;
return 0 ;
}
if ( x < 0 || w > dev -> width - x || y < 0 || h > dev -> height - y ) return_error ( gs_error_rangecheck ) ;
{
gs_get_bits_params_t copy_params ;
byte * * base = & scan_line_base ( mdev , y ) ;
int code ;
copy_params . options = GB_COLORS_NATIVE | GB_PACKING_CHUNKY | GB_ALPHA_NONE | ( mdev -> raster == bitmap_raster ( mdev -> width * mdev -> color_info . depth ) ? GB_RASTER_STANDARD : GB_RASTER_SPECIFIED ) ;
copy_params . raster = mdev -> raster ;
code = gx_get_bits_return_pointer ( dev , x , h , params , & copy_params , base ) ;
if ( code >= 0 ) return code ;
return gx_get_bits_copy ( dev , x , w , h , params , & copy_params , * base , gx_device_raster ( dev , true ) ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void generate ( ELG_secret_key * sk , unsigned int nbits , MPI * * ret_factors ) {
MPI p ;
MPI p_min1 ;
MPI g ;
MPI x ;
MPI y ;
MPI temp ;
unsigned int qbits ;
unsigned int xbits ;
byte * rndbuf ;
p_min1 = mpi_alloc ( mpi_nlimb_hint_from_nbits ( nbits ) ) ;
temp = mpi_alloc ( mpi_nlimb_hint_from_nbits ( nbits ) ) ;
qbits = wiener_map ( nbits ) ;
if ( qbits & 1 ) qbits ++ ;
g = mpi_alloc ( 1 ) ;
p = generate_elg_prime ( 0 , nbits , qbits , g , ret_factors ) ;
mpi_sub_ui ( p_min1 , p , 1 ) ;
xbits = qbits * 3 / 2 ;
if ( xbits >= nbits ) BUG ( ) ;
x = mpi_alloc_secure ( mpi_nlimb_hint_from_nbits ( xbits ) ) ;
if ( DBG_CIPHER ) log_debug ( "choosing a random x of size %u" , xbits ) ;
rndbuf = NULL ;
do {
if ( DBG_CIPHER ) progress ( '.' ) ;
if ( rndbuf ) {
if ( xbits < 16 ) {
xfree ( rndbuf ) ;
rndbuf = get_random_bits ( xbits , 2 , 1 ) ;
}
else {
char * r = get_random_bits ( 16 , 2 , 1 ) ;
memcpy ( rndbuf , r , 16 / 8 ) ;
xfree ( r ) ;
}
}
else rndbuf = get_random_bits ( xbits , 2 , 1 ) ;
mpi_set_buffer ( x , rndbuf , ( xbits + 7 ) / 8 , 0 ) ;
mpi_clear_highbit ( x , xbits + 1 ) ;
}
while ( ! ( mpi_cmp_ui ( x , 0 ) > 0 && mpi_cmp ( x , p_min1 ) < 0 ) ) ;
xfree ( rndbuf ) ;
y = mpi_alloc ( mpi_nlimb_hint_from_nbits ( nbits ) ) ;
mpi_powm ( y , g , x , p ) ;
if ( DBG_CIPHER ) {
progress ( '\n' ) ;
log_mpidump ( "elg p= " , p ) ;
log_mpidump ( "elg g= " , g ) ;
log_mpidump ( "elg y= " , y ) ;
log_mpidump ( "elg x= " , x ) ;
}
sk -> p = p ;
sk -> g = g ;
sk -> y = y ;
sk -> x = x ;
test_keys ( sk , nbits - 64 ) ;
mpi_free ( p_min1 ) ;
mpi_free ( temp ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int load_kernel ( const char * filename , uint8_t * addr , uint8_t * real_addr ) {
int fd , size ;
int setup_sects ;
fd = open ( filename , O_RDONLY ) ;
if ( fd < 0 ) return - 1 ;
if ( read ( fd , real_addr , 512 ) != 512 ) goto fail ;
setup_sects = real_addr [ 0x1F1 ] ;
if ( ! setup_sects ) setup_sects = 4 ;
if ( read ( fd , real_addr + 512 , setup_sects * 512 ) != setup_sects * 512 ) goto fail ;
size = read ( fd , addr , 16 * 1024 * 1024 ) ;
if ( size < 0 ) goto fail ;
close ( fd ) ;
return size ;
fail : close ( fd ) ;
return - 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void compute_precache_linear ( uint8_t * output ) {
uint32_t v = 0 ;
for ( v = 0 ;
v < PRECACHE_OUTPUT_SIZE ;
v ++ ) {
output [ v ] = v / ( PRECACHE_OUTPUT_SIZE / 256 ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void xhci_stall_ep ( XHCITransfer * xfer ) {
XHCIEPContext * epctx = xfer -> epctx ;
XHCIState * xhci = epctx -> xhci ;
uint32_t err ;
XHCIStreamContext * sctx ;
if ( epctx -> nr_pstreams ) {
sctx = xhci_find_stream ( epctx , xfer -> streamid , & err ) ;
if ( sctx == NULL ) {
return ;
}
sctx -> ring . dequeue = xfer -> trbs [ 0 ] . addr ;
sctx -> ring . ccs = xfer -> trbs [ 0 ] . ccs ;
xhci_set_ep_state ( xhci , epctx , sctx , EP_HALTED ) ;
}
else {
epctx -> ring . dequeue = xfer -> trbs [ 0 ] . addr ;
epctx -> ring . ccs = xfer -> trbs [ 0 ] . ccs ;
xhci_set_ep_state ( xhci , epctx , NULL , EP_HALTED ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_NOTIFY_INFO_DATA_job ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , proto_item * item , dcerpc_info * di , guint8 * drep , guint16 field ) {
guint32 value1 ;
proto_item * hidden_item ;
switch ( field ) {
case JOB_NOTIFY_PRINTER_NAME : case JOB_NOTIFY_MACHINE_NAME : case JOB_NOTIFY_PORT_NAME : case JOB_NOTIFY_USER_NAME : case JOB_NOTIFY_NOTIFY_NAME : case JOB_NOTIFY_DATATYPE : case JOB_NOTIFY_PRINT_PROCESSOR : case JOB_NOTIFY_PARAMETERS : case JOB_NOTIFY_DRIVER_NAME : case JOB_NOTIFY_STATUS_STRING : case JOB_NOTIFY_DOCUMENT : offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_bufsize , & value1 ) ;
offset = dissect_ndr_pointer_cb ( tvb , offset , pinfo , tree , di , drep , dissect_notify_info_data_buffer , NDR_POINTER_UNIQUE , "String" , hf_notify_info_data_buffer , cb_notify_str_postprocess , GINT_TO_POINTER ( job_notify_hf_index ( field ) ) ) ;
break ;
case JOB_NOTIFY_STATUS : offset = dissect_job_status ( tvb , offset , pinfo , tree , di , drep ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , NULL , di , drep , hf_notify_info_data_value2 , NULL ) ;
break ;
case JOB_NOTIFY_SUBMITTED : offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_buffer_len , NULL ) ;
offset = dissect_ndr_pointer_cb ( tvb , offset , pinfo , tree , di , drep , dissect_SYSTEM_TIME_ptr , NDR_POINTER_UNIQUE , "Time submitted" , - 1 , notify_job_time_cb , NULL ) ;
break ;
case JOB_NOTIFY_PRIORITY : case JOB_NOTIFY_POSITION : case JOB_NOTIFY_TOTAL_PAGES : case JOB_NOTIFY_PAGES_PRINTED : case JOB_NOTIFY_TOTAL_BYTES : case JOB_NOTIFY_BYTES_PRINTED : {
guint32 value ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_value1 , & value ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_value2 , NULL ) ;
proto_item_append_text ( item , ": %d" , value ) ;
hidden_item = proto_tree_add_uint ( tree , job_notify_hf_index ( field ) , tvb , offset , 4 , value ) ;
PROTO_ITEM_SET_HIDDEN ( hidden_item ) ;
break ;
}
case JOB_NOTIFY_DEVMODE : offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_bufsize , & value1 ) ;
offset = dissect_ndr_pointer ( tvb , offset , pinfo , tree , di , drep , dissect_notify_info_data_buffer , NDR_POINTER_UNIQUE , "Buffer" , hf_notify_info_data_buffer ) ;
break ;
default : offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_value1 , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , tree , di , drep , hf_notify_info_data_value2 , NULL ) ;
}
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void SSL_set_default_read_buffer_len ( SSL * s , size_t len ) {
SSL3_BUFFER_set_default_len ( RECORD_LAYER_get_rbuf ( & s -> rlayer ) , len ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ __u32 ethtool_cmd_speed ( const struct ethtool_cmd * ep ) {
return ( ep -> speed_hi << 16 ) | ep -> speed ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_UseSpecifiedTransport ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h225_UseSpecifiedTransport , UseSpecifiedTransport_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
gboolean proto_registrar_is_protocol ( const int n ) {
header_field_info * hfinfo ;
PROTO_REGISTRAR_GET_NTH ( n , hfinfo ) ;
return ( ( ( hfinfo -> id != hf_text_only ) && ( hfinfo -> parent == - 1 ) ) ? TRUE : FALSE ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void h225_cleanup_routine ( void ) {
int i ;
for ( i = 0 ;
i < 7 ;
i ++ ) {
g_hash_table_destroy ( ras_calls [ i ] ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int word_match ( const byte * uid , size_t uidlen , const byte * pattern ) {
size_t wlen , n ;
const byte * p ;
const byte * s ;
for ( s = pattern ;
* s ;
) {
do {
while ( uidlen && ! word_match_chars [ * uid ] ) uid ++ , uidlen -- ;
n = uidlen ;
p = uid ;
while ( n && word_match_chars [ * p ] ) p ++ , n -- ;
wlen = p - uid ;
for ( n = 0 , p = uid ;
n < wlen && s [ n ] != ' ' && s [ n ] ;
n ++ , p ++ ) {
if ( word_match_chars [ * p ] != s [ n ] ) break ;
}
if ( n == wlen && ( s [ n ] == ' ' || ! s [ n ] ) ) break ;
uid += wlen ;
uidlen -= wlen ;
}
while ( uidlen ) ;
if ( ! uidlen ) return - 1 ;
for ( ;
* s != ' ' && * s ;
s ++ ) ;
if ( * s ) s ++ ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void ohci_port_set_status ( OHCIState * ohci , int portnum , uint32_t val ) {
uint32_t old_state ;
OHCIPort * port ;
port = & ohci -> rhport [ portnum ] ;
old_state = port -> ctrl ;
if ( val & OHCI_PORT_WTC ) port -> ctrl &= ~ ( val & OHCI_PORT_WTC ) ;
if ( val & OHCI_PORT_CCS ) port -> ctrl &= ~ OHCI_PORT_PES ;
ohci_port_set_if_connected ( ohci , portnum , val & OHCI_PORT_PES ) ;
if ( ohci_port_set_if_connected ( ohci , portnum , val & OHCI_PORT_PSS ) ) {
trace_usb_ohci_port_suspend ( portnum ) ;
}
if ( ohci_port_set_if_connected ( ohci , portnum , val & OHCI_PORT_PRS ) ) {
trace_usb_ohci_port_reset ( portnum ) ;
usb_device_reset ( port -> port . dev ) ;
port -> ctrl &= ~ OHCI_PORT_PRS ;
port -> ctrl |= OHCI_PORT_PES | OHCI_PORT_PRSC ;
}
if ( val & OHCI_PORT_LSDA ) ohci_port_power ( ohci , portnum , 0 ) ;
if ( val & OHCI_PORT_PPS ) ohci_port_power ( ohci , portnum , 1 ) ;
if ( old_state != port -> ctrl ) ohci_set_interrupt ( ohci , OHCI_INTR_RHSC ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void idct16 ( const int16_t * input , int16_t * output ) {
int16_t step1 [ 16 ] , step2 [ 16 ] ;
int temp1 , temp2 ;
step1 [ 0 ] = input [ 0 / 2 ] ;
step1 [ 1 ] = input [ 16 / 2 ] ;
step1 [ 2 ] = input [ 8 / 2 ] ;
step1 [ 3 ] = input [ 24 / 2 ] ;
step1 [ 4 ] = input [ 4 / 2 ] ;
step1 [ 5 ] = input [ 20 / 2 ] ;
step1 [ 6 ] = input [ 12 / 2 ] ;
step1 [ 7 ] = input [ 28 / 2 ] ;
step1 [ 8 ] = input [ 2 / 2 ] ;
step1 [ 9 ] = input [ 18 / 2 ] ;
step1 [ 10 ] = input [ 10 / 2 ] ;
step1 [ 11 ] = input [ 26 / 2 ] ;
step1 [ 12 ] = input [ 6 / 2 ] ;
step1 [ 13 ] = input [ 22 / 2 ] ;
step1 [ 14 ] = input [ 14 / 2 ] ;
step1 [ 15 ] = input [ 30 / 2 ] ;
step2 [ 0 ] = step1 [ 0 ] ;
step2 [ 1 ] = step1 [ 1 ] ;
step2 [ 2 ] = step1 [ 2 ] ;
step2 [ 3 ] = step1 [ 3 ] ;
step2 [ 4 ] = step1 [ 4 ] ;
step2 [ 5 ] = step1 [ 5 ] ;
step2 [ 6 ] = step1 [ 6 ] ;
step2 [ 7 ] = step1 [ 7 ] ;
temp1 = step1 [ 8 ] * cospi_30_64 - step1 [ 15 ] * cospi_2_64 ;
temp2 = step1 [ 8 ] * cospi_2_64 + step1 [ 15 ] * cospi_30_64 ;
step2 [ 8 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 15 ] = dct_const_round_shift ( temp2 ) ;
temp1 = step1 [ 9 ] * cospi_14_64 - step1 [ 14 ] * cospi_18_64 ;
temp2 = step1 [ 9 ] * cospi_18_64 + step1 [ 14 ] * cospi_14_64 ;
step2 [ 9 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 14 ] = dct_const_round_shift ( temp2 ) ;
temp1 = step1 [ 10 ] * cospi_22_64 - step1 [ 13 ] * cospi_10_64 ;
temp2 = step1 [ 10 ] * cospi_10_64 + step1 [ 13 ] * cospi_22_64 ;
step2 [ 10 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 13 ] = dct_const_round_shift ( temp2 ) ;
temp1 = step1 [ 11 ] * cospi_6_64 - step1 [ 12 ] * cospi_26_64 ;
temp2 = step1 [ 11 ] * cospi_26_64 + step1 [ 12 ] * cospi_6_64 ;
step2 [ 11 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 12 ] = dct_const_round_shift ( temp2 ) ;
step1 [ 0 ] = step2 [ 0 ] ;
step1 [ 1 ] = step2 [ 1 ] ;
step1 [ 2 ] = step2 [ 2 ] ;
step1 [ 3 ] = step2 [ 3 ] ;
temp1 = step2 [ 4 ] * cospi_28_64 - step2 [ 7 ] * cospi_4_64 ;
temp2 = step2 [ 4 ] * cospi_4_64 + step2 [ 7 ] * cospi_28_64 ;
step1 [ 4 ] = dct_const_round_shift ( temp1 ) ;
step1 [ 7 ] = dct_const_round_shift ( temp2 ) ;
temp1 = step2 [ 5 ] * cospi_12_64 - step2 [ 6 ] * cospi_20_64 ;
temp2 = step2 [ 5 ] * cospi_20_64 + step2 [ 6 ] * cospi_12_64 ;
step1 [ 5 ] = dct_const_round_shift ( temp1 ) ;
step1 [ 6 ] = dct_const_round_shift ( temp2 ) ;
step1 [ 8 ] = step2 [ 8 ] + step2 [ 9 ] ;
step1 [ 9 ] = step2 [ 8 ] - step2 [ 9 ] ;
step1 [ 10 ] = - step2 [ 10 ] + step2 [ 11 ] ;
step1 [ 11 ] = step2 [ 10 ] + step2 [ 11 ] ;
step1 [ 12 ] = step2 [ 12 ] + step2 [ 13 ] ;
step1 [ 13 ] = step2 [ 12 ] - step2 [ 13 ] ;
step1 [ 14 ] = - step2 [ 14 ] + step2 [ 15 ] ;
step1 [ 15 ] = step2 [ 14 ] + step2 [ 15 ] ;
temp1 = ( step1 [ 0 ] + step1 [ 1 ] ) * cospi_16_64 ;
temp2 = ( step1 [ 0 ] - step1 [ 1 ] ) * cospi_16_64 ;
step2 [ 0 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 1 ] = dct_const_round_shift ( temp2 ) ;
temp1 = step1 [ 2 ] * cospi_24_64 - step1 [ 3 ] * cospi_8_64 ;
temp2 = step1 [ 2 ] * cospi_8_64 + step1 [ 3 ] * cospi_24_64 ;
step2 [ 2 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 3 ] = dct_const_round_shift ( temp2 ) ;
step2 [ 4 ] = step1 [ 4 ] + step1 [ 5 ] ;
step2 [ 5 ] = step1 [ 4 ] - step1 [ 5 ] ;
step2 [ 6 ] = - step1 [ 6 ] + step1 [ 7 ] ;
step2 [ 7 ] = step1 [ 6 ] + step1 [ 7 ] ;
step2 [ 8 ] = step1 [ 8 ] ;
step2 [ 15 ] = step1 [ 15 ] ;
temp1 = - step1 [ 9 ] * cospi_8_64 + step1 [ 14 ] * cospi_24_64 ;
temp2 = step1 [ 9 ] * cospi_24_64 + step1 [ 14 ] * cospi_8_64 ;
step2 [ 9 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 14 ] = dct_const_round_shift ( temp2 ) ;
temp1 = - step1 [ 10 ] * cospi_24_64 - step1 [ 13 ] * cospi_8_64 ;
temp2 = - step1 [ 10 ] * cospi_8_64 + step1 [ 13 ] * cospi_24_64 ;
step2 [ 10 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 13 ] = dct_const_round_shift ( temp2 ) ;
step2 [ 11 ] = step1 [ 11 ] ;
step2 [ 12 ] = step1 [ 12 ] ;
step1 [ 0 ] = step2 [ 0 ] + step2 [ 3 ] ;
step1 [ 1 ] = step2 [ 1 ] + step2 [ 2 ] ;
step1 [ 2 ] = step2 [ 1 ] - step2 [ 2 ] ;
step1 [ 3 ] = step2 [ 0 ] - step2 [ 3 ] ;
step1 [ 4 ] = step2 [ 4 ] ;
temp1 = ( step2 [ 6 ] - step2 [ 5 ] ) * cospi_16_64 ;
temp2 = ( step2 [ 5 ] + step2 [ 6 ] ) * cospi_16_64 ;
step1 [ 5 ] = dct_const_round_shift ( temp1 ) ;
step1 [ 6 ] = dct_const_round_shift ( temp2 ) ;
step1 [ 7 ] = step2 [ 7 ] ;
step1 [ 8 ] = step2 [ 8 ] + step2 [ 11 ] ;
step1 [ 9 ] = step2 [ 9 ] + step2 [ 10 ] ;
step1 [ 10 ] = step2 [ 9 ] - step2 [ 10 ] ;
step1 [ 11 ] = step2 [ 8 ] - step2 [ 11 ] ;
step1 [ 12 ] = - step2 [ 12 ] + step2 [ 15 ] ;
step1 [ 13 ] = - step2 [ 13 ] + step2 [ 14 ] ;
step1 [ 14 ] = step2 [ 13 ] + step2 [ 14 ] ;
step1 [ 15 ] = step2 [ 12 ] + step2 [ 15 ] ;
step2 [ 0 ] = step1 [ 0 ] + step1 [ 7 ] ;
step2 [ 1 ] = step1 [ 1 ] + step1 [ 6 ] ;
step2 [ 2 ] = step1 [ 2 ] + step1 [ 5 ] ;
step2 [ 3 ] = step1 [ 3 ] + step1 [ 4 ] ;
step2 [ 4 ] = step1 [ 3 ] - step1 [ 4 ] ;
step2 [ 5 ] = step1 [ 2 ] - step1 [ 5 ] ;
step2 [ 6 ] = step1 [ 1 ] - step1 [ 6 ] ;
step2 [ 7 ] = step1 [ 0 ] - step1 [ 7 ] ;
step2 [ 8 ] = step1 [ 8 ] ;
step2 [ 9 ] = step1 [ 9 ] ;
temp1 = ( - step1 [ 10 ] + step1 [ 13 ] ) * cospi_16_64 ;
temp2 = ( step1 [ 10 ] + step1 [ 13 ] ) * cospi_16_64 ;
step2 [ 10 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 13 ] = dct_const_round_shift ( temp2 ) ;
temp1 = ( - step1 [ 11 ] + step1 [ 12 ] ) * cospi_16_64 ;
temp2 = ( step1 [ 11 ] + step1 [ 12 ] ) * cospi_16_64 ;
step2 [ 11 ] = dct_const_round_shift ( temp1 ) ;
step2 [ 12 ] = dct_const_round_shift ( temp2 ) ;
step2 [ 14 ] = step1 [ 14 ] ;
step2 [ 15 ] = step1 [ 15 ] ;
output [ 0 ] = step2 [ 0 ] + step2 [ 15 ] ;
output [ 1 ] = step2 [ 1 ] + step2 [ 14 ] ;
output [ 2 ] = step2 [ 2 ] + step2 [ 13 ] ;
output [ 3 ] = step2 [ 3 ] + step2 [ 12 ] ;
output [ 4 ] = step2 [ 4 ] + step2 [ 11 ] ;
output [ 5 ] = step2 [ 5 ] + step2 [ 10 ] ;
output [ 6 ] = step2 [ 6 ] + step2 [ 9 ] ;
output [ 7 ] = step2 [ 7 ] + step2 [ 8 ] ;
output [ 8 ] = step2 [ 7 ] - step2 [ 8 ] ;
output [ 9 ] = step2 [ 6 ] - step2 [ 9 ] ;
output [ 10 ] = step2 [ 5 ] - step2 [ 10 ] ;
output [ 11 ] = step2 [ 4 ] - step2 [ 11 ] ;
output [ 12 ] = step2 [ 3 ] - step2 [ 12 ] ;
output [ 13 ] = step2 [ 2 ] - step2 [ 13 ] ;
output [ 14 ] = step2 [ 1 ] - step2 [ 14 ] ;
output [ 15 ] = step2 [ 0 ] - step2 [ 15 ] ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void decCopyFit ( decNumber * dest , const decNumber * src , decContext * set , Int * residue , uInt * status ) {
dest -> bits = src -> bits ;
dest -> exponent = src -> exponent ;
decSetCoeff ( dest , set , src -> lsu , src -> digits , residue , status ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static hb_script_t hb_ot_new_tag_to_script ( hb_tag_t tag ) {
switch ( tag ) {
case HB_TAG ( 'b' , 'n' , 'g' , '2' ) : return HB_SCRIPT_BENGALI ;
case HB_TAG ( 'd' , 'e' , 'v' , '2' ) : return HB_SCRIPT_DEVANAGARI ;
case HB_TAG ( 'g' , 'j' , 'r' , '2' ) : return HB_SCRIPT_GUJARATI ;
case HB_TAG ( 'g' , 'u' , 'r' , '2' ) : return HB_SCRIPT_GURMUKHI ;
case HB_TAG ( 'k' , 'n' , 'd' , '2' ) : return HB_SCRIPT_KANNADA ;
case HB_TAG ( 'm' , 'l' , 'm' , '2' ) : return HB_SCRIPT_MALAYALAM ;
case HB_TAG ( 'o' , 'r' , 'y' , '2' ) : return HB_SCRIPT_ORIYA ;
case HB_TAG ( 't' , 'm' , 'l' , '2' ) : return HB_SCRIPT_TAMIL ;
case HB_TAG ( 't' , 'e' , 'l' , '2' ) : return HB_SCRIPT_TELUGU ;
case HB_TAG ( 'm' , 'y' , 'm' , '2' ) : return HB_SCRIPT_MYANMAR ;
}
return HB_SCRIPT_UNKNOWN ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int com_nopager ( String * buffer __attribute__ ( ( unused ) ) , char * line __attribute__ ( ( unused ) ) ) {
strmov ( pager , "stdout" ) ;
opt_nopager = 1 ;
PAGER = stdout ;
tee_fprintf ( stdout , "PAGER set to stdout\n" ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_vm_enough_memory ( struct mm_struct * mm , long pages ) {
int rc , cap_sys_admin = 0 ;
rc = cred_has_capability ( current_cred ( ) , CAP_SYS_ADMIN , SECURITY_CAP_NOAUDIT , true ) ;
if ( rc == 0 ) cap_sys_admin = 1 ;
return cap_sys_admin ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static unsigned int dtls1_guess_mtu ( unsigned int curr_mtu ) {
unsigned int i ;
if ( curr_mtu == 0 ) return g_probable_mtu [ 0 ] ;
for ( i = 0 ;
i < sizeof ( g_probable_mtu ) / sizeof ( g_probable_mtu [ 0 ] ) ;
i ++ ) if ( curr_mtu > g_probable_mtu [ i ] ) return g_probable_mtu [ i ] ;
return curr_mtu ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void pdo_dbstmt_free_storage ( pdo_stmt_t * stmt TSRMLS_DC ) {
php_pdo_stmt_delref ( stmt TSRMLS_CC ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int ttfcopyfile ( FILE * ttf , FILE * other , int pos , const char * tab_name ) {
int ch ;
int ret = 1 ;
if ( ferror ( ttf ) || ferror ( other ) ) {
IError ( "Disk error of some nature. Perhaps no space on device?\nGenerated font will be unusable" ) ;
}
else if ( pos != ftell ( ttf ) ) {
IError ( "File Offset wrong for ttf table (%s), %d expected %d" , tab_name , ftell ( ttf ) , pos ) ;
}
rewind ( other ) ;
while ( ( ch = getc ( other ) ) != EOF ) putc ( ch , ttf ) ;
if ( ferror ( other ) ) ret = 0 ;
if ( fclose ( other ) ) ret = 0 ;
return ( ret ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void qcms_transform_module_clut_only ( struct qcms_modular_transform * transform , float * src , float * dest , size_t length ) {
size_t i ;
int xy_len = 1 ;
int x_len = transform -> grid_size ;
int len = x_len * x_len ;
float * r_table = transform -> r_clut ;
float * g_table = transform -> g_clut ;
float * b_table = transform -> b_clut ;
for ( i = 0 ;
i < length ;
i ++ ) {
float linear_r = * src ++ ;
float linear_g = * src ++ ;
float linear_b = * src ++ ;
int x = floor ( linear_r * ( transform -> grid_size - 1 ) ) ;
int y = floor ( linear_g * ( transform -> grid_size - 1 ) ) ;
int z = floor ( linear_b * ( transform -> grid_size - 1 ) ) ;
int x_n = ceil ( linear_r * ( transform -> grid_size - 1 ) ) ;
int y_n = ceil ( linear_g * ( transform -> grid_size - 1 ) ) ;
int z_n = ceil ( linear_b * ( transform -> grid_size - 1 ) ) ;
float x_d = linear_r * ( transform -> grid_size - 1 ) - x ;
float y_d = linear_g * ( transform -> grid_size - 1 ) - y ;
float z_d = linear_b * ( transform -> grid_size - 1 ) - z ;
float r_x1 = lerp ( CLU ( r_table , x , y , z ) , CLU ( r_table , x_n , y , z ) , x_d ) ;
float r_x2 = lerp ( CLU ( r_table , x , y_n , z ) , CLU ( r_table , x_n , y_n , z ) , x_d ) ;
float r_y1 = lerp ( r_x1 , r_x2 , y_d ) ;
float r_x3 = lerp ( CLU ( r_table , x , y , z_n ) , CLU ( r_table , x_n , y , z_n ) , x_d ) ;
float r_x4 = lerp ( CLU ( r_table , x , y_n , z_n ) , CLU ( r_table , x_n , y_n , z_n ) , x_d ) ;
float r_y2 = lerp ( r_x3 , r_x4 , y_d ) ;
float clut_r = lerp ( r_y1 , r_y2 , z_d ) ;
float g_x1 = lerp ( CLU ( g_table , x , y , z ) , CLU ( g_table , x_n , y , z ) , x_d ) ;
float g_x2 = lerp ( CLU ( g_table , x , y_n , z ) , CLU ( g_table , x_n , y_n , z ) , x_d ) ;
float g_y1 = lerp ( g_x1 , g_x2 , y_d ) ;
float g_x3 = lerp ( CLU ( g_table , x , y , z_n ) , CLU ( g_table , x_n , y , z_n ) , x_d ) ;
float g_x4 = lerp ( CLU ( g_table , x , y_n , z_n ) , CLU ( g_table , x_n , y_n , z_n ) , x_d ) ;
float g_y2 = lerp ( g_x3 , g_x4 , y_d ) ;
float clut_g = lerp ( g_y1 , g_y2 , z_d ) ;
float b_x1 = lerp ( CLU ( b_table , x , y , z ) , CLU ( b_table , x_n , y , z ) , x_d ) ;
float b_x2 = lerp ( CLU ( b_table , x , y_n , z ) , CLU ( b_table , x_n , y_n , z ) , x_d ) ;
float b_y1 = lerp ( b_x1 , b_x2 , y_d ) ;
float b_x3 = lerp ( CLU ( b_table , x , y , z_n ) , CLU ( b_table , x_n , y , z_n ) , x_d ) ;
float b_x4 = lerp ( CLU ( b_table , x , y_n , z_n ) , CLU ( b_table , x_n , y_n , z_n ) , x_d ) ;
float b_y2 = lerp ( b_x3 , b_x4 , y_d ) ;
float clut_b = lerp ( b_y1 , b_y2 , z_d ) ;
* dest ++ = clamp_float ( clut_r ) ;
* dest ++ = clamp_float ( clut_g ) ;
* dest ++ = clamp_float ( clut_b ) ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_T_mediaMode ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_T_mediaMode , T_mediaMode_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int read_skip ( VP9_COMMON * cm , const MACROBLOCKD * xd , int segment_id , vp9_reader * r ) {
if ( vp9_segfeature_active ( & cm -> seg , segment_id , SEG_LVL_SKIP ) ) {
return 1 ;
}
else {
const int ctx = vp9_get_skip_context ( xd ) ;
const int skip = vp9_read ( r , cm -> fc . skip_probs [ ctx ] ) ;
if ( ! cm -> frame_parallel_decoding_mode ) ++ cm -> counts . skip [ ctx ] [ skip ] ;
return skip ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int isoent_cmp_key ( const struct archive_rb_node * n , const void * key ) {
const struct isoent * e = ( const struct isoent * ) n ;
return ( strcmp ( e -> file -> basename . s , ( const char * ) key ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static PQExpBuffer defaultGetLocalPQExpBuffer ( void ) {
static PQExpBuffer id_return = NULL ;
if ( id_return ) {
resetPQExpBuffer ( id_return ) ;
}
else {
id_return = createPQExpBuffer ( ) ;
}
return id_return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int64_t vp9_rd_pick_inter_mode_sb ( VP9_COMP * cpi , MACROBLOCK * x , const TileInfo * const tile , int mi_row , int mi_col , 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 ;
const struct segmentation * const seg = & cm -> seg ;
struct macroblockd_plane * const pd = xd -> plane ;
PREDICTION_MODE this_mode ;
MV_REFERENCE_FRAME ref_frame , second_ref_frame ;
unsigned char segment_id = mbmi -> segment_id ;
int comp_pred , i , k ;
int_mv frame_mv [ MB_MODE_COUNT ] [ MAX_REF_FRAMES ] ;
struct buf_2d yv12_mb [ 4 ] [ MAX_MB_PLANE ] ;
int_mv single_newmv [ MAX_REF_FRAMES ] = {
{
0 }
}
;
INTERP_FILTER single_inter_filter [ MB_MODE_COUNT ] [ MAX_REF_FRAMES ] ;
int single_skippable [ MB_MODE_COUNT ] [ MAX_REF_FRAMES ] ;
static const int flag_list [ 4 ] = {
0 , VP9_LAST_FLAG , VP9_GOLD_FLAG , VP9_ALT_FLAG }
;
int64_t best_rd = best_rd_so_far ;
int64_t best_tx_rd [ TX_MODES ] ;
int64_t best_tx_diff [ TX_MODES ] ;
int64_t best_pred_diff [ REFERENCE_MODES ] ;
int64_t best_pred_rd [ REFERENCE_MODES ] ;
int64_t best_filter_rd [ SWITCHABLE_FILTER_CONTEXTS ] ;
int64_t best_filter_diff [ SWITCHABLE_FILTER_CONTEXTS ] ;
MB_MODE_INFO best_mbmode ;
int best_mode_skippable = 0 ;
int mode_index , best_mode_index = - 1 ;
unsigned int ref_costs_single [ MAX_REF_FRAMES ] , ref_costs_comp [ MAX_REF_FRAMES ] ;
vp9_prob comp_mode_p ;
int64_t best_intra_rd = INT64_MAX ;
int64_t best_inter_rd = INT64_MAX ;
PREDICTION_MODE best_intra_mode = DC_PRED ;
MV_REFERENCE_FRAME best_inter_ref_frame = LAST_FRAME ;
int rate_uv_intra [ TX_SIZES ] , rate_uv_tokenonly [ TX_SIZES ] ;
int64_t dist_uv [ TX_SIZES ] ;
int skip_uv [ TX_SIZES ] ;
PREDICTION_MODE mode_uv [ TX_SIZES ] ;
int intra_cost_penalty = 20 * vp9_dc_quant ( cm -> base_qindex , cm -> y_dc_delta_q ) ;
int best_skip2 = 0 ;
int mode_skip_mask = 0 ;
int mode_skip_start = cpi -> sf . mode_skip_start + 1 ;
const int * const rd_threshes = rd_opt -> threshes [ segment_id ] [ bsize ] ;
const int * const rd_thresh_freq_fact = rd_opt -> thresh_freq_fact [ bsize ] ;
const int mode_search_skip_flags = cpi -> sf . mode_search_skip_flags ;
const int intra_y_mode_mask = cpi -> sf . intra_y_mode_mask [ max_txsize_lookup [ bsize ] ] ;
int inter_mode_mask = cpi -> sf . inter_mode_mask [ bsize ] ;
vp9_zero ( best_mbmode ) ;
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 < REFERENCE_MODES ;
++ i ) best_pred_rd [ i ] = INT64_MAX ;
for ( i = 0 ;
i < TX_MODES ;
i ++ ) best_tx_rd [ i ] = INT64_MAX ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) best_filter_rd [ i ] = INT64_MAX ;
for ( i = 0 ;
i < TX_SIZES ;
i ++ ) rate_uv_intra [ i ] = INT_MAX ;
for ( i = 0 ;
i < MAX_REF_FRAMES ;
++ i ) x -> pred_sse [ i ] = INT_MAX ;
for ( i = 0 ;
i < MB_MODE_COUNT ;
++ i ) {
for ( k = 0 ;
k < MAX_REF_FRAMES ;
++ k ) {
single_inter_filter [ i ] [ k ] = SWITCHABLE ;
single_skippable [ i ] [ k ] = 0 ;
}
}
* returnrate = INT_MAX ;
for ( ref_frame = LAST_FRAME ;
ref_frame <= ALTREF_FRAME ;
++ ref_frame ) {
x -> pred_mv_sad [ ref_frame ] = INT_MAX ;
if ( cpi -> ref_frame_flags & flag_list [ ref_frame ] ) {
setup_buffer_inter ( cpi , x , tile , ref_frame , bsize , mi_row , mi_col , frame_mv [ NEARESTMV ] , frame_mv [ NEARMV ] , yv12_mb ) ;
}
frame_mv [ NEWMV ] [ ref_frame ] . as_int = INVALID_MV ;
frame_mv [ ZEROMV ] [ ref_frame ] . as_int = 0 ;
}
for ( ref_frame = LAST_FRAME ;
ref_frame <= ALTREF_FRAME ;
++ ref_frame ) {
static const int ref_frame_mask_all [ ] = {
0x0 , 0x123291 , 0x25c444 , 0x39b722 }
;
static const int ref_frame_mask_fixedmv [ ] = {
0x0 , 0x121281 , 0x24c404 , 0x080102 }
;
if ( ! ( cpi -> ref_frame_flags & flag_list [ ref_frame ] ) ) {
mode_skip_mask |= ref_frame_mask_all [ ref_frame ] ;
}
else if ( cpi -> sf . reference_masking ) {
for ( i = LAST_FRAME ;
i <= ALTREF_FRAME ;
++ i ) {
if ( ( x -> pred_mv_sad [ ref_frame ] >> 2 ) > x -> pred_mv_sad [ i ] ) {
mode_skip_mask |= ref_frame_mask_fixedmv [ ref_frame ] ;
break ;
}
}
}
if ( vp9_segfeature_active ( seg , segment_id , SEG_LVL_REF_FRAME ) && vp9_get_segdata ( seg , segment_id , SEG_LVL_REF_FRAME ) != ( int ) ref_frame ) {
mode_skip_mask |= ref_frame_mask_all [ ref_frame ] ;
}
}
if ( ! vp9_segfeature_active ( seg , segment_id , SEG_LVL_REF_FRAME ) ) {
if ( cpi -> rc . is_src_frame_alt_ref && ( cpi -> oxcf . arnr_max_frames == 0 ) ) {
mode_skip_mask = ~ ( ( 1 << THR_NEARESTA ) | ( 1 << THR_NEARA ) | ( 1 << THR_ZEROA ) ) ;
if ( frame_mv [ NEARMV ] [ ALTREF_FRAME ] . as_int != 0 ) mode_skip_mask |= ( 1 << THR_NEARA ) ;
if ( frame_mv [ NEARESTMV ] [ ALTREF_FRAME ] . as_int != 0 ) mode_skip_mask |= ( 1 << THR_NEARESTA ) ;
}
}
if ( bsize > cpi -> sf . max_intra_bsize ) {
const int all_intra_modes = ( 1 << THR_DC ) | ( 1 << THR_TM ) | ( 1 << THR_H_PRED ) | ( 1 << THR_V_PRED ) | ( 1 << THR_D135_PRED ) | ( 1 << THR_D207_PRED ) | ( 1 << THR_D153_PRED ) | ( 1 << THR_D63_PRED ) | ( 1 << THR_D117_PRED ) | ( 1 << THR_D45_PRED ) ;
mode_skip_mask |= all_intra_modes ;
}
for ( mode_index = 0 ;
mode_index < MAX_MODES ;
++ mode_index ) {
int mode_excluded = 0 ;
int64_t this_rd = INT64_MAX ;
int disable_skip = 0 ;
int compmode_cost = 0 ;
int rate2 = 0 , rate_y = 0 , rate_uv = 0 ;
int64_t distortion2 = 0 , distortion_y = 0 , distortion_uv = 0 ;
int skippable = 0 ;
int64_t tx_cache [ TX_MODES ] ;
int i ;
int this_skip2 = 0 ;
int64_t total_sse = INT64_MAX ;
int early_term = 0 ;
this_mode = vp9_mode_order [ mode_index ] . mode ;
ref_frame = vp9_mode_order [ mode_index ] . ref_frame [ 0 ] ;
if ( ref_frame != INTRA_FRAME && ! ( inter_mode_mask & ( 1 << this_mode ) ) ) continue ;
second_ref_frame = vp9_mode_order [ mode_index ] . ref_frame [ 1 ] ;
if ( mode_index == mode_skip_start && best_mode_index >= 0 ) {
switch ( vp9_mode_order [ best_mode_index ] . ref_frame [ 0 ] ) {
case INTRA_FRAME : break ;
case LAST_FRAME : mode_skip_mask |= LAST_FRAME_MODE_MASK ;
break ;
case GOLDEN_FRAME : mode_skip_mask |= GOLDEN_FRAME_MODE_MASK ;
break ;
case ALTREF_FRAME : mode_skip_mask |= ALT_REF_MODE_MASK ;
break ;
case NONE : case MAX_REF_FRAMES : assert ( 0 && "Invalid Reference frame" ) ;
break ;
}
}
if ( cpi -> sf . alt_ref_search_fp && cpi -> rc . is_src_frame_alt_ref ) {
mode_skip_mask = 0 ;
if ( ! ( ref_frame == ALTREF_FRAME && second_ref_frame == NONE ) ) continue ;
}
if ( mode_skip_mask & ( 1 << mode_index ) ) continue ;
if ( rd_less_than_thresh ( best_rd , rd_threshes [ mode_index ] , rd_thresh_freq_fact [ mode_index ] ) ) continue ;
if ( cpi -> sf . motion_field_mode_search ) {
const int mi_width = MIN ( num_8x8_blocks_wide_lookup [ bsize ] , tile -> mi_col_end - mi_col ) ;
const int mi_height = MIN ( num_8x8_blocks_high_lookup [ bsize ] , tile -> mi_row_end - mi_row ) ;
const int bsl = mi_width_log2 ( bsize ) ;
int cb_partition_search_ctrl = ( ( ( mi_row + mi_col ) >> bsl ) + get_chessboard_index ( cm -> current_video_frame ) ) & 0x1 ;
MB_MODE_INFO * ref_mbmi ;
int const_motion = 1 ;
int skip_ref_frame = ! cb_partition_search_ctrl ;
MV_REFERENCE_FRAME rf = NONE ;
int_mv ref_mv ;
ref_mv . as_int = INVALID_MV ;
if ( ( mi_row - 1 ) >= tile -> mi_row_start ) {
ref_mv = xd -> mi [ - xd -> mi_stride ] -> mbmi . mv [ 0 ] ;
rf = xd -> mi [ - xd -> mi_stride ] -> mbmi . ref_frame [ 0 ] ;
for ( i = 0 ;
i < mi_width ;
++ i ) {
ref_mbmi = & xd -> mi [ - xd -> mi_stride + i ] -> mbmi ;
const_motion &= ( ref_mv . as_int == ref_mbmi -> mv [ 0 ] . as_int ) && ( ref_frame == ref_mbmi -> ref_frame [ 0 ] ) ;
skip_ref_frame &= ( rf == ref_mbmi -> ref_frame [ 0 ] ) ;
}
}
if ( ( mi_col - 1 ) >= tile -> mi_col_start ) {
if ( ref_mv . as_int == INVALID_MV ) ref_mv = xd -> mi [ - 1 ] -> mbmi . mv [ 0 ] ;
if ( rf == NONE ) rf = xd -> mi [ - 1 ] -> mbmi . ref_frame [ 0 ] ;
for ( i = 0 ;
i < mi_height ;
++ i ) {
ref_mbmi = & xd -> mi [ i * xd -> mi_stride - 1 ] -> mbmi ;
const_motion &= ( ref_mv . as_int == ref_mbmi -> mv [ 0 ] . as_int ) && ( ref_frame == ref_mbmi -> ref_frame [ 0 ] ) ;
skip_ref_frame &= ( rf == ref_mbmi -> ref_frame [ 0 ] ) ;
}
}
if ( skip_ref_frame && this_mode != NEARESTMV && this_mode != NEWMV ) if ( rf > INTRA_FRAME ) if ( ref_frame != rf ) continue ;
if ( const_motion ) if ( this_mode == NEARMV || this_mode == ZEROMV ) continue ;
}
comp_pred = second_ref_frame > INTRA_FRAME ;
if ( comp_pred ) {
if ( ! cm -> allow_comp_inter_inter ) continue ;
if ( ( mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA ) && best_mode_index >= 0 && vp9_mode_order [ best_mode_index ] . ref_frame [ 0 ] == INTRA_FRAME ) continue ;
if ( ( mode_search_skip_flags & FLAG_SKIP_COMP_REFMISMATCH ) && ref_frame != best_inter_ref_frame && second_ref_frame != best_inter_ref_frame ) continue ;
mode_excluded = cm -> reference_mode == SINGLE_REFERENCE ;
}
else {
if ( ref_frame != INTRA_FRAME ) mode_excluded = cm -> reference_mode == COMPOUND_REFERENCE ;
}
if ( ref_frame == INTRA_FRAME ) {
if ( cpi -> sf . adaptive_mode_search ) if ( ( x -> source_variance << num_pels_log2_lookup [ bsize ] ) > best_intra_rd ) continue ;
if ( ! ( intra_y_mode_mask & ( 1 << this_mode ) ) ) continue ;
if ( this_mode != DC_PRED ) {
const unsigned int skip_intra_var_thresh = 64 ;
if ( ( mode_search_skip_flags & FLAG_SKIP_INTRA_LOWVAR ) && x -> source_variance < skip_intra_var_thresh ) continue ;
if ( ( mode_search_skip_flags & FLAG_SKIP_INTRA_BESTINTER ) && ( this_mode >= D45_PRED && this_mode <= TM_PRED ) ) {
if ( best_mode_index >= 0 && vp9_mode_order [ best_mode_index ] . ref_frame [ 0 ] > INTRA_FRAME ) continue ;
}
if ( mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH ) {
if ( conditional_skipintra ( this_mode , best_intra_mode ) ) continue ;
}
}
}
else {
const MV_REFERENCE_FRAME ref_frames [ 2 ] = {
ref_frame , second_ref_frame }
;
if ( ! check_best_zero_mv ( cpi , mbmi -> mode_context , frame_mv , inter_mode_mask , this_mode , ref_frames ) ) continue ;
}
mbmi -> mode = this_mode ;
mbmi -> uv_mode = DC_PRED ;
mbmi -> ref_frame [ 0 ] = ref_frame ;
mbmi -> ref_frame [ 1 ] = second_ref_frame ;
mbmi -> interp_filter = cm -> interp_filter == SWITCHABLE ? EIGHTTAP : cm -> interp_filter ;
mbmi -> mv [ 0 ] . as_int = mbmi -> mv [ 1 ] . as_int = 0 ;
x -> skip = 0 ;
set_ref_ptrs ( cm , xd , ref_frame , second_ref_frame ) ;
for ( i = 0 ;
i < MAX_MB_PLANE ;
i ++ ) {
xd -> plane [ i ] . pre [ 0 ] = yv12_mb [ ref_frame ] [ i ] ;
if ( comp_pred ) xd -> plane [ i ] . pre [ 1 ] = yv12_mb [ second_ref_frame ] [ i ] ;
}
for ( i = 0 ;
i < TX_MODES ;
++ i ) tx_cache [ i ] = INT64_MAX ;
if ( ref_frame == INTRA_FRAME ) {
TX_SIZE uv_tx ;
super_block_yrd ( cpi , x , & rate_y , & distortion_y , & skippable , NULL , bsize , tx_cache , best_rd ) ;
if ( rate_y == INT_MAX ) continue ;
uv_tx = get_uv_tx_size_impl ( mbmi -> tx_size , bsize , pd [ 1 ] . subsampling_x , pd [ 1 ] . subsampling_y ) ;
if ( rate_uv_intra [ uv_tx ] == INT_MAX ) {
choose_intra_uv_mode ( cpi , ctx , bsize , uv_tx , & rate_uv_intra [ uv_tx ] , & rate_uv_tokenonly [ uv_tx ] , & dist_uv [ uv_tx ] , & skip_uv [ uv_tx ] , & mode_uv [ uv_tx ] ) ;
}
rate_uv = rate_uv_tokenonly [ uv_tx ] ;
distortion_uv = dist_uv [ uv_tx ] ;
skippable = skippable && skip_uv [ uv_tx ] ;
mbmi -> uv_mode = mode_uv [ uv_tx ] ;
rate2 = rate_y + cpi -> mbmode_cost [ mbmi -> mode ] + rate_uv_intra [ uv_tx ] ;
if ( this_mode != DC_PRED && this_mode != TM_PRED ) rate2 += intra_cost_penalty ;
distortion2 = distortion_y + distortion_uv ;
}
else {
this_rd = handle_inter_mode ( cpi , x , bsize , tx_cache , & rate2 , & distortion2 , & skippable , & rate_y , & distortion_y , & rate_uv , & distortion_uv , & disable_skip , frame_mv , mi_row , mi_col , single_newmv , single_inter_filter , single_skippable , & total_sse , best_rd ) ;
if ( this_rd == INT64_MAX ) continue ;
compmode_cost = vp9_cost_bit ( comp_mode_p , comp_pred ) ;
if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) rate2 += compmode_cost ;
}
if ( comp_pred ) {
rate2 += ref_costs_comp [ ref_frame ] ;
}
else {
rate2 += ref_costs_single [ ref_frame ] ;
}
if ( ! disable_skip ) {
if ( skippable ) {
vp9_prob skip_prob = vp9_get_skip_prob ( cm , xd ) ;
rate2 -= ( rate_y + rate_uv ) ;
rate_uv = 0 ;
if ( skip_prob ) {
int prob_skip_cost = vp9_cost_bit ( skip_prob , 1 ) ;
rate2 += prob_skip_cost ;
}
}
else if ( ref_frame != INTRA_FRAME && ! xd -> lossless ) {
if ( RDCOST ( x -> rdmult , x -> rddiv , rate_y + rate_uv , distortion2 ) < RDCOST ( x -> rdmult , x -> rddiv , 0 , total_sse ) ) {
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 0 ) ;
}
else {
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 1 ) ;
distortion2 = total_sse ;
assert ( total_sse >= 0 ) ;
rate2 -= ( rate_y + rate_uv ) ;
rate_y = 0 ;
rate_uv = 0 ;
this_skip2 = 1 ;
}
}
else {
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 0 ) ;
}
this_rd = RDCOST ( x -> rdmult , x -> rddiv , rate2 , distortion2 ) ;
}
if ( ref_frame == INTRA_FRAME ) {
if ( this_rd < best_intra_rd ) {
best_intra_rd = this_rd ;
best_intra_mode = mbmi -> mode ;
}
}
else {
if ( ! comp_pred && ! mode_excluded && this_rd < best_inter_rd ) {
best_inter_rd = this_rd ;
best_inter_ref_frame = ref_frame ;
}
}
if ( ! disable_skip && ref_frame == INTRA_FRAME ) {
for ( i = 0 ;
i < REFERENCE_MODES ;
++ i ) best_pred_rd [ i ] = MIN ( best_pred_rd [ i ] , this_rd ) ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) best_filter_rd [ i ] = MIN ( best_filter_rd [ i ] , this_rd ) ;
}
if ( this_rd < best_rd || x -> skip ) {
int max_plane = MAX_MB_PLANE ;
if ( ! mode_excluded ) {
best_mode_index = mode_index ;
if ( ref_frame == INTRA_FRAME ) {
mbmi -> mv [ 0 ] . as_int = 0 ;
max_plane = 1 ;
}
else {
best_intra_rd = x -> pred_sse [ ref_frame ] ;
}
* returnrate = rate2 ;
* returndistortion = distortion2 ;
best_rd = this_rd ;
best_mbmode = * mbmi ;
best_skip2 = this_skip2 ;
best_mode_skippable = skippable ;
if ( ! x -> select_tx_size ) swap_block_ptr ( x , ctx , 1 , 0 , 0 , max_plane ) ;
vpx_memcpy ( ctx -> zcoeff_blk , x -> zcoeff_blk [ mbmi -> tx_size ] , sizeof ( uint8_t ) * ctx -> num_4x4_blk ) ;
if ( ( mode_search_skip_flags & FLAG_EARLY_TERMINATE ) && ( mode_index > MIN_EARLY_TERM_INDEX ) ) {
const int qstep = xd -> plane [ 0 ] . dequant [ 1 ] ;
int scale = 4 ;
if ( x -> source_variance < UINT_MAX ) {
const int var_adjust = ( x -> source_variance < 16 ) ;
scale -= var_adjust ;
}
if ( ref_frame > INTRA_FRAME && distortion2 * scale < qstep * qstep ) {
early_term = 1 ;
}
}
}
}
if ( ! disable_skip && ref_frame != INTRA_FRAME ) {
int64_t single_rd , hybrid_rd , single_rate , hybrid_rate ;
if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) {
single_rate = rate2 - compmode_cost ;
hybrid_rate = rate2 ;
}
else {
single_rate = rate2 ;
hybrid_rate = rate2 + compmode_cost ;
}
single_rd = RDCOST ( x -> rdmult , x -> rddiv , single_rate , distortion2 ) ;
hybrid_rd = RDCOST ( x -> rdmult , x -> rddiv , hybrid_rate , distortion2 ) ;
if ( ! comp_pred ) {
if ( single_rd < best_pred_rd [ SINGLE_REFERENCE ] ) {
best_pred_rd [ SINGLE_REFERENCE ] = single_rd ;
}
}
else {
if ( single_rd < best_pred_rd [ COMPOUND_REFERENCE ] ) {
best_pred_rd [ COMPOUND_REFERENCE ] = single_rd ;
}
}
if ( hybrid_rd < best_pred_rd [ REFERENCE_MODE_SELECT ] ) best_pred_rd [ REFERENCE_MODE_SELECT ] = hybrid_rd ;
if ( ! mode_excluded && cm -> interp_filter != BILINEAR ) {
int64_t ref = rd_opt -> filter_cache [ cm -> interp_filter == SWITCHABLE ? SWITCHABLE_FILTERS : cm -> interp_filter ] ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) {
int64_t adj_rd ;
if ( ref == INT64_MAX ) adj_rd = 0 ;
else if ( rd_opt -> filter_cache [ i ] == INT64_MAX ) adj_rd = rd_opt -> mask_filter - ref + 10 ;
else adj_rd = rd_opt -> filter_cache [ i ] - ref ;
adj_rd += this_rd ;
best_filter_rd [ i ] = MIN ( best_filter_rd [ i ] , adj_rd ) ;
}
}
}
if ( bsize < BLOCK_32X32 ) {
if ( bsize < BLOCK_16X16 ) tx_cache [ ALLOW_16X16 ] = tx_cache [ ALLOW_8X8 ] ;
tx_cache [ ALLOW_32X32 ] = tx_cache [ ALLOW_16X16 ] ;
}
if ( ! mode_excluded && this_rd != INT64_MAX ) {
for ( i = 0 ;
i < TX_MODES && tx_cache [ i ] < INT64_MAX ;
i ++ ) {
int64_t adj_rd = INT64_MAX ;
adj_rd = this_rd + tx_cache [ i ] - tx_cache [ cm -> tx_mode ] ;
if ( adj_rd < best_tx_rd [ i ] ) best_tx_rd [ i ] = adj_rd ;
}
}
if ( early_term ) break ;
if ( x -> skip && ! comp_pred ) break ;
}
if ( best_mbmode . mode == NEWMV ) {
const MV_REFERENCE_FRAME refs [ 2 ] = {
best_mbmode . ref_frame [ 0 ] , best_mbmode . ref_frame [ 1 ] }
;
int comp_pred_mode = refs [ 1 ] > INTRA_FRAME ;
if ( frame_mv [ NEARESTMV ] [ refs [ 0 ] ] . as_int == best_mbmode . mv [ 0 ] . as_int && ( ( comp_pred_mode && frame_mv [ NEARESTMV ] [ refs [ 1 ] ] . as_int == best_mbmode . mv [ 1 ] . as_int ) || ! comp_pred_mode ) ) best_mbmode . mode = NEARESTMV ;
else if ( frame_mv [ NEARMV ] [ refs [ 0 ] ] . as_int == best_mbmode . mv [ 0 ] . as_int && ( ( comp_pred_mode && frame_mv [ NEARMV ] [ refs [ 1 ] ] . as_int == best_mbmode . mv [ 1 ] . as_int ) || ! comp_pred_mode ) ) best_mbmode . mode = NEARMV ;
else if ( best_mbmode . mv [ 0 ] . as_int == 0 && ( ( comp_pred_mode && best_mbmode . mv [ 1 ] . as_int == 0 ) || ! comp_pred_mode ) ) best_mbmode . mode = ZEROMV ;
}
if ( best_mode_index < 0 || best_rd >= best_rd_so_far ) return INT64_MAX ;
if ( cpi -> sf . use_uv_intra_rd_estimate ) {
if ( vp9_mode_order [ best_mode_index ] . ref_frame [ 0 ] == INTRA_FRAME ) {
TX_SIZE uv_tx_size ;
* mbmi = best_mbmode ;
uv_tx_size = get_uv_tx_size ( mbmi , & xd -> plane [ 1 ] ) ;
rd_pick_intra_sbuv_mode ( cpi , x , ctx , & rate_uv_intra [ uv_tx_size ] , & rate_uv_tokenonly [ uv_tx_size ] , & dist_uv [ uv_tx_size ] , & skip_uv [ uv_tx_size ] , bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize , uv_tx_size ) ;
}
}
assert ( ( cm -> interp_filter == SWITCHABLE ) || ( cm -> interp_filter == best_mbmode . interp_filter ) || ! is_inter_block ( & best_mbmode ) ) ;
update_rd_thresh_fact ( cpi , bsize , best_mode_index ) ;
* mbmi = best_mbmode ;
x -> skip |= best_skip2 ;
for ( i = 0 ;
i < REFERENCE_MODES ;
++ i ) {
if ( best_pred_rd [ i ] == INT64_MAX ) best_pred_diff [ i ] = INT_MIN ;
else best_pred_diff [ i ] = best_rd - best_pred_rd [ i ] ;
}
if ( ! x -> skip ) {
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) {
if ( best_filter_rd [ i ] == INT64_MAX ) best_filter_diff [ i ] = 0 ;
else best_filter_diff [ i ] = best_rd - best_filter_rd [ i ] ;
}
if ( cm -> interp_filter == SWITCHABLE ) assert ( best_filter_diff [ SWITCHABLE_FILTERS ] == 0 ) ;
for ( i = 0 ;
i < TX_MODES ;
i ++ ) {
if ( best_tx_rd [ i ] == INT64_MAX ) best_tx_diff [ i ] = 0 ;
else best_tx_diff [ i ] = best_rd - best_tx_rd [ i ] ;
}
}
else {
vp9_zero ( best_filter_diff ) ;
vp9_zero ( best_tx_diff ) ;
}
set_ref_ptrs ( cm , xd , mbmi -> ref_frame [ 0 ] , mbmi -> ref_frame [ 1 ] ) ;
store_coding_context ( x , ctx , best_mode_index , best_pred_diff , best_tx_diff , best_filter_diff , best_mode_skippable ) ;
return best_rd ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_OpenLogicalChannelRejectCause ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_OpenLogicalChannelRejectCause , OpenLogicalChannelRejectCause_choice , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void free_xargs ( xargs_t xargs ) {
if ( xargs . dn ) free ( xargs . dn ) ;
if ( xargs . linkdn ) free ( xargs . linkdn ) ;
if ( xargs . containerdn ) free ( xargs . containerdn ) ;
if ( xargs . tktpolicydn ) free ( xargs . tktpolicydn ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int main ( int argc , char * argv [ ] ) {
const char * globfile [ ] = {
"one" , "two" , "three" , NULL }
;
char tmpdir [ 32 ] ;
struct passwd * pw ;
const char * cwd ;
int test ;
int fail = 0 ;
int i ;
struct test_case_struct ts ;
if ( argc > 1 ) {
command_line_test ( argv [ 1 ] ) ;
return 0 ;
}
cwd = getcwd ( NULL , 0 ) ;
tmpnam ( tmpdir ) ;
if ( mkdir ( tmpdir , S_IRWXU ) || chdir ( tmpdir ) ) return - 1 ;
else {
int fd ;
for ( i = 0 ;
globfile [ i ] ;
++ i ) if ( ( fd = creat ( globfile [ i ] , S_IRUSR | S_IWUSR ) ) == - 1 || close ( fd ) ) return - 1 ;
}
for ( test = 0 ;
test_case [ test ] . retval != - 1 ;
test ++ ) if ( testit ( & test_case [ test ] ) ) ++ fail ;
pw = getpwnam ( "root" ) ;
if ( pw != NULL ) {
ts . retval = 0 ;
ts . env = NULL ;
ts . words = "~root " ;
ts . flags = 0 ;
ts . wordc = 1 ;
ts . wordv [ 0 ] = pw -> pw_dir ;
ts . ifs = IFS ;
if ( testit ( & ts ) ) ++ fail ;
ts . retval = 0 ;
ts . env = pw -> pw_dir ;
ts . words = "${
var#~root}
x" ;
ts . flags = 0 ;
ts . wordc = 1 ;
ts . wordv [ 0 ] = "x" ;
ts . ifs = IFS ;
if ( testit ( & ts ) ) ++ fail ;
}
setenv ( "HOME" , "/dummy/home" , 1 ) ;
ts . retval = 0 ;
ts . env = NULL ;
ts . words = "~ ~/foo" ;
ts . flags = 0 ;
ts . wordc = 2 ;
ts . wordv [ 0 ] = "/dummy/home" ;
ts . wordv [ 1 ] = "/dummy/home/foo" ;
ts . ifs = IFS ;
if ( testit ( & ts ) ) ++ fail ;
pw = getpwuid ( getuid ( ) ) ;
if ( pw != NULL ) {
unsetenv ( "HOME" ) ;
ts . retval = 0 ;
ts . env = NULL ;
ts . words = "~" ;
ts . flags = 0 ;
ts . wordc = 1 ;
ts . wordv [ 0 ] = pw -> pw_dir ;
ts . ifs = IFS ;
if ( testit ( & ts ) ) ++ fail ;
}
puts ( "tests completed, now cleaning up" ) ;
for ( i = 0 ;
globfile [ i ] ;
++ i ) remove ( globfile [ i ] ) ;
if ( cwd == NULL ) cwd = ".." ;
chdir ( cwd ) ;
rmdir ( tmpdir ) ;
printf ( "tests failed: %d\n" , fail ) ;
return fail != 0 ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_iht4x4_16_add_c ( const tran_low_t * input , uint8_t * dest , int stride , int tx_type ) {
const transform_2d IHT_4 [ ] = {
{
idct4 , idct4 }
, {
iadst4 , idct4 }
, {
idct4 , iadst4 }
, {
iadst4 , iadst4 }
}
;
int i , j ;
tran_low_t out [ 4 * 4 ] ;
tran_low_t * outptr = out ;
tran_low_t temp_in [ 4 ] , temp_out [ 4 ] ;
for ( i = 0 ;
i < 4 ;
++ i ) {
IHT_4 [ tx_type ] . rows ( input , outptr ) ;
input += 4 ;
outptr += 4 ;
}
for ( i = 0 ;
i < 4 ;
++ i ) {
for ( j = 0 ;
j < 4 ;
++ j ) temp_in [ j ] = out [ j * 4 + i ] ;
IHT_4 [ tx_type ] . cols ( temp_in , temp_out ) ;
for ( j = 0 ;
j < 4 ;
++ j ) dest [ j * stride + i ] = clip_pixel ( ROUND_POWER_OF_TWO ( temp_out [ j ] , 4 ) + dest [ j * stride + i ] ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void hb_blob_destroy ( hb_blob_t * blob ) {
if ( ! hb_object_destroy ( blob ) ) return ;
_hb_blob_destroy_user_data ( blob ) ;
free ( blob ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void xmlHashScan ( xmlHashTablePtr table , xmlHashScanner f , void * data ) {
stubData stubdata ;
stubdata . data = data ;
stubdata . hashscanner = f ;
xmlHashScanFull ( table , stubHashScannerFull , & stubdata ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void virtio_net_get_config ( VirtIODevice * vdev , uint8_t * config ) {
VirtIONet * n = to_virtio_net ( vdev ) ;
struct virtio_net_config netcfg ;
stw_p ( & netcfg . status , n -> status ) ;
memcpy ( netcfg . mac , n -> mac , ETH_ALEN ) ;
memcpy ( config , & netcfg , sizeof ( netcfg ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void handle_lockprop_ctx ( struct xml_ctx * ctx , int tag_closed ) {
int * lock_flags = ( int * ) ctx -> userData ;
if ( tag_closed ) {
if ( ! strcmp ( ctx -> name , DAV_CTX_LOCKENTRY ) ) {
if ( ( * lock_flags & DAV_PROP_LOCKEX ) && ( * lock_flags & DAV_PROP_LOCKWR ) ) {
* lock_flags |= DAV_LOCK_OK ;
}
* lock_flags &= DAV_LOCK_OK ;
}
else if ( ! strcmp ( ctx -> name , DAV_CTX_LOCKTYPE_WRITE ) ) {
* lock_flags |= DAV_PROP_LOCKWR ;
}
else if ( ! strcmp ( ctx -> name , DAV_CTX_LOCKTYPE_EXCLUSIVE ) ) {
* lock_flags |= DAV_PROP_LOCKEX ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int vp9_full_search_sadx8 ( const MACROBLOCK * x , const MV * ref_mv , int sad_per_bit , int distance , const vp9_variance_fn_ptr_t * fn_ptr , const MV * center_mv , MV * best_mv ) {
int r ;
const MACROBLOCKD * const xd = & x -> e_mbd ;
const struct buf_2d * const what = & x -> plane [ 0 ] . src ;
const struct buf_2d * const in_what = & xd -> plane [ 0 ] . pre [ 0 ] ;
const int row_min = MAX ( ref_mv -> row - distance , x -> mv_row_min ) ;
const int row_max = MIN ( ref_mv -> row + distance , x -> mv_row_max ) ;
const int col_min = MAX ( ref_mv -> col - distance , x -> mv_col_min ) ;
const int col_max = MIN ( ref_mv -> col + distance , x -> mv_col_max ) ;
const MV fcenter_mv = {
center_mv -> row >> 3 , center_mv -> col >> 3 }
;
unsigned int best_sad = fn_ptr -> sdf ( what -> buf , what -> stride , get_buf_from_mv ( in_what , ref_mv ) , in_what -> stride ) + mvsad_err_cost ( x , ref_mv , & fcenter_mv , sad_per_bit ) ;
* best_mv = * ref_mv ;
for ( r = row_min ;
r < row_max ;
++ r ) {
int c = col_min ;
const uint8_t * check_here = & in_what -> buf [ r * in_what -> stride + c ] ;
if ( fn_ptr -> sdx8f != NULL ) {
while ( ( c + 7 ) < col_max ) {
int i ;
unsigned int sads [ 8 ] ;
fn_ptr -> sdx8f ( what -> buf , what -> stride , check_here , in_what -> stride , sads ) ;
for ( i = 0 ;
i < 8 ;
++ i ) {
unsigned int sad = sads [ i ] ;
if ( sad < best_sad ) {
const MV mv = {
r , c }
;
sad += mvsad_err_cost ( x , & mv , & fcenter_mv , sad_per_bit ) ;
if ( sad < best_sad ) {
best_sad = sad ;
* best_mv = mv ;
}
}
++ check_here ;
++ c ;
}
}
}
if ( fn_ptr -> sdx3f != NULL ) {
while ( ( c + 2 ) < col_max ) {
int i ;
unsigned int sads [ 3 ] ;
fn_ptr -> sdx3f ( what -> buf , what -> stride , check_here , in_what -> stride , sads ) ;
for ( i = 0 ;
i < 3 ;
++ i ) {
unsigned int sad = sads [ i ] ;
if ( sad < best_sad ) {
const MV mv = {
r , c }
;
sad += mvsad_err_cost ( x , & mv , & fcenter_mv , sad_per_bit ) ;
if ( sad < best_sad ) {
best_sad = sad ;
* best_mv = mv ;
}
}
++ check_here ;
++ c ;
}
}
}
while ( c < col_max ) {
unsigned int sad = fn_ptr -> sdf ( what -> buf , what -> stride , check_here , in_what -> stride ) ;
if ( sad < best_sad ) {
const MV mv = {
r , c }
;
sad += mvsad_err_cost ( x , & mv , & fcenter_mv , sad_per_bit ) ;
if ( sad < best_sad ) {
best_sad = sad ;
* best_mv = mv ;
}
}
++ check_here ;
++ c ;
}
}
return best_sad ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void wm_writecb ( struct bufferevent * bev , void * arg ) {
if ( EVBUFFER_LENGTH ( bev -> output ) == 0 ) test_ok ++ ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ipvideo_decode_block_opcode_0x7 ( IpvideoContext * s , AVFrame * frame ) {
int x , y ;
unsigned char P [ 2 ] ;
unsigned int flags ;
P [ 0 ] = bytestream2_get_byte ( & s -> stream_ptr ) ;
P [ 1 ] = bytestream2_get_byte ( & s -> stream_ptr ) ;
if ( P [ 0 ] <= P [ 1 ] ) {
for ( y = 0 ;
y < 8 ;
y ++ ) {
flags = bytestream2_get_byte ( & s -> stream_ptr ) | 0x100 ;
for ( ;
flags != 1 ;
flags >>= 1 ) * s -> pixel_ptr ++ = P [ flags & 1 ] ;
s -> pixel_ptr += s -> line_inc ;
}
}
else {
flags = bytestream2_get_le16 ( & s -> stream_ptr ) ;
for ( y = 0 ;
y < 8 ;
y += 2 ) {
for ( x = 0 ;
x < 8 ;
x += 2 , flags >>= 1 ) {
s -> pixel_ptr [ x ] = s -> pixel_ptr [ x + 1 ] = s -> pixel_ptr [ x + s -> stride ] = s -> pixel_ptr [ x + 1 + s -> stride ] = P [ flags & 1 ] ;
}
s -> pixel_ptr += s -> stride * 2 ;
}
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
METHOD ( x509_t , get_constraint , u_int , private_x509_cert_t * this , x509_constraint_t type ) {
switch ( type ) {
case X509_PATH_LEN : return this -> pathLenConstraint ;
case X509_REQUIRE_EXPLICIT_POLICY : return this -> require_explicit ;
case X509_INHIBIT_POLICY_MAPPING : return this -> inhibit_mapping ;
case X509_INHIBIT_ANY_POLICY : return this -> inhibit_any ;
default : return X509_NO_CONSTRAINT ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorJSONCreateSnapshot ( qemuMonitorPtr mon , const char * name ) {
int ret ;
virJSONValuePtr cmd ;
virJSONValuePtr reply = NULL ;
cmd = qemuMonitorJSONMakeCommand ( "savevm" , "s:name" , name , NULL ) ;
if ( ! cmd ) return - 1 ;
if ( ( ret = qemuMonitorJSONCommand ( mon , cmd , & reply ) ) < 0 ) goto cleanup ;
if ( qemuMonitorJSONHasError ( reply , "CommandNotFound" ) && qemuMonitorCheckHMP ( mon , "savevm" ) ) {
VIR_DEBUG ( "savevm command not found, trying HMP" ) ;
ret = qemuMonitorTextCreateSnapshot ( mon , name ) ;
goto cleanup ;
}
ret = qemuMonitorJSONCheckError ( cmd , reply ) ;
cleanup : virJSONValueFree ( cmd ) ;
virJSONValueFree ( reply ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static timelib_ull timelib_get_unsigned_nr ( char * * ptr , int max_length ) {
timelib_ull dir = 1 ;
while ( ( ( * * ptr < '0' ) || ( * * ptr > '9' ) ) && ( * * ptr != '+' ) && ( * * ptr != '-' ) ) {
if ( * * ptr == '\0' ) {
return TIMELIB_UNSET ;
}
++ * ptr ;
}
while ( * * ptr == '+' || * * ptr == '-' ) {
if ( * * ptr == '-' ) {
dir *= - 1 ;
}
++ * ptr ;
}
return dir * timelib_get_nr ( ptr , max_length ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( FramebustBlockBrowserTest , AllowRadioButtonSelected ) {
const GURL url = embedded_test_server ( ) -> GetURL ( "/iframe.html" ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , url ) ;
auto * helper = GetFramebustTabHelper ( ) ;
helper -> AddBlockedUrl ( url , base : : BindOnce ( & FramebustBlockBrowserTest : : OnClick , base : : Unretained ( this ) ) ) ;
EXPECT_TRUE ( helper -> HasBlockedUrls ( ) ) ;
HostContentSettingsMap * settings_map = HostContentSettingsMapFactory : : GetForProfile ( browser ( ) -> profile ( ) ) ;
EXPECT_EQ ( CONTENT_SETTING_BLOCK , settings_map -> GetContentSetting ( url , GURL ( ) , CONTENT_SETTINGS_TYPE_POPUPS , std : : string ( ) ) ) ;
{
ContentSettingFramebustBlockBubbleModel framebust_block_bubble_model ( browser ( ) -> content_setting_bubble_model_delegate ( ) , GetWebContents ( ) , browser ( ) -> profile ( ) ) ;
framebust_block_bubble_model . OnRadioClicked ( kAllowRadioButtonIndex ) ;
}
EXPECT_EQ ( CONTENT_SETTING_ALLOW , settings_map -> GetContentSetting ( url , GURL ( ) , CONTENT_SETTINGS_TYPE_POPUPS , std : : string ( ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_T_h245Route ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence_of ( tvb , offset , actx , tree , hf_index , ett_h225_T_h245Route , T_h245Route_sequence_of ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorTextRemoveNetdev ( qemuMonitorPtr mon , const char * alias ) {
char * cmd ;
char * reply = NULL ;
int ret = - 1 ;
if ( virAsprintf ( & cmd , "netdev_del %s" , alias ) < 0 ) {
virReportOOMError ( ) ;
return - 1 ;
}
if ( qemuMonitorHMPCommand ( mon , cmd , & reply ) < 0 ) {
qemuReportError ( VIR_ERR_OPERATION_FAILED , _ ( "failed to remove netdev in qemu with '%s'" ) , cmd ) ;
goto cleanup ;
}
ret = 0 ;
cleanup : VIR_FREE ( cmd ) ;
VIR_FREE ( reply ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
struct archive_string * archive_string_ensure ( struct archive_string * as , size_t s ) {
char * p ;
size_t new_length ;
if ( as -> s && ( s <= as -> buffer_length ) ) return ( as ) ;
if ( as -> buffer_length < 32 ) new_length = 32 ;
else if ( as -> buffer_length < 8192 ) new_length = as -> buffer_length + as -> buffer_length ;
else {
new_length = as -> buffer_length + as -> buffer_length / 4 ;
if ( new_length < as -> buffer_length ) {
archive_string_free ( as ) ;
errno = ENOMEM ;
return ( NULL ) ;
}
}
if ( new_length < s ) new_length = s ;
p = ( char * ) realloc ( as -> s , new_length ) ;
if ( p == NULL ) {
archive_string_free ( as ) ;
errno = ENOMEM ;
return ( NULL ) ;
}
as -> s = p ;
as -> buffer_length = new_length ;
return ( as ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void typhoon_alarm_timer ( void * opaque ) {
TyphoonState * s = ( TyphoonState * ) ( ( uintptr_t ) opaque & ~ 3 ) ;
int cpu = ( uintptr_t ) opaque & 3 ;
s -> cchip . misc |= 1 << ( cpu + 4 ) ;
cpu_interrupt ( CPU ( s -> cchip . cpu [ cpu ] ) , CPU_INTERRUPT_TIMER ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
gboolean logcat_binary_dump_open ( wtap_dumper * wdh , int * err ) {
wdh -> subtype_write = logcat_binary_dump ;
wdh -> subtype_close = NULL ;
switch ( wdh -> encap ) {
case WTAP_ENCAP_LOGCAT : wdh -> tsprecision = WTAP_FILE_TSPREC_USEC ;
break ;
default : * err = WTAP_ERR_UNSUPPORTED_FILE_TYPE ;
return FALSE ;
}
return TRUE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void decode_exp_lsp ( WMACodecContext * s , int ch ) {
float lsp_coefs [ NB_LSP_COEFS ] ;
int val , i ;
for ( i = 0 ;
i < NB_LSP_COEFS ;
i ++ ) {
if ( i == 0 || i >= 8 ) val = get_bits ( & s -> gb , 3 ) ;
else val = get_bits ( & s -> gb , 4 ) ;
lsp_coefs [ i ] = ff_wma_lsp_codebook [ i ] [ val ] ;
}
wma_lsp_to_curve ( s , s -> exponents [ ch ] , & s -> max_exponent [ ch ] , s -> block_len , lsp_coefs ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int selinux_msg_queue_msgrcv ( struct msg_queue * msq , struct msg_msg * msg , struct task_struct * target , long type , int mode ) {
struct ipc_security_struct * isec ;
struct msg_security_struct * msec ;
struct common_audit_data ad ;
u32 sid = task_sid ( target ) ;
int rc ;
isec = msq -> q_perm . security ;
msec = msg -> security ;
ad . type = LSM_AUDIT_DATA_IPC ;
ad . u . ipc_id = msq -> q_perm . key ;
rc = avc_has_perm ( sid , isec -> sid , SECCLASS_MSGQ , MSGQ__READ , & ad ) ;
if ( ! rc ) rc = avc_has_perm ( sid , msec -> sid , SECCLASS_MSG , MSG__RECEIVE , & ad ) ;
return rc ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int ossl_x509name_cmp0 ( VALUE self , VALUE other ) {
X509_NAME * name1 , * name2 ;
GetX509Name ( self , name1 ) ;
SafeGetX509Name ( other , name2 ) ;
return X509_NAME_cmp ( name1 , name2 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int virLogFormatString ( char * * msg , int linenr , const char * funcname , virLogPriority priority , const char * str ) {
int ret ;
if ( ( funcname != NULL ) ) {
ret = virAsprintfQuiet ( msg , "%llu: %s : %s:%d : %s\n" , virThreadSelfID ( ) , virLogPriorityString ( priority ) , funcname , linenr , str ) ;
}
else {
ret = virAsprintfQuiet ( msg , "%llu: %s : %s\n" , virThreadSelfID ( ) , virLogPriorityString ( priority ) , str ) ;
}
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int qemuMonitorTextSavePhysicalMemory ( qemuMonitorPtr mon , unsigned long long offset , size_t length , const char * path ) {
return qemuMonitorTextSaveMemory ( mon , "pmemsave" , offset , length , path ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_s_validator_coordination_conn_inst ( packet_info * pinfo , proto_tree * tree , proto_item * item , tvbuff_t * tvb , int offset , int total_len ) {
int i , size ;
proto_tree_add_item ( tree , hf_cip_svalidator_coordination_conn_inst_size , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ;
size = tvb_get_guint8 ( tvb , offset ) * 2 ;
if ( total_len < size + 1 ) {
expert_add_info ( pinfo , item , & ei_mal_svalidator_coordination_conn_inst ) ;
return total_len ;
}
for ( i = 0 ;
i < size ;
i += 2 ) {
proto_tree_add_item ( tree , hf_cip_svalidator_coordination_conn_inst_item , tvb , offset + 1 + i , 2 , ENC_LITTLE_ENDIAN ) ;
}
return ( size + 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h225_EnumeratedParameter ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 830 "./asn1/h225/h225.cnf" gef_ctx_t * parent_gefx ;
parent_gefx = gef_ctx_get ( actx -> private_data ) ;
actx -> private_data = gef_ctx_alloc ( parent_gefx , NULL ) ;
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_EnumeratedParameter , EnumeratedParameter_sequence ) ;
# line 835 "./asn1/h225/h225.cnf" actx -> private_data = parent_gefx ;
return offset ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
int archive_mstring_copy_wcs_len ( struct archive_mstring * aes , const wchar_t * wcs , size_t len ) {
if ( wcs == NULL ) {
aes -> aes_set = 0 ;
}
aes -> aes_set = AES_SET_WCS ;
archive_string_empty ( & ( aes -> aes_mbs ) ) ;
archive_string_empty ( & ( aes -> aes_utf8 ) ) ;
archive_wstrncpy ( & ( aes -> aes_wcs ) , wcs , len ) ;
return ( 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_rc_update_framerate ( VP9_COMP * cpi ) {
const VP9_COMMON * const cm = & cpi -> common ;
const VP9EncoderConfig * const oxcf = & cpi -> oxcf ;
RATE_CONTROL * const rc = & cpi -> rc ;
int vbr_max_bits ;
rc -> avg_frame_bandwidth = ( int ) ( oxcf -> target_bandwidth / cpi -> framerate ) ;
rc -> min_frame_bandwidth = ( int ) ( rc -> avg_frame_bandwidth * oxcf -> two_pass_vbrmin_section / 100 ) ;
rc -> min_frame_bandwidth = MAX ( rc -> min_frame_bandwidth , FRAME_OVERHEAD_BITS ) ;
vbr_max_bits = ( int ) ( ( ( int64_t ) rc -> avg_frame_bandwidth * oxcf -> two_pass_vbrmax_section ) / 100 ) ;
rc -> max_frame_bandwidth = MAX ( MAX ( ( cm -> MBs * MAX_MB_RATE ) , MAXRATE_1080P ) , vbr_max_bits ) ;
vp9_rc_set_gf_max_interval ( cpi , rc ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( ExternalProtocolHandlerTest , TestGetBlockStateLocalDontBlockCopiedAsIsToProfilePref ) {
base : : DictionaryValue prefs_local ;
prefs_local . SetBoolean ( "tel" , false ) ;
local_state_ -> Set ( prefs : : kExcludedSchemes , prefs_local ) ;
ExternalProtocolHandler : : BlockState block_state = ExternalProtocolHandler : : GetBlockState ( "tel" , profile_ . get ( ) ) ;
EXPECT_EQ ( ExternalProtocolHandler : : DONT_BLOCK , block_state ) ;
EXPECT_TRUE ( local_state_ -> GetDictionary ( prefs : : kExcludedSchemes ) -> empty ( ) ) ;
EXPECT_FALSE ( profile_ -> GetPrefs ( ) -> GetDictionary ( prefs : : kExcludedSchemes ) -> empty ( ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( MimeHandlerViewTest , DataUrl ) {
const char * kDataUrlCsv = "data:text/csv;
base64,Y29udGVudCB0byByZWFkCg==" ;
RunTestWithUrl ( GURL ( kDataUrlCsv ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_Password ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_octet_string ( tvb , offset , actx , tree , hf_index , 1 , 32 , FALSE , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const guint8 * composite_get_ptr ( tvbuff_t * tvb , guint abs_offset , guint abs_length ) {
struct tvb_composite * composite_tvb = ( struct tvb_composite * ) tvb ;
guint i , num_members ;
tvb_comp_t * composite ;
tvbuff_t * member_tvb = NULL ;
guint member_offset ;
GSList * slist ;
composite = & composite_tvb -> composite ;
num_members = g_slist_length ( composite -> tvbs ) ;
for ( i = 0 ;
i < num_members ;
i ++ ) {
if ( abs_offset <= composite -> end_offsets [ i ] ) {
slist = g_slist_nth ( composite -> tvbs , i ) ;
member_tvb = ( tvbuff_t * ) slist -> data ;
break ;
}
}
if ( ! member_tvb ) {
DISSECTOR_ASSERT ( abs_offset == tvb -> length && abs_length == 0 ) ;
return "" ;
}
member_offset = abs_offset - composite -> start_offsets [ i ] ;
if ( tvb_bytes_exist ( member_tvb , member_offset , abs_length ) ) {
DISSECTOR_ASSERT ( ! tvb -> real_data ) ;
return tvb_get_ptr ( member_tvb , member_offset , abs_length ) ;
}
else {
void * real_data = g_malloc ( tvb -> length ) ;
tvb_memcpy ( tvb , real_data , 0 , tvb -> length ) ;
tvb -> real_data = ( const guint8 * ) real_data ;
return tvb -> real_data + abs_offset ;
}
DISSECTOR_ASSERT_NOT_REACHED ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void or_bits ( REP_SET * to , REP_SET * from ) {
reg1 uint i ;
for ( i = 0 ;
i < to -> size_of_bits ;
i ++ ) to -> bits [ i ] |= from -> bits [ i ] ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void spl_dllist_it_helper_move_forward ( spl_ptr_llist_element * * traverse_pointer_ptr , int * traverse_position_ptr , spl_ptr_llist * llist , int flags TSRMLS_DC ) {
if ( * traverse_pointer_ptr ) {
spl_ptr_llist_element * old = * traverse_pointer_ptr ;
if ( flags & SPL_DLLIST_IT_LIFO ) {
* traverse_pointer_ptr = old -> prev ;
( * traverse_position_ptr ) -- ;
if ( flags & SPL_DLLIST_IT_DELETE ) {
zval * prev = ( zval * ) spl_ptr_llist_pop ( llist TSRMLS_CC ) ;
if ( prev ) {
zval_ptr_dtor ( ( zval * * ) & prev ) ;
}
}
}
else {
* traverse_pointer_ptr = old -> next ;
if ( flags & SPL_DLLIST_IT_DELETE ) {
zval * prev = ( zval * ) spl_ptr_llist_shift ( llist TSRMLS_CC ) ;
if ( prev ) {
zval_ptr_dtor ( ( zval * * ) & prev ) ;
}
}
else {
( * traverse_position_ptr ) ++ ;
}
}
SPL_LLIST_DELREF ( old ) ;
SPL_LLIST_CHECK_ADDREF ( * traverse_pointer_ptr ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
uint get_errcode_from_name ( const char * error_name , const char * error_end ) {
uint tmp ;
if ( ( tmp = get_errcode_from_name ( error_name , error_end , global_error_names ) ) ) return tmp ;
if ( ( tmp = get_errcode_from_name ( error_name , error_end , handler_error_names ) ) ) return tmp ;
die ( "Unknown SQL error name '%s'" , error_name ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline size_t size_code_gen_buffer ( size_t tb_size ) {
if ( tb_size == 0 ) {
# ifdef USE_STATIC_CODE_GEN_BUFFER tb_size = DEFAULT_CODE_GEN_BUFFER_SIZE ;
# else tb_size = ( unsigned long ) ( ram_size / 4 ) ;
# endif }
if ( tb_size < MIN_CODE_GEN_BUFFER_SIZE ) {
tb_size = MIN_CODE_GEN_BUFFER_SIZE ;
}
if ( tb_size > MAX_CODE_GEN_BUFFER_SIZE ) {
tb_size = MAX_CODE_GEN_BUFFER_SIZE ;
}
tcg_ctx . code_gen_buffer_size = tb_size ;
return tb_size ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static FileConflictResponse * handle_copy_move_conflict ( CommonJob * job , GFile * src , GFile * dest , GFile * dest_dir ) {
FileConflictResponse * response ;
g_timer_stop ( job -> time ) ;
nautilus_progress_info_pause ( job -> progress ) ;
response = copy_move_conflict_ask_user_action ( job -> parent_window , src , dest , dest_dir ) ;
nautilus_progress_info_resume ( job -> progress ) ;
g_timer_continue ( job -> time ) ;
return response ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void ff_h263_update_motion_val ( MpegEncContext * s ) {
const int mb_xy = s -> mb_y * s -> mb_stride + s -> mb_x ;
const int wrap = s -> b8_stride ;
const int xy = s -> block_index [ 0 ] ;
s -> current_picture . f . mbskip_table [ mb_xy ] = s -> mb_skipped ;
if ( s -> mv_type != MV_TYPE_8X8 ) {
int motion_x , motion_y ;
if ( s -> mb_intra ) {
motion_x = 0 ;
motion_y = 0 ;
}
else if ( s -> mv_type == MV_TYPE_16X16 ) {
motion_x = s -> mv [ 0 ] [ 0 ] [ 0 ] ;
motion_y = s -> mv [ 0 ] [ 0 ] [ 1 ] ;
}
else {
int i ;
motion_x = s -> mv [ 0 ] [ 0 ] [ 0 ] + s -> mv [ 0 ] [ 1 ] [ 0 ] ;
motion_y = s -> mv [ 0 ] [ 0 ] [ 1 ] + s -> mv [ 0 ] [ 1 ] [ 1 ] ;
motion_x = ( motion_x >> 1 ) | ( motion_x & 1 ) ;
for ( i = 0 ;
i < 2 ;
i ++ ) {
s -> p_field_mv_table [ i ] [ 0 ] [ mb_xy ] [ 0 ] = s -> mv [ 0 ] [ i ] [ 0 ] ;
s -> p_field_mv_table [ i ] [ 0 ] [ mb_xy ] [ 1 ] = s -> mv [ 0 ] [ i ] [ 1 ] ;
}
s -> current_picture . f . ref_index [ 0 ] [ 4 * mb_xy ] = s -> current_picture . f . ref_index [ 0 ] [ 4 * mb_xy + 1 ] = s -> field_select [ 0 ] [ 0 ] ;
s -> current_picture . f . ref_index [ 0 ] [ 4 * mb_xy + 2 ] = s -> current_picture . f . ref_index [ 0 ] [ 4 * mb_xy + 3 ] = s -> field_select [ 0 ] [ 1 ] ;
}
s -> current_picture . f . motion_val [ 0 ] [ xy ] [ 0 ] = motion_x ;
s -> current_picture . f . motion_val [ 0 ] [ xy ] [ 1 ] = motion_y ;
s -> current_picture . f . motion_val [ 0 ] [ xy + 1 ] [ 0 ] = motion_x ;
s -> current_picture . f . motion_val [ 0 ] [ xy + 1 ] [ 1 ] = motion_y ;
s -> current_picture . f . motion_val [ 0 ] [ xy + wrap ] [ 0 ] = motion_x ;
s -> current_picture . f . motion_val [ 0 ] [ xy + wrap ] [ 1 ] = motion_y ;
s -> current_picture . f . motion_val [ 0 ] [ xy + 1 + wrap ] [ 0 ] = motion_x ;
s -> current_picture . f . motion_val [ 0 ] [ xy + 1 + wrap ] [ 1 ] = motion_y ;
}
if ( s -> encoding ) {
if ( s -> mv_type == MV_TYPE_8X8 ) s -> current_picture . f . mb_type [ mb_xy ] = MB_TYPE_L0 | MB_TYPE_8x8 ;
else if ( s -> mb_intra ) s -> current_picture . f . mb_type [ mb_xy ] = MB_TYPE_INTRA ;
else s -> current_picture . f . mb_type [ mb_xy ] = MB_TYPE_L0 | MB_TYPE_16x16 ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void full_to_model_counts ( vp9_coeff_count_model * model_count , vp9_coeff_count * full_count ) {
int i , j , k , l ;
for ( i = 0 ;
i < PLANE_TYPES ;
++ i ) for ( j = 0 ;
j < REF_TYPES ;
++ j ) for ( k = 0 ;
k < COEF_BANDS ;
++ k ) for ( l = 0 ;
l < BAND_COEFF_CONTEXTS ( k ) ;
++ l ) full_to_model_count ( model_count [ i ] [ j ] [ k ] [ l ] , full_count [ i ] [ j ] [ k ] [ l ] ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VALUE cState_space_set ( VALUE self , VALUE space ) {
unsigned long len ;
GET_STATE ( self ) ;
Check_Type ( space , T_STRING ) ;
len = RSTRING_LEN ( space ) ;
if ( len == 0 ) {
if ( state -> space ) {
ruby_xfree ( state -> space ) ;
state -> space = NULL ;
state -> space_len = 0 ;
}
}
else {
if ( state -> space ) ruby_xfree ( state -> space ) ;
state -> space = fstrndup ( RSTRING_PTR ( space ) , len ) ;
state -> space_len = len ;
}
return Qnil ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static bool find_cgroup_subsystems ( char * * * kernel_subsystems ) {
FILE * proc_cgroups ;
bool bret = false ;
char * line = NULL ;
size_t sz = 0 ;
size_t kernel_subsystems_count = 0 ;
size_t kernel_subsystems_capacity = 0 ;
int r ;
proc_cgroups = fopen_cloexec ( "/proc/cgroups" , "r" ) ;
if ( ! proc_cgroups ) return false ;
while ( getline ( & line , & sz , proc_cgroups ) != - 1 ) {
char * tab1 ;
char * tab2 ;
int hierarchy_number ;
if ( line [ 0 ] == '#' ) continue ;
if ( ! line [ 0 ] ) continue ;
tab1 = strchr ( line , '\t' ) ;
if ( ! tab1 ) continue ;
* tab1 ++ = '\0' ;
tab2 = strchr ( tab1 , '\t' ) ;
if ( ! tab2 ) continue ;
* tab2 = '\0' ;
tab2 = NULL ;
hierarchy_number = strtoul ( tab1 , & tab2 , 10 ) ;
if ( ! tab2 || * tab2 ) continue ;
( void ) hierarchy_number ;
r = lxc_grow_array ( ( void * * * ) kernel_subsystems , & kernel_subsystems_capacity , kernel_subsystems_count + 1 , 12 ) ;
if ( r < 0 ) goto out ;
( * kernel_subsystems ) [ kernel_subsystems_count ] = strdup ( line ) ;
if ( ! ( * kernel_subsystems ) [ kernel_subsystems_count ] ) goto out ;
kernel_subsystems_count ++ ;
}
bret = true ;
out : fclose ( proc_cgroups ) ;
free ( line ) ;
return bret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void examine_variable ( PlannerInfo * root , Node * node , int varRelid , VariableStatData * vardata ) {
Node * basenode ;
Relids varnos ;
RelOptInfo * onerel ;
MemSet ( vardata , 0 , sizeof ( VariableStatData ) ) ;
vardata -> vartype = exprType ( node ) ;
if ( IsA ( node , RelabelType ) ) basenode = ( Node * ) ( ( RelabelType * ) node ) -> arg ;
else basenode = node ;
if ( IsA ( basenode , Var ) && ( varRelid == 0 || varRelid == ( ( Var * ) basenode ) -> varno ) ) {
Var * var = ( Var * ) basenode ;
vardata -> var = basenode ;
vardata -> rel = find_base_rel ( root , var -> varno ) ;
vardata -> atttype = var -> vartype ;
vardata -> atttypmod = var -> vartypmod ;
vardata -> isunique = has_unique_index ( vardata -> rel , var -> varattno ) ;
examine_simple_variable ( root , var , vardata ) ;
return ;
}
varnos = pull_varnos ( basenode ) ;
onerel = NULL ;
switch ( bms_membership ( varnos ) ) {
case BMS_EMPTY_SET : break ;
case BMS_SINGLETON : if ( varRelid == 0 || bms_is_member ( varRelid , varnos ) ) {
onerel = find_base_rel ( root , ( varRelid ? varRelid : bms_singleton_member ( varnos ) ) ) ;
vardata -> rel = onerel ;
node = basenode ;
}
break ;
case BMS_MULTIPLE : if ( varRelid == 0 ) {
vardata -> rel = find_join_rel ( root , varnos ) ;
node = basenode ;
}
else if ( bms_is_member ( varRelid , varnos ) ) {
vardata -> rel = find_base_rel ( root , varRelid ) ;
node = basenode ;
}
break ;
}
bms_free ( varnos ) ;
vardata -> var = node ;
vardata -> atttype = exprType ( node ) ;
vardata -> atttypmod = exprTypmod ( node ) ;
if ( onerel ) {
ListCell * ilist ;
foreach ( ilist , onerel -> indexlist ) {
IndexOptInfo * index = ( IndexOptInfo * ) lfirst ( ilist ) ;
ListCell * indexpr_item ;
int pos ;
indexpr_item = list_head ( index -> indexprs ) ;
if ( indexpr_item == NULL ) continue ;
for ( pos = 0 ;
pos < index -> ncolumns ;
pos ++ ) {
if ( index -> indexkeys [ pos ] == 0 ) {
Node * indexkey ;
if ( indexpr_item == NULL ) elog ( ERROR , "too few entries in indexprs list" ) ;
indexkey = ( Node * ) lfirst ( indexpr_item ) ;
if ( indexkey && IsA ( indexkey , RelabelType ) ) indexkey = ( Node * ) ( ( RelabelType * ) indexkey ) -> arg ;
if ( equal ( node , indexkey ) ) {
if ( index -> unique && index -> ncolumns == 1 && ( index -> indpred == NIL || index -> predOK ) ) vardata -> isunique = true ;
if ( get_index_stats_hook && ( * get_index_stats_hook ) ( root , index -> indexoid , pos + 1 , vardata ) ) {
if ( HeapTupleIsValid ( vardata -> statsTuple ) && ! vardata -> freefunc ) elog ( ERROR , "no function provided to release variable stats with" ) ;
}
else if ( index -> indpred == NIL ) {
vardata -> statsTuple = SearchSysCache3 ( STATRELATTINH , ObjectIdGetDatum ( index -> indexoid ) , Int16GetDatum ( pos + 1 ) , BoolGetDatum ( false ) ) ;
vardata -> freefunc = ReleaseSysCache ;
if ( HeapTupleIsValid ( vardata -> statsTuple ) ) {
RangeTblEntry * rte ;
rte = planner_rt_fetch ( index -> rel -> relid , root ) ;
Assert ( rte -> rtekind == RTE_RELATION ) ;
vardata -> acl_ok = ( pg_class_aclcheck ( rte -> relid , GetUserId ( ) , ACL_SELECT ) == ACLCHECK_OK ) ;
}
else {
vardata -> acl_ok = true ;
}
}
if ( vardata -> statsTuple ) break ;
}
indexpr_item = lnext ( indexpr_item ) ;
}
}
if ( vardata -> statsTuple ) break ;
}
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int parse_usbdevfs_streams ( struct usb_dev_state * ps , struct usbdevfs_streams __user * streams , unsigned int * num_streams_ret , unsigned int * num_eps_ret , struct usb_host_endpoint * * * eps_ret , struct usb_interface * * intf_ret ) {
unsigned int i , num_streams , num_eps ;
struct usb_host_endpoint * * eps ;
struct usb_interface * intf = NULL ;
unsigned char ep ;
int ifnum , ret ;
if ( get_user ( num_streams , & streams -> num_streams ) || get_user ( num_eps , & streams -> num_eps ) ) return - EFAULT ;
if ( num_eps < 1 || num_eps > USB_MAXENDPOINTS ) return - EINVAL ;
if ( num_streams_ret && ( num_streams < 2 || num_streams > 65536 ) ) return - EINVAL ;
eps = kmalloc ( num_eps * sizeof ( * eps ) , GFP_KERNEL ) ;
if ( ! eps ) return - ENOMEM ;
for ( i = 0 ;
i < num_eps ;
i ++ ) {
if ( get_user ( ep , & streams -> eps [ i ] ) ) {
ret = - EFAULT ;
goto error ;
}
eps [ i ] = ep_to_host_endpoint ( ps -> dev , ep ) ;
if ( ! eps [ i ] ) {
ret = - EINVAL ;
goto error ;
}
ifnum = findintfep ( ps -> dev , ep ) ;
if ( ifnum < 0 ) {
ret = ifnum ;
goto error ;
}
if ( i == 0 ) {
ret = checkintf ( ps , ifnum ) ;
if ( ret < 0 ) goto error ;
intf = usb_ifnum_to_if ( ps -> dev , ifnum ) ;
}
else {
if ( ifnum != intf -> altsetting -> desc . bInterfaceNumber ) {
ret = - EINVAL ;
goto error ;
}
}
}
if ( num_streams_ret ) * num_streams_ret = num_streams ;
* num_eps_ret = num_eps ;
* eps_ret = eps ;
* intf_ret = intf ;
return 0 ;
error : kfree ( eps ) ;
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void request_submit ( struct request * const req ) {
if ( req -> ns ) {
evdns_request_insert ( req , & req_head ) ;
global_requests_inflight ++ ;
evdns_request_transmit ( req ) ;
}
else {
evdns_request_insert ( req , & req_waiting_head ) ;
global_requests_waiting ++ ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int xhci_fire_transfer ( XHCIState * xhci , XHCITransfer * xfer , XHCIEPContext * epctx ) {
trace_usb_xhci_xfer_start ( xfer , xfer -> epctx -> slotid , xfer -> epctx -> epid , xfer -> streamid ) ;
return xhci_submit ( xhci , xfer , epctx ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static USBEndpoint * xhci_epid_to_usbep ( XHCIEPContext * epctx ) {
USBPort * uport ;
uint32_t token ;
if ( ! epctx ) {
return NULL ;
}
uport = epctx -> xhci -> slots [ epctx -> slotid - 1 ] . uport ;
token = ( epctx -> epid & 1 ) ? USB_TOKEN_IN : USB_TOKEN_OUT ;
if ( ! uport ) {
return NULL ;
}
return usb_ep_get ( uport -> dev , token , epctx -> epid >> 1 ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.