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 __inline__ int TLV_LIST_CHECK ( struct tlv_list_desc * list , __u16 exp_type ) {
return TLV_CHECK ( list -> tlv_ptr , list -> tlv_space , exp_type ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void docmd ( const char * cmdline ) {
char * tokens [ 1 + MAXARGS + 2 ] ;
struct parse pcmd ;
int ntok ;
static int i ;
struct xcmd * xcmd ;
tokenize ( cmdline , tokens , & ntok ) ;
if ( ntok == 0 ) return ;
i = findcmd ( tokens [ 0 ] , builtins , opcmds , & xcmd ) ;
if ( i == 0 ) {
( void ) fprintf ( stderr , "***Command `%s' unknown\n" , tokens [ 0 ] ) ;
return ;
}
else if ( i >= 2 ) {
( void ) fprintf ( stderr , "***Command `%s' ambiguous\n" , tokens [ 0 ] ) ;
return ;
}
for ( i = MAXARGS + 1 ;
i < ntok ;
++ i ) {
fprintf ( stderr , "***Extra arg `%s' ignored\n" , tokens [ i ] ) ;
}
pcmd . keyword = tokens [ 0 ] ;
pcmd . nargs = 0 ;
for ( i = 0 ;
i < MAXARGS && xcmd -> arg [ i ] != NO ;
i ++ ) {
if ( ( i + 1 ) >= ntok ) {
if ( ! ( xcmd -> arg [ i ] & OPT ) ) {
printusage ( xcmd , stderr ) ;
return ;
}
break ;
}
if ( ( xcmd -> arg [ i ] & OPT ) && ( * tokens [ i + 1 ] == '>' ) ) break ;
if ( ! getarg ( tokens [ i + 1 ] , ( int ) xcmd -> arg [ i ] , & pcmd . argval [ i ] ) ) return ;
pcmd . nargs ++ ;
}
i ++ ;
if ( i < ntok && * tokens [ i ] == '>' ) {
char * fname ;
if ( * ( tokens [ i ] + 1 ) != '\0' ) fname = tokens [ i ] + 1 ;
else if ( ( i + 1 ) < ntok ) fname = tokens [ i + 1 ] ;
else {
( void ) fprintf ( stderr , "***No file for redirect\n" ) ;
return ;
}
current_output = fopen ( fname , "w" ) ;
if ( current_output == NULL ) {
( void ) fprintf ( stderr , "***Error opening %s: " , fname ) ;
perror ( "" ) ;
return ;
}
i = 1 ;
}
else {
current_output = stdout ;
i = 0 ;
}
if ( interactive && setjmp ( interrupt_buf ) ) {
jump = 0 ;
return ;
}
else {
jump ++ ;
( xcmd -> handler ) ( & pcmd , current_output ) ;
jump = 0 ;
if ( i ) ( void ) fclose ( current_output ) ;
}
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int x8_get_orient_vlc ( IntraX8Context * w ) {
MpegEncContext * const s = w -> s ;
int table_index ;
if ( ! w -> j_orient_vlc ) {
table_index = get_bits ( & s -> gb , 1 + ( w -> quant < 13 ) ) ;
w -> j_orient_vlc = & j_orient_vlc [ w -> quant < 13 ] [ table_index ] ;
}
assert ( w -> j_orient_vlc ) ;
assert ( w -> j_orient_vlc -> table ) ;
return get_vlc2 ( & s -> gb , w -> j_orient_vlc -> table , OR_VLC_BITS , OR_VLC_MTD ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static enum fetch_step vbf_stp_fetchbody ( struct worker * wrk , struct busyobj * bo ) {
ssize_t l ;
uint8_t * ptr ;
enum vfp_status vfps = VFP_ERROR ;
ssize_t est ;
struct vfp_ctx * vfc ;
CHECK_OBJ_NOTNULL ( bo , BUSYOBJ_MAGIC ) ;
vfc = bo -> vfc ;
CHECK_OBJ_NOTNULL ( vfc , VFP_CTX_MAGIC ) ;
AN ( vfc -> vfp_nxt ) ;
est = bo -> htc -> content_length ;
if ( est < 0 ) est = 0 ;
do {
if ( vfc -> oc -> flags & OC_F_ABANDON ) {
AN ( vfc -> oc -> flags & OC_F_PASS ) ;
VSLb ( wrk -> vsl , SLT_FetchError , "Pass delivery abandoned" ) ;
bo -> htc -> doclose = SC_RX_BODY ;
break ;
}
AZ ( vfc -> failed ) ;
l = est ;
assert ( l >= 0 ) ;
if ( VFP_GetStorage ( vfc , & l , & ptr ) != VFP_OK ) {
bo -> htc -> doclose = SC_RX_BODY ;
break ;
}
AZ ( vfc -> failed ) ;
vfps = VFP_Suck ( vfc , ptr , & l ) ;
if ( l > 0 && vfps != VFP_ERROR ) {
bo -> acct . beresp_bodybytes += l ;
VFP_Extend ( vfc , l ) ;
if ( est >= l ) est -= l ;
else est = 0 ;
}
}
while ( vfps == VFP_OK ) ;
if ( vfc -> failed ) {
( void ) VFP_Error ( vfc , "Fetch pipeline failed to process" ) ;
bo -> htc -> doclose = SC_RX_BODY ;
VFP_Close ( vfc ) ;
VDI_Finish ( wrk , bo ) ;
if ( ! bo -> do_stream ) {
assert ( bo -> fetch_objcore -> boc -> state < BOS_STREAM ) ;
return ( F_STP_ERROR ) ;
}
else {
wrk -> stats -> fetch_failed ++ ;
return ( F_STP_FAIL ) ;
}
}
ObjTrimStore ( wrk , vfc -> oc ) ;
return ( F_STP_FETCHEND ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int x ( struct vcache * avc , int afun , struct vrequest * areq , \ struct afs_pdata * ain , struct afs_pdata * aout , \ afs_ucred_t * * acred ) DECL_PIOCTL ( PGetFID ) ;
DECL_PIOCTL ( PSetAcl ) ;
DECL_PIOCTL ( PStoreBehind ) ;
DECL_PIOCTL ( PGCPAGs ) ;
DECL_PIOCTL ( PGetAcl ) ;
DECL_PIOCTL ( PNoop ) ;
DECL_PIOCTL ( PBogus ) ;
DECL_PIOCTL ( PGetFileCell ) ;
DECL_PIOCTL ( PGetWSCell ) ;
DECL_PIOCTL ( PGetUserCell ) ;
DECL_PIOCTL ( PSetTokens ) ;
DECL_PIOCTL ( PGetVolumeStatus ) ;
DECL_PIOCTL ( PSetVolumeStatus ) ;
DECL_PIOCTL ( PFlush ) ;
DECL_PIOCTL ( PNewStatMount )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( SSLErrorAssistantTest , DynamicInterstitialListCertErrorMismatch ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
EXPECT_EQ ( 1u , ssl_info ( ) . public_key_hashes . size ( ) ) ;
auto config_proto = std : : make_unique < chrome_browser_ssl : : SSLErrorAssistantConfig > ( ) ;
config_proto -> set_version_id ( kLargeVersionId ) ;
chrome_browser_ssl : : DynamicInterstitial * filter = config_proto -> add_dynamic_interstitial ( ) ;
filter -> set_interstitial_type ( chrome_browser_ssl : : DynamicInterstitial : : INTERSTITIAL_PAGE_SSL ) ;
filter -> set_cert_error ( chrome_browser_ssl : : DynamicInterstitial : : ERR_CERT_DATE_INVALID ) ;
filter -> add_sha256_hash ( "sha256uthatch" ) ;
filter -> add_sha256_hash ( ssl_info ( ) . public_key_hashes [ 0 ] . ToString ( ) ) ;
filter -> add_sha256_hash ( "sha256/treecreeper" ) ;
filter -> set_issuer_common_name_regex ( issuer_common_name ( ) ) ;
filter -> set_issuer_organization_regex ( issuer_organization_name ( ) ) ;
filter -> set_mitm_software_name ( "UwS" ) ;
error_assistant ( ) -> SetErrorAssistantProto ( std : : move ( config_proto ) ) ;
EXPECT_FALSE ( error_assistant ( ) -> MatchDynamicInterstitial ( ssl_info ( ) ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void de_emphasis ( float * out , float * in , float m , float mem [ 1 ] ) {
int i ;
out [ 0 ] = in [ 0 ] + m * mem [ 0 ] ;
for ( i = 1 ;
i < AMRWB_SFR_SIZE ;
i ++ ) out [ i ] = in [ i ] + out [ i - 1 ] * m ;
mem [ 0 ] = out [ AMRWB_SFR_SIZE - 1 ] ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
jpc_pchglist_t * jpc_pchglist_copy ( jpc_pchglist_t * pchglist ) {
jpc_pchglist_t * newpchglist ;
jpc_pchg_t * newpchg ;
int pchgno ;
if ( ! ( newpchglist = jpc_pchglist_create ( ) ) ) {
return 0 ;
}
for ( pchgno = 0 ;
pchgno < pchglist -> numpchgs ;
++ pchgno ) {
if ( ! ( newpchg = jpc_pchg_copy ( pchglist -> pchgs [ pchgno ] ) ) || jpc_pchglist_insert ( newpchglist , - 1 , newpchg ) ) {
jpc_pchglist_destroy ( newpchglist ) ;
return 0 ;
}
}
return newpchglist ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dtap_mm_id_req ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) {
guint32 curr_offset ;
guint curr_len ;
proto_tree * subtree ;
curr_offset = offset ;
curr_len = len ;
is_uplink = IS_UPLINK_FALSE ;
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , curr_offset << 3 , 4 , ENC_BIG_ENDIAN ) ;
subtree = proto_tree_add_subtree ( tree , tvb , curr_offset , 1 , ett_gsm_dtap_elem [ DE_ID_TYPE ] , NULL , val_to_str_ext_const ( DE_ID_TYPE , & gsm_dtap_elem_strings_ext , "" ) ) ;
proto_tree_add_bits_item ( subtree , hf_gsm_a_spare_bits , tvb , ( curr_offset << 3 ) + 4 , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( subtree , hf_gsm_a_dtap_type_of_identity , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
curr_len -- ;
EXTRANEOUS_DATA_CHECK ( curr_len , 0 , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char ) typedef void * OPENSSL_BLOCK ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_BLOCK , void )
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( WebUsbDetectorTest , UsbDeviceAddedAndRemoved ) {
base : : string16 product_name = base : : UTF8ToUTF16 ( kProductName_1 ) ;
GURL landing_page ( kLandingPage_1 ) ;
scoped_refptr < device : : MockUsbDevice > device ( new device : : MockUsbDevice ( 0 , 1 , "Google" , kProductName_1 , "002" , landing_page ) ) ;
std : : string guid = device -> guid ( ) ;
Initialize ( ) ;
device_client_ . usb_service ( ) -> AddDevice ( device ) ;
message_center : : Notification * notification = message_center_ -> FindVisibleNotificationById ( guid ) ;
ASSERT_TRUE ( notification != nullptr ) ;
base : : string16 expected_title = base : : ASCIIToUTF16 ( "Google Product A detected" ) ;
EXPECT_EQ ( expected_title , notification -> title ( ) ) ;
base : : string16 expected_message = base : : ASCIIToUTF16 ( "Go to www.google.com to connect." ) ;
EXPECT_EQ ( expected_message , notification -> message ( ) ) ;
EXPECT_TRUE ( notification -> delegate ( ) != nullptr ) ;
device_client_ . usb_service ( ) -> RemoveDevice ( device ) ;
EXPECT_TRUE ( message_center_ -> FindVisibleNotificationById ( guid ) == nullptr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( SessionRestorePageLoadMetricsBrowserTest , MultipleSessionRestores ) {
ui_test_utils : : NavigateToURL ( browser ( ) , GetTestURL ( ) ) ;
Browser * current_browser = browser ( ) ;
const int num_session_restores = 3 ;
for ( int i = 1 ;
i <= num_session_restores ;
++ i ) {
SessionRestorePaintWaiter session_restore_paint_waiter ;
current_browser = QuitBrowserAndRestore ( current_browser ) ;
session_restore_paint_waiter . WaitForForegroundTabs ( 1 ) ;
ExpectFirstPaintMetricsTotalCount ( i ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void add_dct ( MpegEncContext * s , int16_t * block , int i , uint8_t * dest , int line_size ) {
if ( s -> block_last_index [ i ] >= 0 ) {
s -> dsp . idct_add ( dest , line_size , block ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static guint32 dissect_netb_terminate_trace ( tvbuff_t * tvb _U_ , packet_info * pinfo _U_ , int offset _U_ , proto_tree * tree _U_ ) {
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void wma_lsp_to_curve ( WMACodecContext * s , float * out , float * val_max_ptr , int n , float * lsp ) {
int i , j ;
float p , q , w , v , val_max ;
val_max = 0 ;
for ( i = 0 ;
i < n ;
i ++ ) {
p = 0.5f ;
q = 0.5f ;
w = s -> lsp_cos_table [ i ] ;
for ( j = 1 ;
j < NB_LSP_COEFS ;
j += 2 ) {
q *= w - lsp [ j - 1 ] ;
p *= w - lsp [ j ] ;
}
p *= p * ( 2.0f - w ) ;
q *= q * ( 2.0f + w ) ;
v = p + q ;
v = pow_m1_4 ( s , v ) ;
if ( v > val_max ) val_max = v ;
out [ i ] = v ;
}
* val_max_ptr = val_max ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
proto_item * proto_tree_add_ipv6_format ( proto_tree * tree , int hfindex , tvbuff_t * tvb , gint start , gint length , const struct e_in6_addr * value_ptr , const char * format , ... ) {
proto_item * pi ;
va_list ap ;
pi = proto_tree_add_ipv6 ( tree , hfindex , tvb , start , length , value_ptr ) ;
if ( pi != tree ) {
TRY_TO_FAKE_THIS_REPR ( pi ) ;
va_start ( ap , format ) ;
proto_tree_set_representation ( pi , format , ap ) ;
va_end ( ap ) ;
}
return pi ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dtls1_fix_message_header ( SSL * s , unsigned long frag_off , unsigned long frag_len ) {
struct hm_header_st * msg_hdr = & s -> d1 -> w_msg_hdr ;
msg_hdr -> frag_off = frag_off ;
msg_hdr -> frag_len = frag_len ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
guint16 elem_lv_e ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo , gint pdu_type , int idx , guint32 offset , guint len _U_ , const gchar * name_add ) {
guint16 parm_len ;
guint16 consumed ;
guint32 curr_offset ;
proto_tree * subtree ;
proto_item * item ;
value_string_ext elem_names_ext ;
gint * elem_ett ;
const gchar * elem_name ;
guint16 ( * * elem_funcs ) ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo , guint32 offset , guint len , gchar * add_string , int string_len ) ;
curr_offset = offset ;
consumed = 0 ;
SET_ELEM_VARS ( pdu_type , elem_names_ext , elem_ett , elem_funcs , & ei_gsm_a_unknown_pdu_type ) ;
parm_len = tvb_get_ntohs ( tvb , curr_offset ) ;
elem_name = try_val_to_str_ext ( idx , & elem_names_ext ) ;
if ( elem_name == NULL ) {
proto_tree_add_expert_format ( tree , pinfo , & ei_gsm_a_unknown_element , tvb , curr_offset , parm_len + 2 , "Unknown - aborting dissection%s" , ( name_add == NULL ) || ( name_add [ 0 ] == '\0' ) ? "" : name_add ) ;
return consumed ;
}
subtree = proto_tree_add_subtree_format ( tree , tvb , curr_offset , parm_len + 2 , elem_ett [ idx ] , & item , "%s%s" , elem_name , ( name_add == NULL ) || ( name_add [ 0 ] == '\0' ) ? "" : name_add ) ;
proto_tree_add_uint ( subtree , hf_gsm_a_length , tvb , curr_offset , 2 , parm_len ) ;
if ( parm_len > 0 ) {
if ( elem_funcs [ idx ] == NULL ) {
proto_tree_add_item ( subtree , hf_gsm_a_element_value , tvb , curr_offset + 2 , parm_len , ENC_NA ) ;
consumed = parm_len ;
}
else {
gchar * a_add_string ;
a_add_string = ( gchar * ) wmem_alloc ( wmem_packet_scope ( ) , 1024 ) ;
a_add_string [ 0 ] = '\0' ;
consumed = ( * elem_funcs [ idx ] ) ( tvb , subtree , pinfo , curr_offset + 2 , parm_len , a_add_string , 1024 ) ;
if ( a_add_string [ 0 ] != '\0' ) {
proto_item_append_text ( item , "%s" , a_add_string ) ;
}
}
}
return ( consumed + 2 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int get_len ( LZOContext * c , int x , int mask ) {
int cnt = x & mask ;
if ( ! cnt ) {
while ( ! ( x = get_byte ( c ) ) ) cnt += 255 ;
cnt += mask + x ;
}
return cnt ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
Oid get_range_subtype ( Oid rangeOid ) {
HeapTuple tp ;
tp = SearchSysCache1 ( RANGETYPE , ObjectIdGetDatum ( rangeOid ) ) ;
if ( HeapTupleIsValid ( tp ) ) {
Form_pg_range rngtup = ( Form_pg_range ) GETSTRUCT ( tp ) ;
Oid result ;
result = rngtup -> rngsubtype ;
ReleaseSysCache ( tp ) ;
return result ;
}
else return InvalidOid ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline Float11 * i2f ( int i , Float11 * f ) {
f -> sign = ( i < 0 ) ;
if ( f -> sign ) i = - i ;
f -> exp = av_log2_16bit ( i ) + ! ! i ;
f -> mant = i ? ( i << 6 ) >> f -> exp : 1 << 5 ;
return f ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int xhci_try_complete_packet ( XHCITransfer * xfer ) {
if ( xfer -> packet . status == USB_RET_ASYNC ) {
trace_usb_xhci_xfer_async ( xfer ) ;
xfer -> running_async = 1 ;
xfer -> running_retry = 0 ;
xfer -> complete = 0 ;
return 0 ;
}
else if ( xfer -> packet . status == USB_RET_NAK ) {
trace_usb_xhci_xfer_nak ( xfer ) ;
xfer -> running_async = 0 ;
xfer -> running_retry = 1 ;
xfer -> complete = 0 ;
return 0 ;
}
else {
xfer -> running_async = 0 ;
xfer -> running_retry = 0 ;
xfer -> complete = 1 ;
xhci_xfer_unmap ( xfer ) ;
}
if ( xfer -> packet . status == USB_RET_SUCCESS ) {
trace_usb_xhci_xfer_success ( xfer , xfer -> packet . actual_length ) ;
xfer -> status = CC_SUCCESS ;
xhci_xfer_report ( xfer ) ;
return 0 ;
}
trace_usb_xhci_xfer_error ( xfer , xfer -> packet . status ) ;
switch ( xfer -> packet . status ) {
case USB_RET_NODEV : case USB_RET_IOERROR : xfer -> status = CC_USB_TRANSACTION_ERROR ;
xhci_xfer_report ( xfer ) ;
xhci_stall_ep ( xfer ) ;
break ;
case USB_RET_STALL : xfer -> status = CC_STALL_ERROR ;
xhci_xfer_report ( xfer ) ;
xhci_stall_ep ( xfer ) ;
break ;
case USB_RET_BABBLE : xfer -> status = CC_BABBLE_DETECTED ;
xhci_xfer_report ( xfer ) ;
xhci_stall_ep ( xfer ) ;
break ;
default : DPRINTF ( "%s: FIXME: status = %d\n" , __func__ , xfer -> packet . status ) ;
FIXME ( "unhandled USB_RET_*" ) ;
}
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_btgatt_microbit_button_a_state ( tvbuff_t * tvb , packet_info * pinfo _U_ , proto_tree * tree , void * data ) {
btatt_data_t * att_data = ( btatt_data_t * ) data ;
gint offset = 0 ;
if ( bluetooth_gatt_has_no_parameter ( att_data -> opcode ) ) return - 1 ;
proto_tree_add_item ( tree , hf_gatt_microbit_button_a_state , tvb , offset , 1 , ENC_NA ) ;
offset += 1 ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_h245_SequenceNumber ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 0U , 255U , NULL , FALSE ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool cephx_decode_ticket ( CephContext * cct , KeyStore * keys , uint32_t service_id , CephXTicketBlob & ticket_blob , CephXServiceTicketInfo & ticket_info ) {
uint64_t secret_id = ticket_blob . secret_id ;
CryptoKey service_secret ;
if ( ! ticket_blob . blob . length ( ) ) {
return false ;
}
if ( secret_id == ( uint64_t ) - 1 ) {
if ( ! keys -> get_secret ( cct -> _conf -> name , service_secret ) ) {
ldout ( cct , 0 ) << "ceph_decode_ticket could not get general service secret for service_id=" << ceph_entity_type_name ( service_id ) << " secret_id=" << secret_id << dendl ;
return false ;
}
}
else {
if ( ! keys -> get_service_secret ( service_id , secret_id , service_secret ) ) {
ldout ( cct , 0 ) << "ceph_decode_ticket could not get service secret for service_id=" << ceph_entity_type_name ( service_id ) << " secret_id=" << secret_id << dendl ;
return false ;
}
}
std : : string error ;
decode_decrypt_enc_bl ( cct , ticket_info , service_secret , ticket_blob . blob , error ) ;
if ( ! error . empty ( ) ) {
ldout ( cct , 0 ) << "ceph_decode_ticket could not decrypt ticket info. error:" << error << dendl ;
return false ;
}
return true ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void f_parser ( lua_State * L , void * ud ) {
int i ;
Proto * tf ;
Closure * cl ;
struct SParser * p = cast ( struct SParser * , ud ) ;
int c = luaZ_lookahead ( p -> z ) ;
luaC_checkGC ( L ) ;
tf = ( luaY_parser ) ( L , p -> z , & p -> buff , p -> name ) ;
cl = luaF_newLclosure ( L , tf -> nups , hvalue ( gt ( L ) ) ) ;
cl -> l . p = tf ;
for ( i = 0 ;
i < tf -> nups ;
i ++ ) cl -> l . upvals [ i ] = luaF_newupval ( L ) ;
setclvalue ( L , L -> top , cl ) ;
incr_top ( L ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int SpoolssFCPN_r ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
offset = dissect_doserror ( tvb , offset , pinfo , tree , di , drep , hf_rc , NULL ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dsa_cb ( int operation , ASN1_VALUE * * pval , const ASN1_ITEM * it , void * exarg ) {
if ( operation == ASN1_OP_NEW_PRE ) {
* pval = ( ASN1_VALUE * ) DSA_new ( ) ;
if ( * pval ) return 2 ;
return 0 ;
}
else if ( operation == ASN1_OP_FREE_PRE ) {
DSA_free ( ( DSA * ) * pval ) ;
* pval = NULL ;
return 2 ;
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp8_regular_quantize_b_c ( BLOCK * b , BLOCKD * d ) {
int i , rc , eob ;
int zbin ;
int x , y , z , sz ;
short * zbin_boost_ptr = b -> zrun_zbin_boost ;
short * coeff_ptr = b -> coeff ;
short * zbin_ptr = b -> zbin ;
short * round_ptr = b -> round ;
short * quant_ptr = b -> quant ;
short * quant_shift_ptr = b -> quant_shift ;
short * qcoeff_ptr = d -> qcoeff ;
short * dqcoeff_ptr = d -> dqcoeff ;
short * dequant_ptr = d -> dequant ;
short zbin_oq_value = b -> zbin_extra ;
vpx_memset ( qcoeff_ptr , 0 , 32 ) ;
vpx_memset ( dqcoeff_ptr , 0 , 32 ) ;
eob = - 1 ;
for ( i = 0 ;
i < 16 ;
i ++ ) {
rc = vp8_default_zig_zag1d [ i ] ;
z = coeff_ptr [ rc ] ;
zbin = zbin_ptr [ rc ] + * zbin_boost_ptr + zbin_oq_value ;
zbin_boost_ptr ++ ;
sz = ( z >> 31 ) ;
x = ( z ^ sz ) - sz ;
if ( x >= zbin ) {
x += round_ptr [ rc ] ;
y = ( ( ( ( x * quant_ptr [ rc ] ) >> 16 ) + x ) * quant_shift_ptr [ rc ] ) >> 16 ;
x = ( y ^ sz ) - sz ;
qcoeff_ptr [ rc ] = x ;
dqcoeff_ptr [ rc ] = x * dequant_ptr [ rc ] ;
if ( y ) {
eob = i ;
zbin_boost_ptr = b -> zrun_zbin_boost ;
}
}
}
* d -> eob = ( char ) ( eob + 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( PageLoadMetricsBrowserTest , AbortNewNavigation ) {
ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ;
GURL url ( embedded_test_server ( ) -> GetURL ( "/title1.html" ) ) ;
NavigateParams params ( browser ( ) , url , ui : : PAGE_TRANSITION_LINK ) ;
content : : TestNavigationManager manager ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , url ) ;
Navigate ( & params ) ;
EXPECT_TRUE ( manager . WaitForRequestStart ( ) ) ;
GURL url2 ( embedded_test_server ( ) -> GetURL ( "/title2.html" ) ) ;
NavigateParams params2 ( browser ( ) , url2 , ui : : PAGE_TRANSITION_FROM_ADDRESS_BAR ) ;
auto waiter = CreatePageLoadMetricsWaiter ( ) ;
waiter -> AddPageExpectation ( TimingField : : LOAD_EVENT ) ;
Navigate ( & params2 ) ;
waiter -> Wait ( ) ;
histogram_tester_ . ExpectTotalCount ( internal : : kHistogramAbortNewNavigationBeforeCommit , 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void cancel_mime_list_for_file ( NautilusDirectory * directory , NautilusFile * file ) {
if ( directory -> details -> mime_list_in_progress != NULL && directory -> details -> mime_list_in_progress -> mime_list_file == file ) {
mime_list_cancel ( directory ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int main ( int argc , char * * argv ) {
int frame_cnt = 0 ;
FILE * outfile = NULL ;
vpx_codec_ctx_t codec ;
VpxVideoReader * reader = NULL ;
const VpxInterface * decoder = NULL ;
const VpxVideoInfo * info = NULL ;
exec_name = argv [ 0 ] ;
if ( argc != 3 ) die ( "Invalid number of arguments." ) ;
reader = vpx_video_reader_open ( argv [ 1 ] ) ;
if ( ! reader ) die ( "Failed to open %s for reading." , argv [ 1 ] ) ;
if ( ! ( outfile = fopen ( argv [ 2 ] , "wb" ) ) ) die ( "Failed to open %s for writing." , argv [ 2 ] ) ;
info = vpx_video_reader_get_info ( reader ) ;
decoder = get_vpx_decoder_by_fourcc ( info -> codec_fourcc ) ;
if ( ! decoder ) die ( "Unknown input codec." ) ;
printf ( "Using %s\n" , vpx_codec_iface_name ( decoder -> codec_interface ( ) ) ) ;
if ( vpx_codec_dec_init ( & codec , decoder -> codec_interface ( ) , NULL , 0 ) ) die_codec ( & codec , "Failed to initialize decoder." ) ;
while ( vpx_video_reader_read_frame ( reader ) ) {
vpx_codec_iter_t iter = NULL ;
vpx_image_t * img = NULL ;
size_t frame_size = 0 ;
const unsigned char * frame = vpx_video_reader_get_frame ( reader , & frame_size ) ;
if ( vpx_codec_decode ( & codec , frame , ( unsigned int ) frame_size , NULL , 0 ) ) die_codec ( & codec , "Failed to decode frame." ) ;
while ( ( img = vpx_codec_get_frame ( & codec , & iter ) ) != NULL ) {
vpx_img_write ( img , outfile ) ;
++ frame_cnt ;
}
}
printf ( "Processed %d frames.\n" , frame_cnt ) ;
if ( vpx_codec_destroy ( & codec ) ) die_codec ( & codec , "Failed to destroy codec" ) ;
printf ( "Play: ffplay -f rawvideo -pix_fmt yuv420p -s %dx%d %s\n" , info -> frame_width , info -> frame_height , argv [ 2 ] ) ;
vpx_video_reader_close ( reader ) ;
fclose ( outfile ) ;
return EXIT_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dequant ( float * out , const int * idx , const float * cbs [ ] ) {
int i ;
int stride = 2 ;
int num_vec = 5 ;
for ( i = 0 ;
i < num_vec ;
i ++ ) memcpy ( out + stride * i , cbs [ i ] + stride * idx [ i ] , stride * sizeof ( float ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
unsigned int vp9_sad ## m ## x ## n ## _c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride ) {
return sad ( src , src_stride , ref , ref_stride , m , n ) ;
\ }
unsigned int vp9_sad ## m ## x ## n ## _avg_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , const uint8_t * second_pred ) {
uint8_t comp_pred [ m * n ] ;
vp9_comp_avg_pred ( comp_pred , second_pred , m , n , ref , ref_stride ) ;
return sad ( src , src_stride , comp_pred , m , m , n ) ;
\ }
# define sadMxNxK ( m , n , k ) void vp9_sad ## m ## x ## n ## x ## k ## _c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < k ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , & ref [ i ] , ref_stride ) ;
\ }
# define sadMxNx4D ( m , n ) void vp9_sad ## m ## x ## n ## x4d_c ( const uint8_t * src , int src_stride , const uint8_t * const refs [ ] , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < 4 ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , refs [ i ] , ref_stride ) ;
\ }
sadMxN ( 64 , 64 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void add_h245_Address ( h323_calls_info_t * h323info , h245_address_t * h245_address ) {
h323info -> h245_list = g_list_prepend ( h323info -> h245_list , h245_address ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int xsltSecurityAllow ( xsltSecurityPrefsPtr sec ATTRIBUTE_UNUSED , xsltTransformContextPtr ctxt ATTRIBUTE_UNUSED , const char * value ATTRIBUTE_UNUSED ) {
return ( 1 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void gdev_mem_mono_set_inverted ( gx_device_memory * dev , bool black_is_1 ) {
if ( black_is_1 ) dev -> palette = mem_mono_b_w_palette ;
else dev -> palette = mem_mono_w_b_palette ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void _slurm_rpc_delete_partition ( slurm_msg_t * msg ) {
int error_code = SLURM_SUCCESS ;
DEF_TIMERS ;
delete_part_msg_t * part_desc_ptr = ( delete_part_msg_t * ) msg -> data ;
slurmctld_lock_t part_write_lock = {
NO_LOCK , WRITE_LOCK , READ_LOCK , WRITE_LOCK , NO_LOCK }
;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
START_TIMER ;
debug2 ( "Processing RPC: REQUEST_DELETE_PARTITION from uid=%d" , uid ) ;
if ( ! validate_super_user ( uid ) ) {
error_code = ESLURM_USER_ID_MISSING ;
error ( "Security violation, DELETE_PARTITION RPC from uid=%d" , uid ) ;
}
if ( error_code == SLURM_SUCCESS ) {
lock_slurmctld ( part_write_lock ) ;
error_code = delete_partition ( part_desc_ptr ) ;
unlock_slurmctld ( part_write_lock ) ;
END_TIMER2 ( "_slurm_rpc_delete_partition" ) ;
}
if ( error_code ) {
info ( "_slurm_rpc_delete_partition partition=%s: %s" , part_desc_ptr -> name , slurm_strerror ( error_code ) ) ;
slurm_send_rc_msg ( msg , error_code ) ;
}
else {
info ( "_slurm_rpc_delete_partition complete for %s %s" , part_desc_ptr -> name , TIME_STR ) ;
slurm_send_rc_msg ( msg , SLURM_SUCCESS ) ;
save_all_state ( ) ;
queue_job_scheduler ( ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline bool e1000e_itr_should_postpone ( E1000ECore * core ) {
return e1000e_postpone_interrupt ( & core -> itr_intr_pending , & core -> itr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp8_mbpost_proc_across_ip_c ( unsigned char * src , int pitch , int rows , int cols , int flimit ) {
int r , c , i ;
unsigned char * s = src ;
unsigned char d [ 16 ] ;
for ( r = 0 ;
r < rows ;
r ++ ) {
int sumsq = 0 ;
int sum = 0 ;
for ( i = - 8 ;
i < 0 ;
i ++ ) s [ i ] = s [ 0 ] ;
for ( i = cols ;
i < cols + 17 ;
i ++ ) s [ i ] = s [ cols - 1 ] ;
for ( i = - 8 ;
i <= 6 ;
i ++ ) {
sumsq += s [ i ] * s [ i ] ;
sum += s [ i ] ;
d [ i + 8 ] = 0 ;
}
for ( c = 0 ;
c < cols + 8 ;
c ++ ) {
int x = s [ c + 7 ] - s [ c - 8 ] ;
int y = s [ c + 7 ] + s [ c - 8 ] ;
sum += x ;
sumsq += x * y ;
d [ c & 15 ] = s [ c ] ;
if ( sumsq * 15 - sum * sum < flimit ) {
d [ c & 15 ] = ( 8 + sum + s [ c ] ) >> 4 ;
}
s [ c - 8 ] = d [ ( c - 8 ) & 15 ] ;
}
s += pitch ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void SFDummyUpCIDs ( struct glyphinfo * gi , SplineFont * sf ) {
int i , j , k , max ;
int * bygid ;
max = 0 ;
for ( k = 0 ;
k < sf -> subfontcnt ;
++ k ) if ( sf -> subfonts [ k ] -> glyphcnt > max ) max = sf -> subfonts [ k ] -> glyphcnt ;
if ( max == 0 ) return ;
sf -> glyphs = calloc ( max , sizeof ( SplineChar * ) ) ;
sf -> glyphcnt = sf -> glyphmax = max ;
for ( k = 0 ;
k < sf -> subfontcnt ;
++ k ) for ( i = 0 ;
i < sf -> subfonts [ k ] -> glyphcnt ;
++ i ) if ( sf -> subfonts [ k ] -> glyphs [ i ] != NULL ) sf -> glyphs [ i ] = sf -> subfonts [ k ] -> glyphs [ i ] ;
if ( gi == NULL ) return ;
bygid = malloc ( ( sf -> glyphcnt + 3 ) * sizeof ( int ) ) ;
memset ( bygid , 0xff , ( sf -> glyphcnt + 3 ) * sizeof ( int ) ) ;
j = 1 ;
for ( i = 0 ;
i < sf -> glyphcnt ;
++ i ) if ( sf -> glyphs [ i ] != NULL ) {
if ( bygid [ 0 ] == - 1 && strcmp ( sf -> glyphs [ i ] -> name , ".notdef" ) == 0 ) {
sf -> glyphs [ i ] -> ttf_glyph = 0 ;
bygid [ 0 ] = i ;
}
else if ( SCWorthOutputting ( sf -> glyphs [ i ] ) ) {
sf -> glyphs [ i ] -> ttf_glyph = j ;
bygid [ j ++ ] = i ;
}
}
gi -> bygid = bygid ;
gi -> gcnt = j ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline int padr_match ( PCNetState * s , const uint8_t * buf , int size ) {
struct qemu_ether_header * hdr = ( void * ) buf ;
uint8_t padr [ 6 ] = {
s -> csr [ 12 ] & 0xff , s -> csr [ 12 ] >> 8 , s -> csr [ 13 ] & 0xff , s -> csr [ 13 ] >> 8 , s -> csr [ 14 ] & 0xff , s -> csr [ 14 ] >> 8 }
;
int result = ( ! CSR_DRCVPA ( s ) ) && ! memcmp ( hdr -> ether_dhost , padr , 6 ) ;
# ifdef PCNET_DEBUG_MATCH printf ( "packet dhost=%02x:%02x:%02x:%02x:%02x:%02x, " "padr=%02x:%02x:%02x:%02x:%02x:%02x\n" , hdr -> ether_dhost [ 0 ] , hdr -> ether_dhost [ 1 ] , hdr -> ether_dhost [ 2 ] , hdr -> ether_dhost [ 3 ] , hdr -> ether_dhost [ 4 ] , hdr -> ether_dhost [ 5 ] , padr [ 0 ] , padr [ 1 ] , padr [ 2 ] , padr [ 3 ] , padr [ 4 ] , padr [ 5 ] ) ;
printf ( "padr_match result=%d\n" , result ) ;
# endif return result ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void set_good_speed_feature ( VP9_COMP * cpi , VP9_COMMON * cm , SPEED_FEATURES * sf , int speed ) {
const int boosted = frame_is_boosted ( cpi ) ;
sf -> adaptive_rd_thresh = 1 ;
sf -> allow_skip_recode = 1 ;
if ( speed >= 1 ) {
sf -> use_square_partition_only = ! frame_is_intra_only ( cm ) ;
sf -> less_rectangular_check = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> disable_split_mask = cm -> show_frame ? DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT ;
else sf -> disable_split_mask = DISABLE_COMPOUND_SPLIT ;
sf -> use_rd_breakout = 1 ;
sf -> adaptive_motion_search = 1 ;
sf -> mv . auto_mv_step_size = 1 ;
sf -> adaptive_rd_thresh = 2 ;
sf -> mv . subpel_iters_per_step = 1 ;
sf -> mode_skip_start = 10 ;
sf -> adaptive_pred_interp_filter = 1 ;
sf -> recode_loop = ALLOW_RECODE_KFARFGF ;
sf -> intra_y_mode_mask [ TX_32X32 ] = INTRA_DC_H_V ;
sf -> intra_uv_mode_mask [ TX_32X32 ] = INTRA_DC_H_V ;
sf -> intra_y_mode_mask [ TX_16X16 ] = INTRA_DC_H_V ;
sf -> intra_uv_mode_mask [ TX_16X16 ] = INTRA_DC_H_V ;
sf -> tx_size_search_breakout = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 23 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 21 ) ;
sf -> partition_search_breakout_rate_thr = 500 ;
}
if ( speed >= 2 ) {
sf -> tx_size_search_method = frame_is_boosted ( cpi ) ? USE_FULL_RD : USE_LARGESTALL ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) {
sf -> lf_motion_threshold = LOW_MOTION_THRESHOLD ;
sf -> last_partitioning_redo_frequency = 3 ;
sf -> disable_split_mask = cm -> show_frame ? DISABLE_ALL_SPLIT : DISABLE_ALL_INTER_SPLIT ;
sf -> adaptive_pred_interp_filter = 0 ;
}
else {
sf -> disable_split_mask = LAST_AND_INTRA_SPLIT_ONLY ;
sf -> last_partitioning_redo_frequency = 2 ;
sf -> lf_motion_threshold = NO_MOTION_THRESHOLD ;
}
sf -> reference_masking = 1 ;
sf -> mode_search_skip_flags = FLAG_SKIP_INTRA_DIRMISMATCH | FLAG_SKIP_INTRA_BESTINTER | FLAG_SKIP_COMP_BESTINTRA | FLAG_SKIP_INTRA_LOWVAR ;
sf -> disable_filter_search_var_thresh = 100 ;
sf -> comp_inter_joint_search_thresh = BLOCK_SIZES ;
sf -> auto_min_max_partition_size = CONSTRAIN_NEIGHBORING_MIN_MAX ;
sf -> use_lastframe_partitioning = LAST_FRAME_PARTITION_LOW_MOTION ;
sf -> adjust_partitioning_from_last_frame = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 24 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 22 ) ;
sf -> partition_search_breakout_rate_thr = 700 ;
}
if ( speed >= 3 ) {
sf -> tx_size_search_method = frame_is_intra_only ( cm ) ? USE_FULL_RD : USE_LARGESTALL ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) {
sf -> disable_split_mask = DISABLE_ALL_SPLIT ;
}
else {
sf -> max_intra_bsize = BLOCK_32X32 ;
sf -> disable_split_mask = DISABLE_ALL_INTER_SPLIT ;
}
sf -> adaptive_pred_interp_filter = 0 ;
sf -> adaptive_mode_search = 1 ;
sf -> cb_partition_search = ! boosted ;
sf -> cb_pred_filter_search = 1 ;
sf -> alt_ref_search_fp = 1 ;
sf -> motion_field_mode_search = ! boosted ;
sf -> lf_motion_threshold = LOW_MOTION_THRESHOLD ;
sf -> last_partitioning_redo_frequency = 2 ;
sf -> recode_loop = ALLOW_RECODE_KFMAXBW ;
sf -> adaptive_rd_thresh = 3 ;
sf -> mode_skip_start = 6 ;
sf -> intra_y_mode_mask [ TX_32X32 ] = INTRA_DC ;
sf -> intra_uv_mode_mask [ TX_32X32 ] = INTRA_DC ;
sf -> adaptive_interp_filter_search = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 25 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 23 ) ;
sf -> partition_search_breakout_rate_thr = 1000 ;
}
if ( speed >= 4 ) {
sf -> use_square_partition_only = 1 ;
sf -> tx_size_search_method = USE_LARGESTALL ;
sf -> disable_split_mask = DISABLE_ALL_SPLIT ;
sf -> adaptive_rd_thresh = 4 ;
sf -> mode_search_skip_flags |= FLAG_SKIP_COMP_REFMISMATCH | FLAG_EARLY_TERMINATE ;
sf -> disable_filter_search_var_thresh = 200 ;
sf -> use_lastframe_partitioning = LAST_FRAME_PARTITION_ALL ;
sf -> use_lp32x32fdct = 1 ;
sf -> use_fast_coef_updates = ONE_LOOP_REDUCED ;
sf -> use_fast_coef_costing = 1 ;
if ( MIN ( cm -> width , cm -> height ) >= 720 ) sf -> partition_search_breakout_dist_thr = ( 1 << 26 ) ;
else sf -> partition_search_breakout_dist_thr = ( 1 << 24 ) ;
sf -> partition_search_breakout_rate_thr = 1500 ;
}
if ( speed >= 5 ) {
int i ;
sf -> partition_search_type = FIXED_PARTITION ;
sf -> optimize_coefficients = 0 ;
sf -> mv . search_method = HEX ;
sf -> disable_filter_search_var_thresh = 500 ;
for ( i = 0 ;
i < TX_SIZES ;
++ i ) {
sf -> intra_y_mode_mask [ i ] = INTRA_DC ;
sf -> intra_uv_mode_mask [ i ] = INTRA_DC ;
}
cpi -> allow_encode_breakout = ENCODE_BREAKOUT_ENABLED ;
}
if ( speed >= 6 ) {
sf -> mv . reduce_first_step_size = 1 ;
}
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static VALUE cState_indent_set ( VALUE self , VALUE indent ) {
unsigned long len ;
GET_STATE ( self ) ;
Check_Type ( indent , T_STRING ) ;
len = RSTRING_LEN ( indent ) ;
if ( len == 0 ) {
if ( state -> indent ) {
ruby_xfree ( state -> indent ) ;
state -> indent = NULL ;
state -> indent_len = 0 ;
}
}
else {
if ( state -> indent ) ruby_xfree ( state -> indent ) ;
state -> indent = fstrndup ( RSTRING_PTR ( indent ) , len ) ;
state -> indent_len = len ;
}
return Qnil ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
TEST_F ( PrintPreviewUIUnitTest , PrintPreviewData ) {
WebContents * initiator = browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) ;
ASSERT_TRUE ( initiator ) ;
EXPECT_FALSE ( IsShowingWebContentsModalDialog ( initiator ) ) ;
printing : : PrintPreviewDialogController * controller = printing : : PrintPreviewDialogController : : GetInstance ( ) ;
ASSERT_TRUE ( controller ) ;
printing : : PrintViewManager * print_view_manager = printing : : PrintViewManager : : FromWebContents ( initiator ) ;
print_view_manager -> PrintPreviewNow ( false ) ;
WebContents * preview_dialog = controller -> GetOrCreatePreviewDialog ( initiator ) ;
EXPECT_NE ( initiator , preview_dialog ) ;
EXPECT_EQ ( 1 , browser ( ) -> tab_strip_model ( ) -> count ( ) ) ;
EXPECT_TRUE ( IsShowingWebContentsModalDialog ( initiator ) ) ;
PrintPreviewUI * preview_ui = static_cast < PrintPreviewUI * > ( preview_dialog -> GetWebUI ( ) -> GetController ( ) ) ;
ASSERT_TRUE ( preview_ui != NULL ) ;
scoped_refptr < base : : RefCountedBytes > data ;
preview_ui -> GetPrintPreviewDataForIndex ( printing : : COMPLETE_PREVIEW_DOCUMENT_INDEX , & data ) ;
EXPECT_EQ ( NULL , data . get ( ) ) ;
scoped_refptr < base : : RefCountedBytes > dummy_data = CreateTestData ( ) ;
preview_ui -> SetPrintPreviewDataForIndex ( printing : : COMPLETE_PREVIEW_DOCUMENT_INDEX , dummy_data . get ( ) ) ;
preview_ui -> GetPrintPreviewDataForIndex ( printing : : COMPLETE_PREVIEW_DOCUMENT_INDEX , & data ) ;
EXPECT_EQ ( dummy_data -> size ( ) , data -> size ( ) ) ;
EXPECT_EQ ( dummy_data . get ( ) , data . get ( ) ) ;
dummy_data = new base : : RefCountedBytes ( ) ;
preview_ui -> SetPrintPreviewDataForIndex ( printing : : FIRST_PAGE_INDEX , dummy_data . get ( ) ) ;
preview_ui -> ClearAllPreviewData ( ) ;
preview_ui -> GetPrintPreviewDataForIndex ( printing : : COMPLETE_PREVIEW_DOCUMENT_INDEX , & data ) ;
EXPECT_EQ ( NULL , data . get ( ) ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int collated_compare ( const void * a , const void * b ) {
const char * const s1 = * ( const char * const * const ) a ;
const char * const s2 = * ( const char * const * const ) b ;
if ( s1 == s2 ) return 0 ;
if ( s1 == NULL ) return 1 ;
if ( s2 == NULL ) return - 1 ;
return strcoll ( s1 , s2 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void truespeech_filters_merge ( TSContext * dec ) {
int i ;
if ( ! dec -> flag ) {
for ( i = 0 ;
i < 8 ;
i ++ ) {
dec -> filters [ i + 0 ] = dec -> prevfilt [ i ] ;
dec -> filters [ i + 8 ] = dec -> prevfilt [ i ] ;
}
}
else {
for ( i = 0 ;
i < 8 ;
i ++ ) {
dec -> filters [ i + 0 ] = ( dec -> cvector [ i ] * 21846 + dec -> prevfilt [ i ] * 10923 + 16384 ) >> 15 ;
dec -> filters [ i + 8 ] = ( dec -> cvector [ i ] * 10923 + dec -> prevfilt [ i ] * 21846 + 16384 ) >> 15 ;
}
}
for ( i = 0 ;
i < 8 ;
i ++ ) {
dec -> filters [ i + 16 ] = dec -> cvector [ i ] ;
dec -> filters [ i + 24 ] = dec -> cvector [ i ] ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void bn_sqr_comba8 ( BN_ULONG * r , const BN_ULONG * a ) {
BN_ULONG c1 , c2 , c3 ;
c1 = 0 ;
c2 = 0 ;
c3 = 0 ;
sqr_add_c ( a , 0 , c1 , c2 , c3 ) ;
r [ 0 ] = c1 ;
c1 = 0 ;
sqr_add_c2 ( a , 1 , 0 , c2 , c3 , c1 ) ;
r [ 1 ] = c2 ;
c2 = 0 ;
sqr_add_c ( a , 1 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 2 , 0 , c3 , c1 , c2 ) ;
r [ 2 ] = c3 ;
c3 = 0 ;
sqr_add_c2 ( a , 3 , 0 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 2 , 1 , c1 , c2 , c3 ) ;
r [ 3 ] = c1 ;
c1 = 0 ;
sqr_add_c ( a , 2 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 3 , 1 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 4 , 0 , c2 , c3 , c1 ) ;
r [ 4 ] = c2 ;
c2 = 0 ;
sqr_add_c2 ( a , 5 , 0 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 4 , 1 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 3 , 2 , c3 , c1 , c2 ) ;
r [ 5 ] = c3 ;
c3 = 0 ;
sqr_add_c ( a , 3 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 4 , 2 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 5 , 1 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 6 , 0 , c1 , c2 , c3 ) ;
r [ 6 ] = c1 ;
c1 = 0 ;
sqr_add_c2 ( a , 7 , 0 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 6 , 1 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 5 , 2 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 4 , 3 , c2 , c3 , c1 ) ;
r [ 7 ] = c2 ;
c2 = 0 ;
sqr_add_c ( a , 4 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 5 , 3 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 6 , 2 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 7 , 1 , c3 , c1 , c2 ) ;
r [ 8 ] = c3 ;
c3 = 0 ;
sqr_add_c2 ( a , 7 , 2 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 6 , 3 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 5 , 4 , c1 , c2 , c3 ) ;
r [ 9 ] = c1 ;
c1 = 0 ;
sqr_add_c ( a , 5 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 6 , 4 , c2 , c3 , c1 ) ;
sqr_add_c2 ( a , 7 , 3 , c2 , c3 , c1 ) ;
r [ 10 ] = c2 ;
c2 = 0 ;
sqr_add_c2 ( a , 7 , 4 , c3 , c1 , c2 ) ;
sqr_add_c2 ( a , 6 , 5 , c3 , c1 , c2 ) ;
r [ 11 ] = c3 ;
c3 = 0 ;
sqr_add_c ( a , 6 , c1 , c2 , c3 ) ;
sqr_add_c2 ( a , 7 , 5 , c1 , c2 , c3 ) ;
r [ 12 ] = c1 ;
c1 = 0 ;
sqr_add_c2 ( a , 7 , 6 , c2 , c3 , c1 ) ;
r [ 13 ] = c2 ;
c2 = 0 ;
sqr_add_c ( a , 7 , c3 , c1 , c2 ) ;
r [ 14 ] = c3 ;
r [ 15 ] = c1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void mark_commit ( struct commit * c , void * data ) {
mark_object ( & c -> object , NULL , NULL , data ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
void timeout_process ( struct event_base * base ) {
struct timeval now ;
struct event * ev ;
if ( min_heap_empty ( & base -> timeheap ) ) return ;
gettime ( base , & now ) ;
while ( ( ev = min_heap_top ( & base -> timeheap ) ) ) {
if ( evutil_timercmp ( & ev -> ev_timeout , & now , > ) ) break ;
event_del ( ev ) ;
event_debug ( ( "timeout_process: call %p" , ev -> ev_callback ) ) ;
event_active ( ev , EV_TIMEOUT , 1 ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void gx_ttfReader__Reset ( gx_ttfReader * self ) {
if ( self -> extra_glyph_index != - 1 ) {
self -> extra_glyph_index = - 1 ;
gs_glyph_data_free ( & self -> glyph_data , "gx_ttfReader__Reset" ) ;
}
self -> error = false ;
self -> pos = 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int tipc_nl_compat_bearer_disable ( struct tipc_nl_compat_cmd_doit * cmd , struct sk_buff * skb , struct tipc_nl_compat_msg * msg ) {
char * name ;
struct nlattr * bearer ;
name = ( char * ) TLV_DATA ( msg -> req ) ;
bearer = nla_nest_start ( skb , TIPC_NLA_BEARER ) ;
if ( ! bearer ) return - EMSGSIZE ;
if ( nla_put_string ( skb , TIPC_NLA_BEARER_NAME , name ) ) return - EMSGSIZE ;
nla_nest_end ( skb , bearer ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static inline void dpy_resize ( DisplayState * s , int w , int h ) {
s -> dpy_resize ( s , w , h ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( AppApiTest , SameBrowsingInstanceAfterSwap ) {
extensions : : ProcessMap * process_map = extensions : : ProcessMap : : Get ( browser ( ) -> profile ( ) ) ;
GURL base_url = GetTestBaseURL ( "app_process" ) ;
const Extension * app = LoadExtension ( test_data_dir_ . AppendASCII ( "app_process" ) ) ;
ASSERT_TRUE ( app ) ;
ui_test_utils : : NavigateToURL ( browser ( ) , base_url . Resolve ( "path1/iframe.html" ) ) ;
content : : SiteInstance * app_instance = browser ( ) -> tab_strip_model ( ) -> GetWebContentsAt ( 0 ) -> GetSiteInstance ( ) ;
EXPECT_TRUE ( process_map -> Contains ( app_instance -> GetProcess ( ) -> GetID ( ) ) ) ;
const BrowserList * active_browser_list = BrowserList : : GetInstance ( ) ;
EXPECT_EQ ( 2U , active_browser_list -> size ( ) ) ;
content : : WebContents * popup_contents = active_browser_list -> get ( 1 ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) ;
content : : WaitForLoadStop ( popup_contents ) ;
SiteInstance * popup_instance = popup_contents -> GetSiteInstance ( ) ;
EXPECT_EQ ( app_instance , popup_instance ) ;
GURL non_app_url ( base_url . Resolve ( "path3/empty.html" ) ) ;
ui_test_utils : : NavigateToURL ( active_browser_list -> get ( 1 ) , non_app_url ) ;
SiteInstance * new_instance = popup_contents -> GetSiteInstance ( ) ;
EXPECT_NE ( app_instance , new_instance ) ;
EXPECT_TRUE ( app_instance -> IsRelatedSiteInstance ( new_instance ) ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void PNGAPI png_set_tRNS ( png_structp png_ptr , png_infop info_ptr , png_bytep trans , int num_trans , png_color_16p trans_values ) {
png_debug1 ( 1 , "in %s storage function" , "tRNS" ) ;
if ( png_ptr == NULL || info_ptr == NULL ) return ;
if ( num_trans < 0 || num_trans > PNG_MAX_PALETTE_LENGTH ) {
png_warning ( png_ptr , "Ignoring invalid num_trans value" ) ;
return ;
}
if ( trans != NULL ) {
# ifdef PNG_FREE_ME_SUPPORTED png_free_data ( png_ptr , info_ptr , PNG_FREE_TRNS , 0 ) ;
# endif png_ptr -> trans = info_ptr -> trans = ( png_bytep ) png_malloc ( png_ptr , ( png_uint_32 ) PNG_MAX_PALETTE_LENGTH ) ;
if ( num_trans > 0 && num_trans <= PNG_MAX_PALETTE_LENGTH ) png_memcpy ( info_ptr -> trans , trans , ( png_size_t ) num_trans ) ;
}
if ( trans_values != NULL ) {
int sample_max = ( 1 << info_ptr -> bit_depth ) ;
if ( ( info_ptr -> color_type == PNG_COLOR_TYPE_GRAY && ( int ) trans_values -> gray > sample_max ) || ( info_ptr -> color_type == PNG_COLOR_TYPE_RGB && ( ( int ) trans_values -> red > sample_max || ( int ) trans_values -> green > sample_max || ( int ) trans_values -> blue > sample_max ) ) ) png_warning ( png_ptr , "tRNS chunk has out-of-range samples for bit_depth" ) ;
png_memcpy ( & ( info_ptr -> trans_values ) , trans_values , png_sizeof ( png_color_16 ) ) ;
if ( num_trans == 0 ) num_trans = 1 ;
}
info_ptr -> num_trans = ( png_uint_16 ) num_trans ;
if ( num_trans != 0 ) {
info_ptr -> valid |= PNG_INFO_tRNS ;
# ifdef PNG_FREE_ME_SUPPORTED info_ptr -> free_me |= PNG_FREE_TRNS ;
# else png_ptr -> flags |= PNG_FLAG_FREE_TRNS ;
# endif }
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t getFromUBytesValue ( CnvExtData * extData , UCMTable * table , UCMapping * m ) {
uint8_t * bytes , * resultBytes ;
uint32_t value ;
int32_t u16Length , ratio ;
if ( m -> f == 2 ) {
return UCNV_EXT_FROM_U_SUBCHAR1 ;
}
bytes = UCM_GET_BYTES ( table , m ) ;
value = 0 ;
switch ( m -> bLen ) {
case 3 : value = ( ( uint32_t ) * bytes ++ ) << 16 ;
case 2 : value |= ( ( uint32_t ) * bytes ++ ) << 8 ;
case 1 : value |= * bytes ;
break ;
default : value = ( uint32_t ) utm_countItems ( extData -> fromUBytes ) ;
resultBytes = utm_allocN ( extData -> fromUBytes , m -> bLen ) ;
uprv_memcpy ( resultBytes , bytes , m -> bLen ) ;
break ;
}
value |= ( uint32_t ) m -> bLen << UCNV_EXT_FROM_U_LENGTH_SHIFT ;
if ( m -> f == 0 ) {
value |= UCNV_EXT_FROM_U_ROUNDTRIP_FLAG ;
}
else if ( m -> f == 4 ) {
value |= UCNV_EXT_FROM_U_GOOD_ONE_WAY_FLAG ;
}
if ( m -> uLen == 1 ) {
u16Length = U16_LENGTH ( m -> u ) ;
}
else {
u16Length = U16_LENGTH ( UCM_GET_CODE_POINTS ( table , m ) [ 0 ] ) + ( m -> uLen - 2 ) ;
}
if ( u16Length > extData -> maxInUChars ) {
extData -> maxInUChars = u16Length ;
}
if ( m -> bLen > extData -> maxOutBytes ) {
extData -> maxOutBytes = m -> bLen ;
}
ratio = ( m -> bLen + ( u16Length - 1 ) ) / u16Length ;
if ( ratio > extData -> maxBytesPerUChar ) {
extData -> maxBytesPerUChar = ratio ;
}
return value ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
char op_volatile ( Oid opno ) {
RegProcedure funcid = get_opcode ( opno ) ;
if ( funcid == ( RegProcedure ) InvalidOid ) elog ( ERROR , "operator %u does not exist" , opno ) ;
return func_volatile ( ( Oid ) funcid ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IN_PROC_BROWSER_TEST_F ( ChooserDialogViewTest , Accept ) {
EXPECT_CALL ( * mock_chooser_controller_ , Select ( testing : : _ ) ) . Times ( 1 ) ;
chooser_dialog_view_ -> Accept ( ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void add_range ( fz_context * ctx , pdf_cmap * cmap , unsigned int low , unsigned int high , unsigned int out , int check_for_overlap , int many ) {
int current ;
cmap_splay * tree ;
if ( low > high ) {
fz_warn ( ctx , "range limits out of range in cmap %s" , cmap -> cmap_name ) ;
return ;
}
tree = cmap -> tree ;
if ( cmap -> tlen ) {
unsigned int move = cmap -> ttop ;
unsigned int gt = EMPTY ;
unsigned int lt = EMPTY ;
if ( check_for_overlap ) {
do {
current = move ;
if ( low <= tree [ current ] . low && tree [ current ] . low <= high ) {
tree [ current ] . out += high + 1 - tree [ current ] . low ;
tree [ current ] . low = high + 1 ;
if ( tree [ current ] . low > tree [ current ] . high ) {
move = delete_node ( cmap , current ) ;
current = EMPTY ;
continue ;
}
}
else if ( low <= tree [ current ] . high && tree [ current ] . high <= high ) {
tree [ current ] . high = low - 1 ;
assert ( tree [ current ] . low <= tree [ current ] . high ) ;
}
else if ( tree [ current ] . low < low && high < tree [ current ] . high ) {
int new_high = tree [ current ] . high ;
tree [ current ] . high = low - 1 ;
add_range ( ctx , cmap , high + 1 , new_high , tree [ current ] . out + high + 1 - tree [ current ] . low , 0 , many ) ;
}
if ( tree [ current ] . low > high ) {
move = tree [ current ] . left ;
gt = current ;
}
else {
move = tree [ current ] . right ;
lt = current ;
}
}
while ( move != EMPTY ) ;
}
else {
do {
current = move ;
if ( tree [ current ] . low > high ) {
move = tree [ current ] . left ;
gt = current ;
}
else {
move = tree [ current ] . right ;
lt = current ;
}
}
while ( move != EMPTY ) ;
}
if ( ! many ) {
if ( lt != EMPTY && ! tree [ lt ] . many && tree [ lt ] . high == low - 1 && tree [ lt ] . out - tree [ lt ] . low == out - low ) {
tree [ lt ] . high = high ;
if ( gt != EMPTY && ! tree [ gt ] . many && tree [ gt ] . low == high + 1 && tree [ gt ] . out - tree [ gt ] . low == out - low ) {
tree [ lt ] . high = tree [ gt ] . high ;
delete_node ( cmap , gt ) ;
}
goto exit ;
}
if ( gt != EMPTY && ! tree [ gt ] . many && tree [ gt ] . low == high + 1 && tree [ gt ] . out - tree [ gt ] . low == out - low ) {
tree [ gt ] . low = low ;
tree [ gt ] . out = out ;
goto exit ;
}
}
}
else current = EMPTY ;
if ( cmap -> tlen == cmap -> tcap ) {
int new_cap = cmap -> tcap ? cmap -> tcap * 2 : 256 ;
tree = cmap -> tree = fz_resize_array ( ctx , cmap -> tree , new_cap , sizeof * cmap -> tree ) ;
cmap -> tcap = new_cap ;
}
tree [ cmap -> tlen ] . low = low ;
tree [ cmap -> tlen ] . high = high ;
tree [ cmap -> tlen ] . out = out ;
tree [ cmap -> tlen ] . parent = current ;
tree [ cmap -> tlen ] . left = EMPTY ;
tree [ cmap -> tlen ] . right = EMPTY ;
tree [ cmap -> tlen ] . many = many ;
cmap -> tlen ++ ;
if ( current == EMPTY ) cmap -> ttop = 0 ;
else if ( tree [ current ] . low > high ) tree [ current ] . left = cmap -> tlen - 1 ;
else {
assert ( tree [ current ] . high < low ) ;
tree [ current ] . right = cmap -> tlen - 1 ;
}
move_to_root ( tree , cmap -> tlen - 1 ) ;
cmap -> ttop = cmap -> tlen - 1 ;
exit : {
}
# ifdef CHECK_SPLAY check_splay ( cmap -> tree , cmap -> ttop , 0 ) ;
# endif # ifdef DUMP_SPLAY dump_splay ( cmap -> tree , cmap -> ttop , 0 , "" ) ;
# endif }
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int register_interfaces ( extcap_parameters * extcap_conf , const char * adb_server_ip , unsigned short * adb_server_tcp_port ) {
static char packet [ PACKET_LENGTH ] ;
static char helpful_packet [ PACKET_LENGTH ] ;
char * response ;
char * device_list ;
gssize data_length ;
gssize device_length ;
socket_handle_t sock ;
const char * adb_transport_serial_templace = "%04x" "host:transport:%s" ;
const char * adb_check_port_templace = "%04x" "shell:cat /proc/%set/tcp" ;
const char * adb_devices = "000E" "host:devices-l" ;
const char * adb_api_level = "0022" "shell:getprop ro.build.version.sdk" ;
const char * adb_hcidump_version = "0017" "shell:hcidump --version" ;
const char * adb_ps_droid_bluetooth = "0018" "shell:ps droid.bluetooth" ;
const char * adb_ps_bluetooth_app = "001E" "shell:ps com.android.bluetooth" ;
const char * adb_tcpdump_help = "0010" "shell:tcpdump -h" ;
char serial_number [ SERIAL_NUMBER_LENGTH_MAX ] ;
size_t serial_number_length ;
char model_name [ MODEL_NAME_LENGTH_MAX ] ;
int result ;
char * pos ;
char * i_pos ;
char * model_pos ;
char * device_pos ;
char * prev_pos ;
int api_level ;
int disable_interface ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) return EXIT_CODE_INVALID_SOCKET_INTERFACES_LIST ;
device_list = adb_send_and_receive ( sock , adb_devices , packet , sizeof ( packet ) , & device_length ) ;
closesocket ( sock ) ;
if ( ! device_list ) {
errmsg_print ( "ERROR: Cannot get list of interfaces from devices" ) ;
return EXIT_CODE_CANNOT_GET_INTERFACES_LIST ;
}
device_list [ device_length ] = '\0' ;
pos = ( char * ) device_list ;
while ( pos < ( char * ) ( device_list + device_length ) ) {
prev_pos = pos ;
pos = strchr ( pos , ' ' ) ;
i_pos = pos ;
result = ( int ) ( pos - prev_pos ) ;
pos = strchr ( pos , '\n' ) + 1 ;
if ( result >= ( int ) sizeof ( serial_number ) ) {
verbose_print ( "WARNING: Serial number too long, ignore device\n" ) ;
continue ;
}
memcpy ( serial_number , prev_pos , result ) ;
serial_number [ result ] = '\0' ;
serial_number_length = strlen ( serial_number ) ;
model_name [ 0 ] = '\0' ;
model_pos = g_strstr_len ( i_pos , pos - i_pos , "model:" ) ;
if ( model_pos ) {
device_pos = g_strstr_len ( i_pos , pos - i_pos , "device:" ) ;
if ( device_pos && device_pos - model_pos - 6 - 1 < MODEL_NAME_LENGTH_MAX ) {
memcpy ( model_name , model_pos + 6 , device_pos - model_pos - 6 - 1 ) ;
model_name [ device_pos - model_pos - 6 - 1 ] = '\0' ;
}
}
if ( model_name [ 0 ] == '\0' ) strcpy ( model_name , "unknown" ) ;
verbose_print ( "VERBOSE: Processing device: \"%s\" <%s>\n" , serial_number , model_name ) ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) continue ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet for transport" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_1 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
verbose_print ( "WARNING: Error while setting adb transport for <%s>\n" , helpful_packet ) ;
closesocket ( sock ) ;
}
else {
response = adb_send_and_read ( sock , adb_tcpdump_help , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( response ) {
response [ data_length ] = '\0' ;
if ( strstr ( response , "tcpdump version" ) ) {
new_interface ( extcap_conf , INTERFACE_ANDROID_WIFI_TCPDUMP , model_name , serial_number , "Android WiFi" ) ;
}
}
else {
verbose_print ( "WARNING: Error on socket: <%s>\n" , helpful_packet ) ;
}
}
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) continue ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_2 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
verbose_print ( "WARNING: Error while setting adb transport for <%s>\n" , helpful_packet ) ;
closesocket ( sock ) ;
continue ;
}
response = adb_send_and_read ( sock , adb_api_level , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( ! response ) {
verbose_print ( "WARNING: Error on socket: <%s>\n" , helpful_packet ) ;
continue ;
}
response [ data_length ] = '\0' ;
api_level = ( int ) g_ascii_strtoll ( response , NULL , 10 ) ;
verbose_print ( "VERBOSE: Android API Level for %s is %i\n" , serial_number , api_level ) ;
if ( api_level < 21 ) {
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_MAIN , model_name , serial_number , "Android Logcat Main" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_SYSTEM , model_name , serial_number , "Android Logcat System" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_RADIO , model_name , serial_number , "Android Logcat Radio" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_EVENTS , model_name , serial_number , "Android Logcat Events" ) ;
}
else {
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_TEXT_MAIN , model_name , serial_number , "Android Logcat Main" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_TEXT_SYSTEM , model_name , serial_number , "Android Logcat System" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_TEXT_RADIO , model_name , serial_number , "Android Logcat Radio" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_TEXT_EVENTS , model_name , serial_number , "Android Logcat Events" ) ;
new_interface ( extcap_conf , INTERFACE_ANDROID_LOGCAT_TEXT_CRASH , model_name , serial_number , "Android Logcat Crash" ) ;
}
if ( api_level >= 5 && api_level < 17 ) {
disable_interface = 0 ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) continue ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_3 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport for <%s>" , helpful_packet ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
response = adb_send_and_read ( sock , adb_hcidump_version , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( ! response || data_length < 1 ) {
verbose_print ( "WARNING: Error while getting hcidump version by <%s> (%p len=%" G_GSSIZE_FORMAT ")\n" , adb_hcidump_version , ( void * ) response , data_length ) ;
verbose_print ( "VERBOSE: Android hcidump version for %s is unknown\n" , serial_number ) ;
disable_interface = 1 ;
}
else {
response [ data_length ] = '\0' ;
if ( g_ascii_strtoull ( response , NULL , 10 ) == 0 ) {
verbose_print ( "VERBOSE: Android hcidump version for %s is unknown\n" , serial_number ) ;
disable_interface = 1 ;
}
else {
verbose_print ( "VERBOSE: Android hcidump version for %s is %s\n" , serial_number , response ) ;
}
}
if ( ! disable_interface ) {
new_interface ( extcap_conf , INTERFACE_ANDROID_BLUETOOTH_HCIDUMP , model_name , serial_number , "Android Bluetooth Hcidump" ) ;
}
}
if ( api_level >= 17 && api_level < 21 ) {
disable_interface = 0 ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) continue ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_4 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport for <%s>" , helpful_packet ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
response = adb_send_and_read ( sock , adb_ps_droid_bluetooth , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( ! response || data_length < 1 ) {
verbose_print ( "WARNING: Error while getting Bluetooth application process id by <%s> " "(%p len=%" G_GSSIZE_FORMAT ")\n" , adb_hcidump_version , ( void * ) response , data_length ) ;
verbose_print ( "VERBOSE: Android Bluetooth application PID for %s is unknown\n" , serial_number ) ;
disable_interface = 1 ;
}
else {
char * data_str ;
char pid [ 16 ] ;
memset ( pid , 0 , sizeof ( pid ) ) ;
response [ data_length ] = '\0' ;
data_str = strchr ( response , '\n' ) ;
if ( data_str && sscanf ( data_str , "%*s %s" , pid ) == 1 ) {
verbose_print ( "VERBOSE: Android Bluetooth application PID for %s is %s\n" , serial_number , pid ) ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) return EXIT_CODE_INVALID_SOCKET_1 ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_5 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport for <%s>" , helpful_packet ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_check_port_templace , strlen ( adb_check_port_templace ) - 6 + strlen ( pid ) , pid ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_6 ;
}
response = adb_send_and_read ( sock , helpful_packet , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( ! response ) {
disable_interface = 1 ;
}
else {
response [ data_length ] = '\0' ;
data_str = strchr ( response , '\n' ) ;
if ( data_str && sscanf ( data_str , "%*s %s" , pid ) == 1 && strcmp ( pid + 9 , "10EA" ) == 0 ) {
verbose_print ( "VERBOSE: Bluedroid External Parser Port for %s is %s\n" , serial_number , pid + 9 ) ;
}
else {
disable_interface = 1 ;
verbose_print ( "VERBOSE: Bluedroid External Parser Port for %s is unknown\n" , serial_number ) ;
}
}
}
else {
disable_interface = 1 ;
verbose_print ( "VERBOSE: Android Bluetooth application PID for %s is unknown\n" , serial_number ) ;
}
}
if ( ! disable_interface ) {
new_interface ( extcap_conf , INTERFACE_ANDROID_BLUETOOTH_EXTERNAL_PARSER , model_name , serial_number , "Android Bluetooth External Parser" ) ;
}
}
if ( api_level >= 21 ) {
disable_interface = 0 ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) continue ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_7 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport for <%s>" , helpful_packet ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
if ( api_level >= 23 ) {
response = adb_send_and_read ( sock , adb_ps_bluetooth_app , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
}
else response = adb_send_and_read ( sock , adb_ps_droid_bluetooth , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( ! response || data_length < 1 ) {
verbose_print ( "WARNING: Error while getting Bluetooth application process id by <%s> " "(%p len=%" G_GSSIZE_FORMAT ")\n" , adb_hcidump_version , ( void * ) response , data_length ) ;
verbose_print ( "VERBOSE: Android Bluetooth application PID for %s is unknown\n" , serial_number ) ;
disable_interface = 1 ;
}
else {
char * data_str ;
char pid [ 16 ] ;
memset ( pid , 0 , sizeof ( pid ) ) ;
response [ data_length ] = '\0' ;
data_str = strchr ( response , '\n' ) ;
if ( data_str && sscanf ( data_str , "%*s %s" , pid ) == 1 ) {
verbose_print ( "VERBOSE: Android Bluetooth application PID for %s is %s\n" , serial_number , pid ) ;
sock = adb_connect ( adb_server_ip , adb_server_tcp_port ) ;
if ( sock == INVALID_SOCKET ) return EXIT_CODE_INVALID_SOCKET_2 ;
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_transport_serial_templace , 15 + serial_number_length , serial_number ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_8 ;
}
result = adb_send ( sock , helpful_packet ) ;
if ( result ) {
errmsg_print ( "ERROR: Error while setting adb transport for <%s>" , helpful_packet ) ;
closesocket ( sock ) ;
return EXIT_CODE_GENERIC ;
}
result = g_snprintf ( ( char * ) helpful_packet , PACKET_LENGTH , adb_check_port_templace , strlen ( adb_check_port_templace ) - 6 + strlen ( pid ) , pid ) ;
if ( result <= 0 || result > PACKET_LENGTH ) {
errmsg_print ( "ERROR: Error while completing adb packet" ) ;
closesocket ( sock ) ;
return EXIT_CODE_BAD_SIZE_OF_ASSEMBLED_ADB_PACKET_9 ;
}
response = adb_send_and_read ( sock , helpful_packet , helpful_packet , sizeof ( helpful_packet ) , & data_length ) ;
closesocket ( sock ) ;
if ( ! response ) {
disable_interface = 1 ;
}
else {
response [ data_length ] = '\0' ;
data_str = strchr ( response , '\n' ) ;
if ( data_str && sscanf ( data_str , "%*s %s" , pid ) == 1 && strcmp ( pid + 9 , "22A8" ) == 0 ) {
verbose_print ( "VERBOSE: Btsnoop Net Port for %s is %s\n" , serial_number , pid + 9 ) ;
}
else {
disable_interface = 1 ;
verbose_print ( "VERBOSE: Btsnoop Net Port for %s is unknown\n" , serial_number ) ;
}
}
}
else {
disable_interface = 1 ;
verbose_print ( "VERBOSE: Android Bluetooth application PID for %s is unknown\n" , serial_number ) ;
}
}
if ( ! disable_interface ) {
new_interface ( extcap_conf , INTERFACE_ANDROID_BLUETOOTH_BTSNOOP_NET , model_name , serial_number , "Android Bluetooth Btsnoop Net" ) ;
}
}
}
return EXIT_CODE_SUCCESS ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dummy ( void ) {
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
IF_DEBUG ( static int main_mallocs = 0 ;
)
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static XHCIEPContext * xhci_alloc_epctx ( XHCIState * xhci , unsigned int slotid , unsigned int epid ) {
XHCIEPContext * epctx ;
epctx = g_new0 ( XHCIEPContext , 1 ) ;
epctx -> xhci = xhci ;
epctx -> slotid = slotid ;
epctx -> epid = epid ;
QTAILQ_INIT ( & epctx -> transfers ) ;
epctx -> kick_timer = timer_new_ns ( QEMU_CLOCK_VIRTUAL , xhci_ep_kick_timer , epctx ) ;
return epctx ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void at1_subband_synthesis ( AT1Ctx * q , AT1SUCtx * su , float * pOut ) {
float temp [ 256 ] ;
float iqmf_temp [ 512 + 46 ] ;
ff_atrac_iqmf ( q -> bands [ 0 ] , q -> bands [ 1 ] , 128 , temp , su -> fst_qmf_delay , iqmf_temp ) ;
memcpy ( su -> last_qmf_delay , & su -> last_qmf_delay [ 256 ] , sizeof ( float ) * 23 ) ;
memcpy ( & su -> last_qmf_delay [ 23 ] , q -> bands [ 2 ] , sizeof ( float ) * 256 ) ;
ff_atrac_iqmf ( temp , su -> last_qmf_delay , 256 , pOut , su -> snd_qmf_delay , iqmf_temp ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static ossl_inline t2 * sk_ ## t1 ## _value ( const STACK_OF ( t1 ) * sk , int idx ) {
return ( t2 * ) OPENSSL_sk_value ( ( const OPENSSL_STACK * ) sk , idx ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new ( sk_ ## t1 ## _compfunc compare ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new ( ( OPENSSL_sk_compfunc ) compare ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_null ( void ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_null ( ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _new_reserve ( sk_ ## t1 ## _compfunc compare , int n ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_new_reserve ( ( OPENSSL_sk_compfunc ) compare , n ) ;
}
static ossl_inline int sk_ ## t1 ## _reserve ( STACK_OF ( t1 ) * sk , int n ) {
return OPENSSL_sk_reserve ( ( OPENSSL_STACK * ) sk , n ) ;
}
static ossl_inline void sk_ ## t1 ## _free ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_free ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _zero ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_zero ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete ( STACK_OF ( t1 ) * sk , int i ) {
return ( t2 * ) OPENSSL_sk_delete ( ( OPENSSL_STACK * ) sk , i ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _delete_ptr ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_delete_ptr ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _push ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_push ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _unshift ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_unshift ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) {
return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) {
OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) {
return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ;
}
static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) {
return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) {
return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ;
}
static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) {
OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ;
}
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
virLogPriority virLogGetDefaultPriority ( void ) {
return virLogDefaultPriority ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int raw_decode ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
const AVPixFmtDescriptor * desc = av_pix_fmt_desc_get ( avctx -> pix_fmt ) ;
RawVideoContext * context = avctx -> priv_data ;
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
int res ;
AVFrame * frame = data ;
AVPicture * picture = data ;
frame -> pict_type = avctx -> coded_frame -> pict_type ;
frame -> interlaced_frame = avctx -> coded_frame -> interlaced_frame ;
frame -> top_field_first = avctx -> coded_frame -> top_field_first ;
frame -> reordered_opaque = avctx -> reordered_opaque ;
frame -> pkt_pts = avctx -> pkt -> pts ;
if ( buf_size < context -> length - ( avctx -> pix_fmt == AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0 ) ) return - 1 ;
if ( context -> buffer ) {
int i ;
uint8_t * dst = context -> buffer ;
buf_size = context -> length - AVPALETTE_SIZE ;
if ( avctx -> bits_per_coded_sample == 4 ) {
for ( i = 0 ;
2 * i + 1 < buf_size ;
i ++ ) {
dst [ 2 * i + 0 ] = buf [ i ] >> 4 ;
dst [ 2 * i + 1 ] = buf [ i ] & 15 ;
}
}
else {
for ( i = 0 ;
4 * i + 3 < buf_size ;
i ++ ) {
dst [ 4 * i + 0 ] = buf [ i ] >> 6 ;
dst [ 4 * i + 1 ] = buf [ i ] >> 4 & 3 ;
dst [ 4 * i + 2 ] = buf [ i ] >> 2 & 3 ;
dst [ 4 * i + 3 ] = buf [ i ] & 3 ;
}
}
buf = dst ;
}
if ( avctx -> codec_tag == MKTAG ( 'A' , 'V' , '1' , 'x' ) || avctx -> codec_tag == MKTAG ( 'A' , 'V' , 'u' , 'p' ) ) buf += buf_size - context -> length ;
if ( ( res = avpicture_fill ( picture , buf , avctx -> pix_fmt , avctx -> width , avctx -> height ) ) < 0 ) return res ;
if ( ( avctx -> pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context -> length ) || ( desc -> flags & PIX_FMT_PSEUDOPAL ) ) {
frame -> data [ 1 ] = context -> palette ;
}
if ( avctx -> pix_fmt == AV_PIX_FMT_PAL8 ) {
const uint8_t * pal = av_packet_get_side_data ( avpkt , AV_PKT_DATA_PALETTE , NULL ) ;
if ( pal ) {
memcpy ( frame -> data [ 1 ] , pal , AVPALETTE_SIZE ) ;
frame -> palette_has_changed = 1 ;
}
}
if ( avctx -> pix_fmt == AV_PIX_FMT_BGR24 && ( ( frame -> linesize [ 0 ] + 3 ) & ~ 3 ) * avctx -> height <= buf_size ) frame -> linesize [ 0 ] = ( frame -> linesize [ 0 ] + 3 ) & ~ 3 ;
if ( context -> flip ) flip ( avctx , picture ) ;
if ( avctx -> codec_tag == MKTAG ( 'Y' , 'V' , '1' , '2' ) || avctx -> codec_tag == MKTAG ( 'Y' , 'V' , '1' , '6' ) || avctx -> codec_tag == MKTAG ( 'Y' , 'V' , '2' , '4' ) || avctx -> codec_tag == MKTAG ( 'Y' , 'V' , 'U' , '9' ) ) FFSWAP ( uint8_t * , picture -> data [ 1 ] , picture -> data [ 2 ] ) ;
if ( avctx -> codec_tag == AV_RL32 ( "yuv2" ) && avctx -> pix_fmt == AV_PIX_FMT_YUYV422 ) {
int x , y ;
uint8_t * line = picture -> data [ 0 ] ;
for ( y = 0 ;
y < avctx -> height ;
y ++ ) {
for ( x = 0 ;
x < avctx -> width ;
x ++ ) line [ 2 * x + 1 ] ^= 0x80 ;
line += picture -> linesize [ 0 ] ;
}
}
* got_frame = 1 ;
return buf_size ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int get_aq_c_strength ( int q_index ) {
int base_quant = vp9_ac_quant ( q_index , 0 ) / 4 ;
return ( base_quant > 20 ) + ( base_quant > 45 ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void bug31418_impl ( ) {
MYSQL con ;
my_bool is_null ;
int rc = 0 ;
DIE_UNLESS ( mysql_client_init ( & con ) ) ;
DIE_UNLESS ( mysql_real_connect ( & con , opt_host , opt_user , opt_password , opt_db ? opt_db : "test" , opt_port , opt_unix_socket , CLIENT_FOUND_ROWS ) ) ;
is_null = query_int_variable ( & con , "IS_FREE_LOCK('bug31418')" , & rc ) ;
DIE_UNLESS ( ! is_null && rc ) ;
is_null = query_int_variable ( & con , "IS_USED_LOCK('bug31418')" , & rc ) ;
DIE_UNLESS ( is_null ) ;
query_int_variable ( & con , "GET_LOCK('bug31418', 1)" , & rc ) ;
DIE_UNLESS ( rc ) ;
is_null = query_int_variable ( & con , "IS_FREE_LOCK('bug31418')" , & rc ) ;
DIE_UNLESS ( ! is_null && ! rc ) ;
is_null = query_int_variable ( & con , "IS_USED_LOCK('bug31418')" , & rc ) ;
DIE_UNLESS ( ! is_null && rc ) ;
bug20023_change_user ( & con ) ;
is_null = query_int_variable ( & con , "IS_FREE_LOCK('bug31418')" , & rc ) ;
DIE_UNLESS ( ! is_null && rc ) ;
is_null = query_int_variable ( & con , "IS_USED_LOCK('bug31418')" , & rc ) ;
DIE_UNLESS ( is_null ) ;
mysql_close ( & con ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void fill_decode_caches ( H264Context * h , int mb_type ) {
int topleft_xy , top_xy , topright_xy , left_xy [ LEFT_MBS ] ;
int topleft_type , top_type , topright_type , left_type [ LEFT_MBS ] ;
const uint8_t * left_block = h -> left_block ;
int i ;
uint8_t * nnz ;
uint8_t * nnz_cache ;
topleft_xy = h -> topleft_mb_xy ;
top_xy = h -> top_mb_xy ;
topright_xy = h -> topright_mb_xy ;
left_xy [ LTOP ] = h -> left_mb_xy [ LTOP ] ;
left_xy [ LBOT ] = h -> left_mb_xy [ LBOT ] ;
topleft_type = h -> topleft_type ;
top_type = h -> top_type ;
topright_type = h -> topright_type ;
left_type [ LTOP ] = h -> left_type [ LTOP ] ;
left_type [ LBOT ] = h -> left_type [ LBOT ] ;
if ( ! IS_SKIP ( mb_type ) ) {
if ( IS_INTRA ( mb_type ) ) {
int type_mask = h -> pps . constrained_intra_pred ? IS_INTRA ( - 1 ) : - 1 ;
h -> topleft_samples_available = h -> top_samples_available = h -> left_samples_available = 0xFFFF ;
h -> topright_samples_available = 0xEEEA ;
if ( ! ( top_type & type_mask ) ) {
h -> topleft_samples_available = 0xB3FF ;
h -> top_samples_available = 0x33FF ;
h -> topright_samples_available = 0x26EA ;
}
if ( IS_INTERLACED ( mb_type ) != IS_INTERLACED ( left_type [ LTOP ] ) ) {
if ( IS_INTERLACED ( mb_type ) ) {
if ( ! ( left_type [ LTOP ] & type_mask ) ) {
h -> topleft_samples_available &= 0xDFFF ;
h -> left_samples_available &= 0x5FFF ;
}
if ( ! ( left_type [ LBOT ] & type_mask ) ) {
h -> topleft_samples_available &= 0xFF5F ;
h -> left_samples_available &= 0xFF5F ;
}
}
else {
int left_typei = h -> cur_pic . f . mb_type [ left_xy [ LTOP ] + h -> mb_stride ] ;
assert ( left_xy [ LTOP ] == left_xy [ LBOT ] ) ;
if ( ! ( ( left_typei & type_mask ) && ( left_type [ LTOP ] & type_mask ) ) ) {
h -> topleft_samples_available &= 0xDF5F ;
h -> left_samples_available &= 0x5F5F ;
}
}
}
else {
if ( ! ( left_type [ LTOP ] & type_mask ) ) {
h -> topleft_samples_available &= 0xDF5F ;
h -> left_samples_available &= 0x5F5F ;
}
}
if ( ! ( topleft_type & type_mask ) ) h -> topleft_samples_available &= 0x7FFF ;
if ( ! ( topright_type & type_mask ) ) h -> topright_samples_available &= 0xFBFF ;
if ( IS_INTRA4x4 ( mb_type ) ) {
if ( IS_INTRA4x4 ( top_type ) ) {
AV_COPY32 ( h -> intra4x4_pred_mode_cache + 4 + 8 * 0 , h -> intra4x4_pred_mode + h -> mb2br_xy [ top_xy ] ) ;
}
else {
h -> intra4x4_pred_mode_cache [ 4 + 8 * 0 ] = h -> intra4x4_pred_mode_cache [ 5 + 8 * 0 ] = h -> intra4x4_pred_mode_cache [ 6 + 8 * 0 ] = h -> intra4x4_pred_mode_cache [ 7 + 8 * 0 ] = 2 - 3 * ! ( top_type & type_mask ) ;
}
for ( i = 0 ;
i < 2 ;
i ++ ) {
if ( IS_INTRA4x4 ( left_type [ LEFT ( i ) ] ) ) {
int8_t * mode = h -> intra4x4_pred_mode + h -> mb2br_xy [ left_xy [ LEFT ( i ) ] ] ;
h -> intra4x4_pred_mode_cache [ 3 + 8 * 1 + 2 * 8 * i ] = mode [ 6 - left_block [ 0 + 2 * i ] ] ;
h -> intra4x4_pred_mode_cache [ 3 + 8 * 2 + 2 * 8 * i ] = mode [ 6 - left_block [ 1 + 2 * i ] ] ;
}
else {
h -> intra4x4_pred_mode_cache [ 3 + 8 * 1 + 2 * 8 * i ] = h -> intra4x4_pred_mode_cache [ 3 + 8 * 2 + 2 * 8 * i ] = 2 - 3 * ! ( left_type [ LEFT ( i ) ] & type_mask ) ;
}
}
}
}
nnz_cache = h -> non_zero_count_cache ;
if ( top_type ) {
nnz = h -> non_zero_count [ top_xy ] ;
AV_COPY32 ( & nnz_cache [ 4 + 8 * 0 ] , & nnz [ 4 * 3 ] ) ;
if ( ! h -> chroma_y_shift ) {
AV_COPY32 ( & nnz_cache [ 4 + 8 * 5 ] , & nnz [ 4 * 7 ] ) ;
AV_COPY32 ( & nnz_cache [ 4 + 8 * 10 ] , & nnz [ 4 * 11 ] ) ;
}
else {
AV_COPY32 ( & nnz_cache [ 4 + 8 * 5 ] , & nnz [ 4 * 5 ] ) ;
AV_COPY32 ( & nnz_cache [ 4 + 8 * 10 ] , & nnz [ 4 * 9 ] ) ;
}
}
else {
uint32_t top_empty = CABAC && ! IS_INTRA ( mb_type ) ? 0 : 0x40404040 ;
AV_WN32A ( & nnz_cache [ 4 + 8 * 0 ] , top_empty ) ;
AV_WN32A ( & nnz_cache [ 4 + 8 * 5 ] , top_empty ) ;
AV_WN32A ( & nnz_cache [ 4 + 8 * 10 ] , top_empty ) ;
}
for ( i = 0 ;
i < 2 ;
i ++ ) {
if ( left_type [ LEFT ( i ) ] ) {
nnz = h -> non_zero_count [ left_xy [ LEFT ( i ) ] ] ;
nnz_cache [ 3 + 8 * 1 + 2 * 8 * i ] = nnz [ left_block [ 8 + 0 + 2 * i ] ] ;
nnz_cache [ 3 + 8 * 2 + 2 * 8 * i ] = nnz [ left_block [ 8 + 1 + 2 * i ] ] ;
if ( CHROMA444 ) {
nnz_cache [ 3 + 8 * 6 + 2 * 8 * i ] = nnz [ left_block [ 8 + 0 + 2 * i ] + 4 * 4 ] ;
nnz_cache [ 3 + 8 * 7 + 2 * 8 * i ] = nnz [ left_block [ 8 + 1 + 2 * i ] + 4 * 4 ] ;
nnz_cache [ 3 + 8 * 11 + 2 * 8 * i ] = nnz [ left_block [ 8 + 0 + 2 * i ] + 8 * 4 ] ;
nnz_cache [ 3 + 8 * 12 + 2 * 8 * i ] = nnz [ left_block [ 8 + 1 + 2 * i ] + 8 * 4 ] ;
}
else if ( CHROMA422 ) {
nnz_cache [ 3 + 8 * 6 + 2 * 8 * i ] = nnz [ left_block [ 8 + 0 + 2 * i ] - 2 + 4 * 4 ] ;
nnz_cache [ 3 + 8 * 7 + 2 * 8 * i ] = nnz [ left_block [ 8 + 1 + 2 * i ] - 2 + 4 * 4 ] ;
nnz_cache [ 3 + 8 * 11 + 2 * 8 * i ] = nnz [ left_block [ 8 + 0 + 2 * i ] - 2 + 8 * 4 ] ;
nnz_cache [ 3 + 8 * 12 + 2 * 8 * i ] = nnz [ left_block [ 8 + 1 + 2 * i ] - 2 + 8 * 4 ] ;
}
else {
nnz_cache [ 3 + 8 * 6 + 8 * i ] = nnz [ left_block [ 8 + 4 + 2 * i ] ] ;
nnz_cache [ 3 + 8 * 11 + 8 * i ] = nnz [ left_block [ 8 + 5 + 2 * i ] ] ;
}
}
else {
nnz_cache [ 3 + 8 * 1 + 2 * 8 * i ] = nnz_cache [ 3 + 8 * 2 + 2 * 8 * i ] = nnz_cache [ 3 + 8 * 6 + 2 * 8 * i ] = nnz_cache [ 3 + 8 * 7 + 2 * 8 * i ] = nnz_cache [ 3 + 8 * 11 + 2 * 8 * i ] = nnz_cache [ 3 + 8 * 12 + 2 * 8 * i ] = CABAC && ! IS_INTRA ( mb_type ) ? 0 : 64 ;
}
}
if ( CABAC ) {
if ( top_type ) h -> top_cbp = h -> cbp_table [ top_xy ] ;
else h -> top_cbp = IS_INTRA ( mb_type ) ? 0x7CF : 0x00F ;
if ( left_type [ LTOP ] ) {
h -> left_cbp = ( h -> cbp_table [ left_xy [ LTOP ] ] & 0x7F0 ) | ( ( h -> cbp_table [ left_xy [ LTOP ] ] >> ( left_block [ 0 ] & ( ~ 1 ) ) ) & 2 ) | ( ( ( h -> cbp_table [ left_xy [ LBOT ] ] >> ( left_block [ 2 ] & ( ~ 1 ) ) ) & 2 ) << 2 ) ;
}
else {
h -> left_cbp = IS_INTRA ( mb_type ) ? 0x7CF : 0x00F ;
}
}
}
if ( IS_INTER ( mb_type ) || ( IS_DIRECT ( mb_type ) && h -> direct_spatial_mv_pred ) ) {
int list ;
int b_stride = h -> b_stride ;
for ( list = 0 ;
list < h -> list_count ;
list ++ ) {
int8_t * ref_cache = & h -> ref_cache [ list ] [ scan8 [ 0 ] ] ;
int8_t * ref = h -> cur_pic . f . ref_index [ list ] ;
int16_t ( * mv_cache ) [ 2 ] = & h -> mv_cache [ list ] [ scan8 [ 0 ] ] ;
int16_t ( * mv ) [ 2 ] = h -> cur_pic . f . motion_val [ list ] ;
if ( ! USES_LIST ( mb_type , list ) ) continue ;
assert ( ! ( IS_DIRECT ( mb_type ) && ! h -> direct_spatial_mv_pred ) ) ;
if ( USES_LIST ( top_type , list ) ) {
const int b_xy = h -> mb2b_xy [ top_xy ] + 3 * b_stride ;
AV_COPY128 ( mv_cache [ 0 - 1 * 8 ] , mv [ b_xy + 0 ] ) ;
ref_cache [ 0 - 1 * 8 ] = ref_cache [ 1 - 1 * 8 ] = ref [ 4 * top_xy + 2 ] ;
ref_cache [ 2 - 1 * 8 ] = ref_cache [ 3 - 1 * 8 ] = ref [ 4 * top_xy + 3 ] ;
}
else {
AV_ZERO128 ( mv_cache [ 0 - 1 * 8 ] ) ;
AV_WN32A ( & ref_cache [ 0 - 1 * 8 ] , ( ( top_type ? LIST_NOT_USED : PART_NOT_AVAILABLE ) & 0xFF ) * 0x01010101u ) ;
}
if ( mb_type & ( MB_TYPE_16x8 | MB_TYPE_8x8 ) ) {
for ( i = 0 ;
i < 2 ;
i ++ ) {
int cache_idx = - 1 + i * 2 * 8 ;
if ( USES_LIST ( left_type [ LEFT ( i ) ] , list ) ) {
const int b_xy = h -> mb2b_xy [ left_xy [ LEFT ( i ) ] ] + 3 ;
const int b8_xy = 4 * left_xy [ LEFT ( i ) ] + 1 ;
AV_COPY32 ( mv_cache [ cache_idx ] , mv [ b_xy + b_stride * left_block [ 0 + i * 2 ] ] ) ;
AV_COPY32 ( mv_cache [ cache_idx + 8 ] , mv [ b_xy + b_stride * left_block [ 1 + i * 2 ] ] ) ;
ref_cache [ cache_idx ] = ref [ b8_xy + ( left_block [ 0 + i * 2 ] & ~ 1 ) ] ;
ref_cache [ cache_idx + 8 ] = ref [ b8_xy + ( left_block [ 1 + i * 2 ] & ~ 1 ) ] ;
}
else {
AV_ZERO32 ( mv_cache [ cache_idx ] ) ;
AV_ZERO32 ( mv_cache [ cache_idx + 8 ] ) ;
ref_cache [ cache_idx ] = ref_cache [ cache_idx + 8 ] = ( left_type [ LEFT ( i ) ] ) ? LIST_NOT_USED : PART_NOT_AVAILABLE ;
}
}
}
else {
if ( USES_LIST ( left_type [ LTOP ] , list ) ) {
const int b_xy = h -> mb2b_xy [ left_xy [ LTOP ] ] + 3 ;
const int b8_xy = 4 * left_xy [ LTOP ] + 1 ;
AV_COPY32 ( mv_cache [ - 1 ] , mv [ b_xy + b_stride * left_block [ 0 ] ] ) ;
ref_cache [ - 1 ] = ref [ b8_xy + ( left_block [ 0 ] & ~ 1 ) ] ;
}
else {
AV_ZERO32 ( mv_cache [ - 1 ] ) ;
ref_cache [ - 1 ] = left_type [ LTOP ] ? LIST_NOT_USED : PART_NOT_AVAILABLE ;
}
}
if ( USES_LIST ( topright_type , list ) ) {
const int b_xy = h -> mb2b_xy [ topright_xy ] + 3 * b_stride ;
AV_COPY32 ( mv_cache [ 4 - 1 * 8 ] , mv [ b_xy ] ) ;
ref_cache [ 4 - 1 * 8 ] = ref [ 4 * topright_xy + 2 ] ;
}
else {
AV_ZERO32 ( mv_cache [ 4 - 1 * 8 ] ) ;
ref_cache [ 4 - 1 * 8 ] = topright_type ? LIST_NOT_USED : PART_NOT_AVAILABLE ;
}
if ( ref_cache [ 4 - 1 * 8 ] < 0 ) {
if ( USES_LIST ( topleft_type , list ) ) {
const int b_xy = h -> mb2b_xy [ topleft_xy ] + 3 + b_stride + ( h -> topleft_partition & 2 * b_stride ) ;
const int b8_xy = 4 * topleft_xy + 1 + ( h -> topleft_partition & 2 ) ;
AV_COPY32 ( mv_cache [ - 1 - 1 * 8 ] , mv [ b_xy ] ) ;
ref_cache [ - 1 - 1 * 8 ] = ref [ b8_xy ] ;
}
else {
AV_ZERO32 ( mv_cache [ - 1 - 1 * 8 ] ) ;
ref_cache [ - 1 - 1 * 8 ] = topleft_type ? LIST_NOT_USED : PART_NOT_AVAILABLE ;
}
}
if ( ( mb_type & ( MB_TYPE_SKIP | MB_TYPE_DIRECT2 ) ) && ! FRAME_MBAFF ) continue ;
if ( ! ( mb_type & ( MB_TYPE_SKIP | MB_TYPE_DIRECT2 ) ) ) {
uint8_t ( * mvd_cache ) [ 2 ] = & h -> mvd_cache [ list ] [ scan8 [ 0 ] ] ;
uint8_t ( * mvd ) [ 2 ] = h -> mvd_table [ list ] ;
ref_cache [ 2 + 8 * 0 ] = ref_cache [ 2 + 8 * 2 ] = PART_NOT_AVAILABLE ;
AV_ZERO32 ( mv_cache [ 2 + 8 * 0 ] ) ;
AV_ZERO32 ( mv_cache [ 2 + 8 * 2 ] ) ;
if ( CABAC ) {
if ( USES_LIST ( top_type , list ) ) {
const int b_xy = h -> mb2br_xy [ top_xy ] ;
AV_COPY64 ( mvd_cache [ 0 - 1 * 8 ] , mvd [ b_xy + 0 ] ) ;
}
else {
AV_ZERO64 ( mvd_cache [ 0 - 1 * 8 ] ) ;
}
if ( USES_LIST ( left_type [ LTOP ] , list ) ) {
const int b_xy = h -> mb2br_xy [ left_xy [ LTOP ] ] + 6 ;
AV_COPY16 ( mvd_cache [ - 1 + 0 * 8 ] , mvd [ b_xy - left_block [ 0 ] ] ) ;
AV_COPY16 ( mvd_cache [ - 1 + 1 * 8 ] , mvd [ b_xy - left_block [ 1 ] ] ) ;
}
else {
AV_ZERO16 ( mvd_cache [ - 1 + 0 * 8 ] ) ;
AV_ZERO16 ( mvd_cache [ - 1 + 1 * 8 ] ) ;
}
if ( USES_LIST ( left_type [ LBOT ] , list ) ) {
const int b_xy = h -> mb2br_xy [ left_xy [ LBOT ] ] + 6 ;
AV_COPY16 ( mvd_cache [ - 1 + 2 * 8 ] , mvd [ b_xy - left_block [ 2 ] ] ) ;
AV_COPY16 ( mvd_cache [ - 1 + 3 * 8 ] , mvd [ b_xy - left_block [ 3 ] ] ) ;
}
else {
AV_ZERO16 ( mvd_cache [ - 1 + 2 * 8 ] ) ;
AV_ZERO16 ( mvd_cache [ - 1 + 3 * 8 ] ) ;
}
AV_ZERO16 ( mvd_cache [ 2 + 8 * 0 ] ) ;
AV_ZERO16 ( mvd_cache [ 2 + 8 * 2 ] ) ;
if ( h -> slice_type_nos == AV_PICTURE_TYPE_B ) {
uint8_t * direct_cache = & h -> direct_cache [ scan8 [ 0 ] ] ;
uint8_t * direct_table = h -> direct_table ;
fill_rectangle ( direct_cache , 4 , 4 , 8 , MB_TYPE_16x16 >> 1 , 1 ) ;
if ( IS_DIRECT ( top_type ) ) {
AV_WN32A ( & direct_cache [ - 1 * 8 ] , 0x01010101u * ( MB_TYPE_DIRECT2 >> 1 ) ) ;
}
else if ( IS_8X8 ( top_type ) ) {
int b8_xy = 4 * top_xy ;
direct_cache [ 0 - 1 * 8 ] = direct_table [ b8_xy + 2 ] ;
direct_cache [ 2 - 1 * 8 ] = direct_table [ b8_xy + 3 ] ;
}
else {
AV_WN32A ( & direct_cache [ - 1 * 8 ] , 0x01010101 * ( MB_TYPE_16x16 >> 1 ) ) ;
}
if ( IS_DIRECT ( left_type [ LTOP ] ) ) direct_cache [ - 1 + 0 * 8 ] = MB_TYPE_DIRECT2 >> 1 ;
else if ( IS_8X8 ( left_type [ LTOP ] ) ) direct_cache [ - 1 + 0 * 8 ] = direct_table [ 4 * left_xy [ LTOP ] + 1 + ( left_block [ 0 ] & ~ 1 ) ] ;
else direct_cache [ - 1 + 0 * 8 ] = MB_TYPE_16x16 >> 1 ;
if ( IS_DIRECT ( left_type [ LBOT ] ) ) direct_cache [ - 1 + 2 * 8 ] = MB_TYPE_DIRECT2 >> 1 ;
else if ( IS_8X8 ( left_type [ LBOT ] ) ) direct_cache [ - 1 + 2 * 8 ] = direct_table [ 4 * left_xy [ LBOT ] + 1 + ( left_block [ 2 ] & ~ 1 ) ] ;
else direct_cache [ - 1 + 2 * 8 ] = MB_TYPE_16x16 >> 1 ;
}
}
}
# define MAP_MVS MAP_F2F ( scan8 [ 0 ] - 1 - 1 * 8 , topleft_type ) MAP_F2F ( scan8 [ 0 ] + 0 - 1 * 8 , top_type ) MAP_F2F ( scan8 [ 0 ] + 1 - 1 * 8 , top_type ) MAP_F2F ( scan8 [ 0 ] + 2 - 1 * 8 , top_type ) MAP_F2F ( scan8 [ 0 ] + 3 - 1 * 8 , top_type ) MAP_F2F ( scan8 [ 0 ] + 4 - 1 * 8 , topright_type ) MAP_F2F ( scan8 [ 0 ] - 1 + 0 * 8 , left_type [ LTOP ] ) MAP_F2F ( scan8 [ 0 ] - 1 + 1 * 8 , left_type [ LTOP ] ) MAP_F2F ( scan8 [ 0 ] - 1 + 2 * 8 , left_type [ LBOT ] ) MAP_F2F ( scan8 [ 0 ] - 1 + 3 * 8 , left_type [ LBOT ] ) if ( FRAME_MBAFF ) {
if ( MB_FIELD ) {
# define MAP_F2F ( idx , mb_type ) if ( ! IS_INTERLACED ( mb_type ) && h -> ref_cache [ list ] [ idx ] >= 0 ) {
h -> ref_cache [ list ] [ idx ] <<= 1 ;
h -> mv_cache [ list ] [ idx ] [ 1 ] /= 2 ;
h -> mvd_cache [ list ] [ idx ] [ 1 ] >>= 1 ;
}
MAP_MVS }
else {
# undef MAP_F2F # define MAP_F2F ( idx , mb_type ) if ( IS_INTERLACED ( mb_type ) && h -> ref_cache [ list ] [ idx ] >= 0 ) {
h -> ref_cache [ list ] [ idx ] >>= 1 ;
h -> mv_cache [ list ] [ idx ] [ 1 ] <<= 1 ;
h -> mvd_cache [ list ] [ idx ] [ 1 ] <<= 1 ;
}
MAP_MVS # undef MAP_F2F }
}
}
}
h -> neighbor_transform_size = ! ! IS_8x8DCT ( top_type ) + ! ! IS_8x8DCT ( left_type [ LTOP ] ) ;
}
| 1True
|
Categorize the following code snippet as vulnerable or not. True or False
|
TSReturnCode TSHttpHdrStatusSet ( TSMBuffer bufp , TSMLoc obj , TSHttpStatus status ) {
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_http_hdr_handle ( obj ) == TS_SUCCESS ) ;
if ( ! isWriteable ( bufp ) ) {
return TS_ERROR ;
}
HTTPHdr h ;
SET_HTTP_HDR ( h , bufp , obj ) ;
ink_assert ( h . m_http -> m_type == HDR_HEAP_OBJ_HTTP_HEADER ) ;
h . status_set ( ( HTTPStatus ) status ) ;
return TS_SUCCESS ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
const char * proto_field_display_to_string ( int field_display ) {
return val_to_str_const ( field_display , hf_display , "Unknown" ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int raw_decode ( char * packet , int len , struct query * q , int dns_fd , int tun_fd ) {
int raw_user ;
if ( len < RAW_HDR_LEN ) return 0 ;
if ( memcmp ( packet , raw_header , RAW_HDR_IDENT_LEN ) ) return 0 ;
raw_user = RAW_HDR_GET_USR ( packet ) ;
switch ( RAW_HDR_GET_CMD ( packet ) ) {
case RAW_HDR_CMD_LOGIN : handle_raw_login ( & packet [ RAW_HDR_LEN ] , len - RAW_HDR_LEN , q , dns_fd , raw_user ) ;
break ;
case RAW_HDR_CMD_DATA : handle_raw_data ( & packet [ RAW_HDR_LEN ] , len - RAW_HDR_LEN , q , dns_fd , tun_fd , raw_user ) ;
break ;
case RAW_HDR_CMD_PING : handle_raw_ping ( q , dns_fd , raw_user ) ;
break ;
default : warnx ( "Unhandled raw command %02X from user %d" , RAW_HDR_GET_CMD ( packet ) , raw_user ) ;
break ;
}
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t virtio_pci_config_readb ( void * opaque , uint32_t addr ) {
VirtIOPCIProxy * proxy = opaque ;
uint32_t config = VIRTIO_PCI_CONFIG ( & proxy -> pci_dev ) ;
addr -= proxy -> addr ;
if ( addr < config ) return virtio_ioport_read ( proxy , addr ) ;
addr -= config ;
return virtio_config_readb ( proxy -> vdev , addr ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
kadm5_ret_t kadm5_create_policy_internal ( void * server_handle , kadm5_policy_ent_t entry , long mask ) {
kadm5_server_handle_t handle = server_handle ;
osa_policy_ent_rec pent ;
int ret ;
char * p ;
CHECK_HANDLE ( server_handle ) ;
if ( ( entry == ( kadm5_policy_ent_t ) NULL ) || ( entry -> policy == NULL ) ) return EINVAL ;
if ( strlen ( entry -> policy ) == 0 ) return KADM5_BAD_POLICY ;
if ( ! ( mask & KADM5_POLICY ) ) return KADM5_BAD_MASK ;
if ( ( mask & KADM5_POLICY_ALLOWED_KEYSALTS ) && entry -> allowed_keysalts != NULL ) {
ret = validate_allowed_keysalts ( entry -> allowed_keysalts ) ;
if ( ret ) return ret ;
}
memset ( & pent , 0 , sizeof ( pent ) ) ;
pent . name = entry -> policy ;
p = entry -> policy ;
while ( * p != '\0' ) {
if ( * p < ' ' || * p > '~' ) return KADM5_BAD_POLICY ;
else p ++ ;
}
if ( ! ( mask & KADM5_PW_MAX_LIFE ) ) pent . pw_max_life = 0 ;
else pent . pw_max_life = entry -> pw_max_life ;
if ( ! ( mask & KADM5_PW_MIN_LIFE ) ) pent . pw_min_life = 0 ;
else {
if ( ( mask & KADM5_PW_MAX_LIFE ) ) {
if ( entry -> pw_min_life > entry -> pw_max_life && entry -> pw_max_life != 0 ) return KADM5_BAD_MIN_PASS_LIFE ;
}
pent . pw_min_life = entry -> pw_min_life ;
}
if ( ! ( mask & KADM5_PW_MIN_LENGTH ) ) pent . pw_min_length = MIN_PW_LENGTH ;
else {
if ( entry -> pw_min_length < MIN_PW_LENGTH ) return KADM5_BAD_LENGTH ;
pent . pw_min_length = entry -> pw_min_length ;
}
if ( ! ( mask & KADM5_PW_MIN_CLASSES ) ) pent . pw_min_classes = MIN_PW_CLASSES ;
else {
if ( entry -> pw_min_classes > MAX_PW_CLASSES || entry -> pw_min_classes < MIN_PW_CLASSES ) return KADM5_BAD_CLASS ;
pent . pw_min_classes = entry -> pw_min_classes ;
}
if ( ! ( mask & KADM5_PW_HISTORY_NUM ) ) pent . pw_history_num = MIN_PW_HISTORY ;
else {
if ( entry -> pw_history_num < MIN_PW_HISTORY ) return KADM5_BAD_HISTORY ;
else pent . pw_history_num = entry -> pw_history_num ;
}
if ( handle -> api_version >= KADM5_API_VERSION_4 ) {
if ( ! ( mask & KADM5_POLICY_ATTRIBUTES ) ) pent . attributes = 0 ;
else pent . attributes = entry -> attributes ;
if ( ! ( mask & KADM5_POLICY_MAX_LIFE ) ) pent . max_life = 0 ;
else pent . max_life = entry -> max_life ;
if ( ! ( mask & KADM5_POLICY_MAX_RLIFE ) ) pent . max_renewable_life = 0 ;
else pent . max_renewable_life = entry -> max_renewable_life ;
if ( ! ( mask & KADM5_POLICY_ALLOWED_KEYSALTS ) ) pent . allowed_keysalts = 0 ;
else pent . allowed_keysalts = entry -> allowed_keysalts ;
if ( ! ( mask & KADM5_POLICY_TL_DATA ) ) {
pent . n_tl_data = 0 ;
pent . tl_data = NULL ;
}
else {
pent . n_tl_data = entry -> n_tl_data ;
pent . tl_data = entry -> tl_data ;
}
}
if ( handle -> api_version >= KADM5_API_VERSION_3 ) {
if ( ! ( mask & KADM5_PW_MAX_FAILURE ) ) pent . pw_max_fail = 0 ;
else pent . pw_max_fail = entry -> pw_max_fail ;
if ( ! ( mask & KADM5_PW_FAILURE_COUNT_INTERVAL ) ) pent . pw_failcnt_interval = 0 ;
else pent . pw_failcnt_interval = entry -> pw_failcnt_interval ;
if ( ! ( mask & KADM5_PW_LOCKOUT_DURATION ) ) pent . pw_lockout_duration = 0 ;
else pent . pw_lockout_duration = entry -> pw_lockout_duration ;
}
if ( ( ret = krb5_db_create_policy ( handle -> context , & pent ) ) ) return ret ;
else return KADM5_OK ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void h245_setup_channels ( packet_info * pinfo , channel_info_t * upcoming_channel_lcl ) {
rtp_dyn_payload_t * rtp_dyn_payload = NULL ;
struct srtp_info * dummy_srtp_info = NULL ;
if ( ! upcoming_channel_lcl ) return ;
if ( ! strcmp ( upcoming_channel_lcl -> data_type_str , "t38fax" ) ) {
if ( upcoming_channel_lcl -> media_addr . addr . type != AT_NONE && upcoming_channel_lcl -> media_addr . port != 0 ) {
t38_add_address ( pinfo , & upcoming_channel_lcl -> media_addr . addr , upcoming_channel_lcl -> media_addr . port , 0 , "H245" , pinfo -> fd -> num ) ;
}
return ;
}
if ( upcoming_channel_lcl -> rfc2198 > 0 ) {
rtp_dyn_payload = rtp_dyn_payload_new ( ) ;
rtp_dyn_payload_insert ( rtp_dyn_payload , upcoming_channel_lcl -> rfc2198 , "red" , 8000 ) ;
}
if ( upcoming_channel_lcl -> srtp_flag ) {
dummy_srtp_info = wmem_new0 ( wmem_file_scope ( ) , struct srtp_info ) ;
}
if ( upcoming_channel_lcl -> media_addr . addr . type != AT_NONE && upcoming_channel_lcl -> media_addr . port != 0 ) {
srtp_add_address ( pinfo , & upcoming_channel_lcl -> media_addr . addr , upcoming_channel_lcl -> media_addr . port , 0 , "H245" , pinfo -> fd -> num , upcoming_channel_lcl -> is_video , rtp_dyn_payload , dummy_srtp_info ) ;
}
if ( upcoming_channel_lcl -> media_control_addr . addr . type != AT_NONE && upcoming_channel_lcl -> media_control_addr . port != 0 && rtcp_handle ) {
srtcp_add_address ( pinfo , & upcoming_channel_lcl -> media_control_addr . addr , upcoming_channel_lcl -> media_control_addr . port , 0 , "H245" , pinfo -> fd -> num , dummy_srtp_info ) ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
int kvm_device_pci_assign ( KVMState * s , PCIHostDeviceAddress * dev_addr , uint32_t flags , uint32_t * dev_id ) {
struct kvm_assigned_pci_dev dev_data = {
. segnr = dev_addr -> domain , . busnr = dev_addr -> bus , . devfn = PCI_DEVFN ( dev_addr -> slot , dev_addr -> function ) , . flags = flags , }
;
int ret ;
dev_data . assigned_dev_id = ( dev_addr -> domain << 16 ) | ( dev_addr -> bus << 8 ) | dev_data . devfn ;
ret = kvm_vm_ioctl ( s , KVM_ASSIGN_PCI_DEVICE , & dev_data ) ;
if ( ret < 0 ) {
return ret ;
}
* dev_id = dev_data . assigned_dev_id ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
mbfl_string * mbfl_mime_header_decode ( mbfl_string * string , mbfl_string * result , enum mbfl_no_encoding outcode ) {
int n ;
unsigned char * p ;
struct mime_header_decoder_data * pd ;
mbfl_string_init ( result ) ;
result -> no_language = string -> no_language ;
result -> no_encoding = outcode ;
pd = mime_header_decoder_new ( outcode ) ;
if ( pd == NULL ) {
return NULL ;
}
n = string -> len ;
p = string -> val ;
while ( n > 0 ) {
mime_header_decoder_collector ( * p ++ , pd ) ;
n -- ;
}
result = mime_header_decoder_result ( pd , result ) ;
mime_header_decoder_delete ( pd ) ;
return result ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
REGRESSION_TEST ( SDK_API_TSMgmtGet ) ( RegressionTest * test , int , int * pstatus ) {
const char * CONFIG_PARAM_COUNTER_NAME = "proxy.process.ssl.total_tickets_renewed" ;
int CONFIG_PARAM_COUNTER_VALUE = 0 ;
const char * CONFIG_PARAM_FLOAT_NAME = "proxy.config.http.background_fill_completed_threshold" ;
float CONFIG_PARAM_FLOAT_VALUE = 0.0 ;
const char * CONFIG_PARAM_INT_NAME = "proxy.config.http.cache.http" ;
int CONFIG_PARAM_INT_VALUE = 1 ;
const char * CONFIG_PARAM_STRING_NAME = "proxy.config.product_name" ;
const char * CONFIG_PARAM_STRING_VALUE = "Traffic Server" ;
* pstatus = REGRESSION_TEST_INPROGRESS ;
int err = 0 ;
TSMgmtCounter cvalue = 0 ;
TSMgmtFloat fvalue = 0.0 ;
TSMgmtInt ivalue = - 1 ;
TSMgmtString svalue = nullptr ;
if ( TS_SUCCESS != TSMgmtCounterGet ( CONFIG_PARAM_COUNTER_NAME , & cvalue ) ) {
SDK_RPRINT ( test , "TSMgmtCounterGet" , "TestCase1.1" , TC_FAIL , "can not get value of param %s" , CONFIG_PARAM_COUNTER_NAME ) ;
err = 1 ;
}
else if ( cvalue != CONFIG_PARAM_COUNTER_VALUE ) {
SDK_RPRINT ( test , "TSMgmtCounterGet" , "TestCase1.1" , TC_FAIL , "got incorrect value of param %s, should have been %d, found %d" , CONFIG_PARAM_COUNTER_NAME , CONFIG_PARAM_COUNTER_VALUE , cvalue ) ;
err = 1 ;
}
else {
SDK_RPRINT ( test , "TSMgmtCounterGet" , "TestCase1.1" , TC_PASS , "ok" ) ;
}
if ( ( TS_SUCCESS != TSMgmtFloatGet ( CONFIG_PARAM_FLOAT_NAME , & fvalue ) ) || ( fvalue != CONFIG_PARAM_FLOAT_VALUE ) ) {
SDK_RPRINT ( test , "TSMgmtFloatGet" , "TestCase2" , TC_FAIL , "can not get value of param %s" , CONFIG_PARAM_FLOAT_NAME ) ;
err = 1 ;
}
else {
SDK_RPRINT ( test , "TSMgmtFloatGet" , "TestCase1.2" , TC_PASS , "ok" ) ;
}
if ( ( TSMgmtIntGet ( CONFIG_PARAM_INT_NAME , & ivalue ) != TS_SUCCESS ) || ( ivalue != CONFIG_PARAM_INT_VALUE ) ) {
SDK_RPRINT ( test , "TSMgmtIntGet" , "TestCase1.3" , TC_FAIL , "can not get value of param %s" , CONFIG_PARAM_INT_NAME ) ;
err = 1 ;
}
else {
SDK_RPRINT ( test , "TSMgmtIntGet" , "TestCase1.3" , TC_PASS , "ok" ) ;
}
if ( TS_SUCCESS != TSMgmtStringGet ( CONFIG_PARAM_STRING_NAME , & svalue ) ) {
SDK_RPRINT ( test , "TSMgmtStringGet" , "TestCase1.4" , TC_FAIL , "can not get value of param %s" , CONFIG_PARAM_STRING_NAME ) ;
err = 1 ;
}
else if ( strcmp ( svalue , CONFIG_PARAM_STRING_VALUE ) != 0 ) {
SDK_RPRINT ( test , "TSMgmtStringGet" , "TestCase1.4" , TC_FAIL , R "(got incorrect value of param %s, should have been " % s ", found " % s ")" , CONFIG_PARAM_STRING_NAME , CONFIG_PARAM_STRING_VALUE , svalue ) ;
err = 1 ;
}
else {
SDK_RPRINT ( test , "TSMgmtStringGet" , "TestCase1.4" , TC_PASS , "ok" ) ;
}
if ( err ) {
* pstatus = REGRESSION_TEST_FAILED ;
return ;
}
* pstatus = REGRESSION_TEST_PASSED ;
SDK_RPRINT ( test , "TSMgmtGet" , "TestCase1" , TC_PASS , "ok" ) ;
return ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int mxpeg_decode_app ( MXpegDecodeContext * s , const uint8_t * buf_ptr , int buf_size ) {
int len ;
if ( buf_size < 2 ) return 0 ;
len = AV_RB16 ( buf_ptr ) ;
skip_bits ( & s -> jpg . gb , 8 * FFMIN ( len , buf_size ) ) ;
return 0 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void remove_tap_listener_isup_calls ( void ) {
remove_tap_listener ( & ( the_tapinfo_struct . isup_dummy ) ) ;
have_isup_tap_listener = FALSE ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static const char * qemuAgentStringifyErrorClass ( const char * klass ) {
if ( STREQ_NULLABLE ( klass , "BufferOverrun" ) ) return "Buffer overrun" ;
else if ( STREQ_NULLABLE ( klass , "CommandDisabled" ) ) return "The command has been disabled for this instance" ;
else if ( STREQ_NULLABLE ( klass , "CommandNotFound" ) ) return "The command has not been found" ;
else if ( STREQ_NULLABLE ( klass , "FdNotFound" ) ) return "File descriptor not found" ;
else if ( STREQ_NULLABLE ( klass , "InvalidParameter" ) ) return "Invalid parameter" ;
else if ( STREQ_NULLABLE ( klass , "InvalidParameterType" ) ) return "Invalid parameter type" ;
else if ( STREQ_NULLABLE ( klass , "InvalidParameterValue" ) ) return "Invalid parameter value" ;
else if ( STREQ_NULLABLE ( klass , "OpenFileFailed" ) ) return "Cannot open file" ;
else if ( STREQ_NULLABLE ( klass , "QgaCommandFailed" ) ) return "Guest agent command failed" ;
else if ( STREQ_NULLABLE ( klass , "QMPBadInputObjectMember" ) ) return "Bad QMP input object member" ;
else if ( STREQ_NULLABLE ( klass , "QMPExtraInputObjectMember" ) ) return "Unexpected extra object member" ;
else if ( STREQ_NULLABLE ( klass , "UndefinedError" ) ) return "An undefined error has occurred" ;
else if ( STREQ_NULLABLE ( klass , "Unsupported" ) ) return "this feature or command is not currently supported" ;
else if ( klass ) return klass ;
else return "unknown QEMU command error" ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dnslabel_table_add ( struct dnslabel_table * table , const char * label , off_t pos ) {
char * v ;
int p ;
if ( table -> n_labels == MAX_LABELS ) return ( - 1 ) ;
v = strdup ( label ) ;
if ( v == NULL ) return ( - 1 ) ;
p = table -> n_labels ++ ;
table -> labels [ p ] . v = v ;
table -> labels [ p ] . pos = pos ;
return ( 0 ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static Datum ExecEvalAnd ( BoolExprState * andExpr , ExprContext * econtext , bool * isNull , ExprDoneCond * isDone ) {
List * clauses = andExpr -> args ;
ListCell * clause ;
bool AnyNull ;
if ( isDone ) * isDone = ExprSingleResult ;
AnyNull = false ;
foreach ( clause , clauses ) {
ExprState * clausestate = ( ExprState * ) lfirst ( clause ) ;
Datum clause_value ;
clause_value = ExecEvalExpr ( clausestate , econtext , isNull , NULL ) ;
if ( * isNull ) AnyNull = true ;
else if ( ! DatumGetBool ( clause_value ) ) return clause_value ;
}
* isNull = AnyNull ;
return BoolGetDatum ( ! AnyNull ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
void vp9_update_layer_context_change_config ( VP9_COMP * const cpi , const int target_bandwidth ) {
SVC * const svc = & cpi -> svc ;
const VP9EncoderConfig * const oxcf = & cpi -> oxcf ;
const RATE_CONTROL * const rc = & cpi -> rc ;
int layer ;
int layer_end ;
float bitrate_alloc = 1.0 ;
if ( svc -> number_temporal_layers > 1 && cpi -> oxcf . rc_mode == VPX_CBR ) {
layer_end = svc -> number_temporal_layers ;
}
else {
layer_end = svc -> number_spatial_layers ;
}
for ( layer = 0 ;
layer < layer_end ;
++ layer ) {
LAYER_CONTEXT * const lc = & svc -> layer_context [ layer ] ;
RATE_CONTROL * const lrc = & lc -> rc ;
if ( svc -> number_temporal_layers > 1 && cpi -> oxcf . rc_mode == VPX_CBR ) {
lc -> target_bandwidth = oxcf -> ts_target_bitrate [ layer ] ;
}
else {
lc -> target_bandwidth = oxcf -> ss_target_bitrate [ layer ] ;
}
bitrate_alloc = ( float ) lc -> target_bandwidth / target_bandwidth ;
lrc -> starting_buffer_level = ( int64_t ) ( rc -> starting_buffer_level * bitrate_alloc ) ;
lrc -> optimal_buffer_level = ( int64_t ) ( rc -> optimal_buffer_level * bitrate_alloc ) ;
lrc -> maximum_buffer_size = ( int64_t ) ( rc -> maximum_buffer_size * bitrate_alloc ) ;
lrc -> bits_off_target = MIN ( lrc -> bits_off_target , lrc -> maximum_buffer_size ) ;
lrc -> buffer_level = MIN ( lrc -> buffer_level , lrc -> maximum_buffer_size ) ;
if ( svc -> number_temporal_layers > 1 && cpi -> oxcf . rc_mode == VPX_CBR ) {
lc -> framerate = cpi -> framerate / oxcf -> ts_rate_decimator [ layer ] ;
}
else {
lc -> framerate = cpi -> framerate ;
}
lrc -> avg_frame_bandwidth = ( int ) ( lc -> target_bandwidth / lc -> framerate ) ;
lrc -> max_frame_bandwidth = rc -> max_frame_bandwidth ;
lrc -> worst_quality = rc -> worst_quality ;
lrc -> best_quality = rc -> best_quality ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void dtap_tp_epc_test_loop_mode_c_mbms_packet_counter_response ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) {
guint32 curr_offset ;
guint32 consumed ;
guint curr_len ;
curr_len = len ;
curr_offset = offset ;
ELEM_MAND_V ( GSM_A_PDU_TYPE_DTAP , DE_TP_EPC_MBMS_PACKET_COUNTER_VALUE , NULL ) ;
EXTRANEOUS_DATA_CHECK ( curr_len , 0 , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void timelib_eat_spaces ( char * * ptr ) {
while ( * * ptr == ' ' || * * ptr == '\t' ) {
++ * ptr ;
}
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void nvic_sysreg_write ( void * opaque , hwaddr addr , uint64_t value , unsigned size ) {
nvic_state * s = ( nvic_state * ) opaque ;
uint32_t offset = addr ;
int i ;
switch ( offset ) {
case 0xd18 ... 0xd23 : for ( i = 0 ;
i < size ;
i ++ ) {
s -> gic . priority1 [ ( offset - 0xd14 ) + i ] [ 0 ] = ( value >> ( i * 8 ) ) & 0xff ;
}
gic_update ( & s -> gic ) ;
return ;
}
if ( size == 4 ) {
nvic_writel ( s , offset , value ) ;
return ;
}
qemu_log_mask ( LOG_GUEST_ERROR , "NVIC: Bad write of size %d at offset 0x%x\n" , size , offset ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
bool parsePGArray ( const char * atext , char * * * itemarray , int * nitems ) {
int inputlen ;
char * * items ;
char * strings ;
int curitem ;
* itemarray = NULL ;
* nitems = 0 ;
inputlen = strlen ( atext ) ;
if ( inputlen < 2 || atext [ 0 ] != '{
' || atext [ inputlen - 1 ] != '}
' ) return false ;
items = ( char * * ) malloc ( inputlen * ( sizeof ( char * ) + sizeof ( char ) ) ) ;
if ( items == NULL ) return false ;
* itemarray = items ;
strings = ( char * ) ( items + inputlen ) ;
atext ++ ;
curitem = 0 ;
while ( * atext != '}
' ) {
if ( * atext == '\0' ) return false ;
items [ curitem ] = strings ;
while ( * atext != '}
' && * atext != ',' ) {
if ( * atext == '\0' ) return false ;
if ( * atext != '"' ) * strings ++ = * atext ++ ;
else {
atext ++ ;
while ( * atext != '"' ) {
if ( * atext == '\0' ) return false ;
if ( * atext == '\\' ) {
atext ++ ;
if ( * atext == '\0' ) return false ;
}
* strings ++ = * atext ++ ;
}
atext ++ ;
}
}
* strings ++ = '\0' ;
if ( * atext == ',' ) atext ++ ;
curitem ++ ;
}
if ( atext [ 1 ] != '\0' ) return false ;
* nitems = curitem ;
return true ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int dissect_pvfs2_rmdirent_request ( tvbuff_t * tvb , proto_tree * tree , int offset , packet_info * pinfo ) {
offset = dissect_pvfs_string ( tvb , tree , hf_pvfs_path , offset , NULL ) ;
offset = dissect_pvfs_fh ( tvb , offset , pinfo , tree , "handle" , NULL ) ;
offset = dissect_pvfs_fs_id ( tvb , tree , offset ) ;
offset += 4 ;
offset = dissect_pvfs_time ( tvb , tree , offset , hf_pvfs_atime , hf_pvfs_atime_sec , hf_pvfs_atime_nsec ) ;
offset = dissect_pvfs_time ( tvb , tree , offset , hf_pvfs_mtime , hf_pvfs_mtime_sec , hf_pvfs_mtime_nsec ) ;
offset = dissect_pvfs_time ( tvb , tree , offset , hf_pvfs_ctime , hf_pvfs_ctime_sec , hf_pvfs_ctime_nsec ) ;
return offset ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static uint32_t PPC_io_readb ( target_phys_addr_t addr ) {
uint32_t ret = cpu_inb ( NULL , addr - PPC_IO_BASE ) ;
# if 0 if ( ( addr < 0x800003F0 || addr > 0x80000400 ) && ( addr < 0x80000074 || addr > 0x80000077 ) && ( addr < 0x80000020 || addr > 0x80000021 ) && ( addr < 0x800000a0 || addr > 0x800000a1 ) && ( addr < 0x800001f0 || addr > 0x800001f7 ) && ( addr < 0x80000170 || addr > 0x80000177 ) && ( addr < 0x8000060 || addr > 0x8000064 ) ) # endif {
PPC_IO_DPRINTF ( "0x%08x <= 0x%02x\n" , addr - PPC_IO_BASE , ret ) ;
}
return ret ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
char * xmlrpc_normalizeBuffer ( const char * buf ) {
char * newbuf ;
int i , len , j = 0 ;
len = strlen ( buf ) ;
newbuf = ( char * ) smalloc ( sizeof ( char ) * len + 1 ) ;
for ( i = 0 ;
i < len ;
i ++ ) {
switch ( buf [ i ] ) {
case 1 : break ;
case 2 : break ;
case 3 : if ( isdigit ( ( unsigned char ) buf [ i + 1 ] ) ) {
i ++ ;
if ( isdigit ( ( unsigned char ) buf [ i + 1 ] ) ) {
i ++ ;
}
if ( buf [ i + 1 ] == ',' ) {
i ++ ;
if ( isdigit ( ( unsigned char ) buf [ i + 1 ] ) ) {
i ++ ;
}
if ( isdigit ( ( unsigned char ) buf [ i + 1 ] ) ) {
i ++ ;
}
}
}
break ;
case 9 : break ;
case 10 : break ;
case 13 : break ;
case 22 : break ;
case 31 : break ;
default : if ( buf [ i ] > 31 ) {
newbuf [ j ] = buf [ i ] ;
j ++ ;
}
}
}
newbuf [ j ] = 0 ;
return ( newbuf ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int address_is_correct ( struct nameserver * ns , struct sockaddr * sa , socklen_t slen ) {
struct sockaddr_in * sin = ( struct sockaddr_in * ) sa ;
if ( sa -> sa_family != AF_INET || slen != sizeof ( struct sockaddr_in ) ) return 0 ;
if ( sin -> sin_addr . s_addr != ns -> address ) return 0 ;
return 1 ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void allocate_gf_group_bits ( VP9_COMP * cpi , int64_t gf_group_bits , double group_error , int gf_arf_bits ) {
RATE_CONTROL * const rc = & cpi -> rc ;
const VP9EncoderConfig * const oxcf = & cpi -> oxcf ;
TWO_PASS * const twopass = & cpi -> twopass ;
GF_GROUP * const gf_group = & twopass -> gf_group ;
FIRSTPASS_STATS frame_stats ;
int i ;
int frame_index = 1 ;
int target_frame_size ;
int key_frame ;
const int max_bits = frame_max_bits ( & cpi -> rc , & cpi -> oxcf ) ;
int64_t total_group_bits = gf_group_bits ;
double modified_err = 0.0 ;
double err_fraction ;
int mid_boost_bits = 0 ;
int mid_frame_idx ;
unsigned char arf_buffer_indices [ MAX_ACTIVE_ARFS ] ;
int alt_frame_index = frame_index ;
int has_temporal_layers = is_two_pass_svc ( cpi ) && cpi -> svc . number_temporal_layers > 1 ;
if ( has_temporal_layers ) alt_frame_index = cpi -> svc . number_temporal_layers ;
key_frame = cpi -> common . frame_type == KEY_FRAME || vp9_is_upper_layer_key_frame ( cpi ) ;
get_arf_buffer_indices ( arf_buffer_indices ) ;
if ( ! key_frame ) {
if ( rc -> source_alt_ref_active ) {
gf_group -> update_type [ 0 ] = OVERLAY_UPDATE ;
gf_group -> rf_level [ 0 ] = INTER_NORMAL ;
gf_group -> bit_allocation [ 0 ] = 0 ;
gf_group -> arf_update_idx [ 0 ] = arf_buffer_indices [ 0 ] ;
gf_group -> arf_ref_idx [ 0 ] = arf_buffer_indices [ 0 ] ;
}
else {
gf_group -> update_type [ 0 ] = GF_UPDATE ;
gf_group -> rf_level [ 0 ] = GF_ARF_STD ;
gf_group -> bit_allocation [ 0 ] = gf_arf_bits ;
gf_group -> arf_update_idx [ 0 ] = arf_buffer_indices [ 0 ] ;
gf_group -> arf_ref_idx [ 0 ] = arf_buffer_indices [ 0 ] ;
}
if ( EOF == input_stats ( twopass , & frame_stats ) ) return ;
}
if ( rc -> source_alt_ref_pending || ! key_frame ) total_group_bits -= gf_arf_bits ;
if ( rc -> source_alt_ref_pending ) {
gf_group -> update_type [ alt_frame_index ] = ARF_UPDATE ;
gf_group -> rf_level [ alt_frame_index ] = GF_ARF_STD ;
gf_group -> bit_allocation [ alt_frame_index ] = gf_arf_bits ;
if ( has_temporal_layers ) gf_group -> arf_src_offset [ alt_frame_index ] = ( unsigned char ) ( rc -> baseline_gf_interval - cpi -> svc . number_temporal_layers ) ;
else gf_group -> arf_src_offset [ alt_frame_index ] = ( unsigned char ) ( rc -> baseline_gf_interval - 1 ) ;
gf_group -> arf_update_idx [ alt_frame_index ] = arf_buffer_indices [ 0 ] ;
gf_group -> arf_ref_idx [ alt_frame_index ] = arf_buffer_indices [ cpi -> multi_arf_last_grp_enabled && rc -> source_alt_ref_active ] ;
if ( ! has_temporal_layers ) ++ frame_index ;
if ( cpi -> multi_arf_enabled ) {
gf_group -> update_type [ frame_index ] = ARF_UPDATE ;
gf_group -> rf_level [ frame_index ] = GF_ARF_LOW ;
gf_group -> arf_src_offset [ frame_index ] = ( unsigned char ) ( ( rc -> baseline_gf_interval >> 1 ) - 1 ) ;
gf_group -> arf_update_idx [ frame_index ] = arf_buffer_indices [ 1 ] ;
gf_group -> arf_ref_idx [ frame_index ] = arf_buffer_indices [ 0 ] ;
++ frame_index ;
}
}
mid_frame_idx = frame_index + ( rc -> baseline_gf_interval >> 1 ) - 1 ;
for ( i = 0 ;
i < rc -> baseline_gf_interval - 1 ;
++ i ) {
int arf_idx = 0 ;
if ( EOF == input_stats ( twopass , & frame_stats ) ) break ;
if ( has_temporal_layers && frame_index == alt_frame_index ) {
++ frame_index ;
}
modified_err = calculate_modified_err ( twopass , oxcf , & frame_stats ) ;
if ( group_error > 0 ) err_fraction = modified_err / DOUBLE_DIVIDE_CHECK ( group_error ) ;
else err_fraction = 0.0 ;
target_frame_size = ( int ) ( ( double ) total_group_bits * err_fraction ) ;
if ( rc -> source_alt_ref_pending && cpi -> multi_arf_enabled ) {
mid_boost_bits += ( target_frame_size >> 4 ) ;
target_frame_size -= ( target_frame_size >> 4 ) ;
if ( frame_index <= mid_frame_idx ) arf_idx = 1 ;
}
gf_group -> arf_update_idx [ frame_index ] = arf_buffer_indices [ arf_idx ] ;
gf_group -> arf_ref_idx [ frame_index ] = arf_buffer_indices [ arf_idx ] ;
target_frame_size = clamp ( target_frame_size , 0 , MIN ( max_bits , ( int ) total_group_bits ) ) ;
gf_group -> update_type [ frame_index ] = LF_UPDATE ;
gf_group -> rf_level [ frame_index ] = INTER_NORMAL ;
gf_group -> bit_allocation [ frame_index ] = target_frame_size ;
++ frame_index ;
}
gf_group -> arf_update_idx [ frame_index ] = arf_buffer_indices [ 0 ] ;
gf_group -> arf_ref_idx [ frame_index ] = arf_buffer_indices [ 0 ] ;
if ( rc -> source_alt_ref_pending ) {
gf_group -> update_type [ frame_index ] = OVERLAY_UPDATE ;
gf_group -> rf_level [ frame_index ] = INTER_NORMAL ;
if ( cpi -> multi_arf_enabled ) {
gf_group -> bit_allocation [ 2 ] = gf_group -> bit_allocation [ mid_frame_idx ] + mid_boost_bits ;
gf_group -> update_type [ mid_frame_idx ] = OVERLAY_UPDATE ;
gf_group -> bit_allocation [ mid_frame_idx ] = 0 ;
}
}
else {
gf_group -> update_type [ frame_index ] = GF_UPDATE ;
gf_group -> rf_level [ frame_index ] = GF_ARF_STD ;
}
cpi -> multi_arf_last_grp_enabled = cpi -> multi_arf_enabled ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static int decode_frame ( AVCodecContext * avctx , void * data , int * got_frame , AVPacket * avpkt ) {
const uint8_t * buf = avpkt -> data ;
int buf_size = avpkt -> size ;
VmncContext * const c = avctx -> priv_data ;
uint8_t * outptr ;
const uint8_t * src = buf ;
int dx , dy , w , h , depth , enc , chunks , res , size_left , ret ;
if ( ( ret = ff_reget_buffer ( avctx , & c -> pic ) ) < 0 ) {
av_log ( avctx , AV_LOG_ERROR , "reget_buffer() failed\n" ) ;
return ret ;
}
c -> pic . key_frame = 0 ;
c -> pic . pict_type = AV_PICTURE_TYPE_P ;
if ( c -> screendta ) {
int i ;
w = c -> cur_w ;
if ( c -> width < c -> cur_x + w ) w = c -> width - c -> cur_x ;
h = c -> cur_h ;
if ( c -> height < c -> cur_y + h ) h = c -> height - c -> cur_y ;
dx = c -> cur_x ;
if ( dx < 0 ) {
w += dx ;
dx = 0 ;
}
dy = c -> cur_y ;
if ( dy < 0 ) {
h += dy ;
dy = 0 ;
}
if ( ( w > 0 ) && ( h > 0 ) ) {
outptr = c -> pic . data [ 0 ] + dx * c -> bpp2 + dy * c -> pic . linesize [ 0 ] ;
for ( i = 0 ;
i < h ;
i ++ ) {
memcpy ( outptr , c -> screendta + i * c -> cur_w * c -> bpp2 , w * c -> bpp2 ) ;
outptr += c -> pic . linesize [ 0 ] ;
}
}
}
src += 2 ;
chunks = AV_RB16 ( src ) ;
src += 2 ;
while ( chunks -- ) {
dx = AV_RB16 ( src ) ;
src += 2 ;
dy = AV_RB16 ( src ) ;
src += 2 ;
w = AV_RB16 ( src ) ;
src += 2 ;
h = AV_RB16 ( src ) ;
src += 2 ;
enc = AV_RB32 ( src ) ;
src += 4 ;
outptr = c -> pic . data [ 0 ] + dx * c -> bpp2 + dy * c -> pic . linesize [ 0 ] ;
size_left = buf_size - ( src - buf ) ;
switch ( enc ) {
case MAGIC_WMVd : if ( size_left < 2 + w * h * c -> bpp2 * 2 ) {
av_log ( avctx , AV_LOG_ERROR , "Premature end of data! (need %i got %i)\n" , 2 + w * h * c -> bpp2 * 2 , size_left ) ;
return - 1 ;
}
src += 2 ;
c -> cur_w = w ;
c -> cur_h = h ;
c -> cur_hx = dx ;
c -> cur_hy = dy ;
if ( ( c -> cur_hx > c -> cur_w ) || ( c -> cur_hy > c -> cur_h ) ) {
av_log ( avctx , AV_LOG_ERROR , "Cursor hot spot is not in image: %ix%i of %ix%i cursor size\n" , c -> cur_hx , c -> cur_hy , c -> cur_w , c -> cur_h ) ;
c -> cur_hx = c -> cur_hy = 0 ;
}
c -> curbits = av_realloc ( c -> curbits , c -> cur_w * c -> cur_h * c -> bpp2 ) ;
c -> curmask = av_realloc ( c -> curmask , c -> cur_w * c -> cur_h * c -> bpp2 ) ;
c -> screendta = av_realloc ( c -> screendta , c -> cur_w * c -> cur_h * c -> bpp2 ) ;
load_cursor ( c , src ) ;
src += w * h * c -> bpp2 * 2 ;
break ;
case MAGIC_WMVe : src += 2 ;
break ;
case MAGIC_WMVf : c -> cur_x = dx - c -> cur_hx ;
c -> cur_y = dy - c -> cur_hy ;
break ;
case MAGIC_WMVg : src += 10 ;
break ;
case MAGIC_WMVh : src += 4 ;
break ;
case MAGIC_WMVi : c -> pic . key_frame = 1 ;
c -> pic . pict_type = AV_PICTURE_TYPE_I ;
depth = * src ++ ;
if ( depth != c -> bpp ) {
av_log ( avctx , AV_LOG_INFO , "Depth mismatch. Container %i bpp, Frame data: %i bpp\n" , c -> bpp , depth ) ;
}
src ++ ;
c -> bigendian = * src ++ ;
if ( c -> bigendian & ( ~ 1 ) ) {
av_log ( avctx , AV_LOG_INFO , "Invalid header: bigendian flag = %i\n" , c -> bigendian ) ;
return - 1 ;
}
src += 13 ;
break ;
case MAGIC_WMVj : src += 2 ;
break ;
case 0x00000000 : if ( ( dx + w > c -> width ) || ( dy + h > c -> height ) ) {
av_log ( avctx , AV_LOG_ERROR , "Incorrect frame size: %ix%i+%ix%i of %ix%i\n" , w , h , dx , dy , c -> width , c -> height ) ;
return - 1 ;
}
if ( size_left < w * h * c -> bpp2 ) {
av_log ( avctx , AV_LOG_ERROR , "Premature end of data! (need %i got %i)\n" , w * h * c -> bpp2 , size_left ) ;
return - 1 ;
}
paint_raw ( outptr , w , h , src , c -> bpp2 , c -> bigendian , c -> pic . linesize [ 0 ] ) ;
src += w * h * c -> bpp2 ;
break ;
case 0x00000005 : if ( ( dx + w > c -> width ) || ( dy + h > c -> height ) ) {
av_log ( avctx , AV_LOG_ERROR , "Incorrect frame size: %ix%i+%ix%i of %ix%i\n" , w , h , dx , dy , c -> width , c -> height ) ;
return - 1 ;
}
res = decode_hextile ( c , outptr , src , size_left , w , h , c -> pic . linesize [ 0 ] ) ;
if ( res < 0 ) return - 1 ;
src += res ;
break ;
default : av_log ( avctx , AV_LOG_ERROR , "Unsupported block type 0x%08X\n" , enc ) ;
chunks = 0 ;
}
}
if ( c -> screendta ) {
int i ;
w = c -> cur_w ;
if ( c -> width < c -> cur_x + w ) w = c -> width - c -> cur_x ;
h = c -> cur_h ;
if ( c -> height < c -> cur_y + h ) h = c -> height - c -> cur_y ;
dx = c -> cur_x ;
if ( dx < 0 ) {
w += dx ;
dx = 0 ;
}
dy = c -> cur_y ;
if ( dy < 0 ) {
h += dy ;
dy = 0 ;
}
if ( ( w > 0 ) && ( h > 0 ) ) {
outptr = c -> pic . data [ 0 ] + dx * c -> bpp2 + dy * c -> pic . linesize [ 0 ] ;
for ( i = 0 ;
i < h ;
i ++ ) {
memcpy ( c -> screendta + i * c -> cur_w * c -> bpp2 , outptr , w * c -> bpp2 ) ;
outptr += c -> pic . linesize [ 0 ] ;
}
outptr = c -> pic . data [ 0 ] ;
put_cursor ( outptr , c -> pic . linesize [ 0 ] , c , c -> cur_x , c -> cur_y ) ;
}
}
* got_frame = 1 ;
if ( ( ret = av_frame_ref ( data , & c -> pic ) ) < 0 ) return ret ;
return buf_size ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
unsigned int vp9_sub_pixel_avg_variance ## W ## x ## H ## _c ( const uint8_t * src , int src_stride , int xoffset , int yoffset , const uint8_t * dst , int dst_stride , unsigned int * sse , const uint8_t * second_pred ) {
uint16_t fdata3 [ ( H + 1 ) * W ] ;
uint8_t temp2 [ H * W ] ;
DECLARE_ALIGNED_ARRAY ( 16 , uint8_t , temp3 , H * W ) ;
var_filter_block2d_bil_first_pass ( src , fdata3 , src_stride , 1 , H + 1 , W , BILINEAR_FILTERS_2TAP ( xoffset ) ) ;
var_filter_block2d_bil_second_pass ( fdata3 , temp2 , W , W , H , W , BILINEAR_FILTERS_2TAP ( yoffset ) ) ;
vp9_comp_avg_pred ( temp3 , second_pred , W , H , temp2 , W ) ;
return vp9_variance ## W ## x ## H ## _c ( temp3 , W , dst , dst_stride , sse ) ;
\ }
void vp9_get16x16var_c ( const uint8_t * src_ptr , int source_stride , const uint8_t * ref_ptr , int ref_stride , unsigned int * sse , int * sum ) {
variance ( src_ptr , source_stride , ref_ptr , ref_stride , 16 , 16 , sse , sum ) ;
}
void vp9_get8x8var_c ( const uint8_t * src_ptr , int source_stride , const uint8_t * ref_ptr , int ref_stride , unsigned int * sse , int * sum ) {
variance ( src_ptr , source_stride , ref_ptr , ref_stride , 8 , 8 , sse , sum ) ;
}
unsigned int vp9_mse16x16_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 16 , 16 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse16x8_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 16 , 8 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse8x16_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 8 , 16 , sse , & sum ) ;
return * sse ;
}
unsigned int vp9_mse8x8_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sse ) {
int sum ;
variance ( src , src_stride , ref , ref_stride , 8 , 8 , sse , & sum ) ;
return * sse ;
}
VAR ( 4 , 4 ) SUBPIX_VAR ( 4 , 4 ) SUBPIX_AVG_VAR ( 4 , 4 )
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void e1000e_rss_parse_packet ( E1000ECore * core , struct NetRxPkt * pkt , E1000E_RSSInfo * info ) {
trace_e1000e_rx_rss_started ( ) ;
if ( ! e1000e_rss_enabled ( core ) ) {
info -> enabled = false ;
info -> hash = 0 ;
info -> queue = 0 ;
info -> type = 0 ;
trace_e1000e_rx_rss_disabled ( ) ;
return ;
}
info -> enabled = true ;
info -> type = e1000e_rss_get_hash_type ( core , pkt ) ;
trace_e1000e_rx_rss_type ( info -> type ) ;
if ( info -> type == E1000_MRQ_RSS_TYPE_NONE ) {
info -> hash = 0 ;
info -> queue = 0 ;
return ;
}
info -> hash = e1000e_rss_calc_hash ( core , pkt , info ) ;
info -> queue = E1000_RSS_QUEUE ( & core -> mac [ RETA ] , info -> hash ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static __inline__ unsigned int dccp_packet_hdr_len ( const __u8 type ) {
if ( type == DCCP_PKT_DATA ) return 0 ;
if ( type == DCCP_PKT_DATAACK || type == DCCP_PKT_ACK || type == DCCP_PKT_SYNC || type == DCCP_PKT_SYNCACK || type == DCCP_PKT_CLOSE || type == DCCP_PKT_CLOSEREQ ) return sizeof ( struct dccp_hdr_ack_bits ) ;
if ( type == DCCP_PKT_REQUEST ) return sizeof ( struct dccp_hdr_request ) ;
if ( type == DCCP_PKT_RESPONSE ) return sizeof ( struct dccp_hdr_response ) ;
return sizeof ( struct dccp_hdr_reset ) ;
}
| 0False
|
Categorize the following code snippet as vulnerable or not. True or False
|
static void gx_ttfMemory__free ( ttfMemory * self , void * p , const char * cname ) {
gs_memory_t * mem = ( ( gx_ttfMemory * ) self ) -> memory ;
gs_free_object ( mem , p , cname ) ;
}
| 0False
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.