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 | int mbfl_oddlen ( mbfl_string * string ) {
int len , n , m , k ;
unsigned char * p ;
const unsigned char * mbtab ;
const mbfl_encoding * encoding ;
if ( string == NULL ) {
return - 1 ;
}
encoding = mbfl_no2encoding ( string -> no_encoding ) ;
if ( encoding == NULL ) {
return - 1 ;
}
len = 0 ;
if ( encoding -> flag & MBFL_ENCTYPE_SBCS ) {
return 0 ;
}
else if ( encoding -> flag & ( MBFL_ENCTYPE_WCS2BE | MBFL_ENCTYPE_WCS2LE ) ) {
return len % 2 ;
}
else if ( encoding -> flag & ( MBFL_ENCTYPE_WCS4BE | MBFL_ENCTYPE_WCS4LE ) ) {
return len % 4 ;
}
else if ( encoding -> mblen_table != NULL ) {
mbtab = encoding -> mblen_table ;
n = 0 ;
p = string -> val ;
k = string -> len ;
if ( p != NULL ) {
while ( n < k ) {
m = mbtab [ * p ] ;
n += m ;
p += m ;
}
;
}
return n - k ;
}
else {
return 0 ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int dwarf_elf_object_access_get_section_info ( void * obj_in , Dwarf_Half section_index , Dwarf_Obj_Access_Section * ret_scn , int * error ) {
dwarf_elf_object_access_internals_t * obj = ( dwarf_elf_object_access_internals_t * ) obj_in ;
Elf32_Shdr * shdr32 = 0 ;
# ifdef HAVE_ELF64_GETSHDR Elf64_Shdr * shdr64 = 0 ;
# endif Elf_Scn * scn = 0 ;
scn = elf_getscn ( obj -> elf , section_index ) ;
if ( scn == NULL ) {
* error = DW_DLE_MDE ;
return DW_DLV_ERROR ;
}
if ( obj -> is_64bit ) {
# ifdef HAVE_ELF64_GETSHDR shdr64 = elf64_getshdr ( scn ) ;
if ( shdr64 == NULL ) {
* error = DW_DLE_ELF_GETSHDR_ERROR ;
return DW_DLV_ERROR ;
}
ret_scn -> type = shdr64 -> sh_type ;
ret_scn -> size = shdr64 -> sh_size ;
ret_scn -> addr = shdr64 -> sh_addr ;
ret_scn -> link = shdr64 -> sh_link ;
ret_scn -> info = shdr64 -> sh_info ;
ret_scn -> entrysize = shdr64 -> sh_entsize ;
ret_scn -> name = elf_strptr ( obj -> elf , obj -> ehdr64 -> e_shstrndx , shdr64 -> sh_name ) ;
if ( ret_scn -> name == NULL ) {
* error = DW_DLE_ELF_STRPTR_ERROR ;
return DW_DLV_ERROR ;
}
return DW_DLV_OK ;
# else * error = DW_DLE_MISSING_ELF64_SUPPORT ;
return DW_DLV_ERROR ;
# endif }
if ( ( shdr32 = elf32_getshdr ( scn ) ) == NULL ) {
* error = DW_DLE_ELF_GETSHDR_ERROR ;
return DW_DLV_ERROR ;
}
ret_scn -> type = shdr32 -> sh_type ;
ret_scn -> size = shdr32 -> sh_size ;
ret_scn -> addr = shdr32 -> sh_addr ;
ret_scn -> link = shdr32 -> sh_link ;
ret_scn -> info = shdr32 -> sh_info ;
ret_scn -> entrysize = shdr32 -> sh_entsize ;
ret_scn -> name = elf_strptr ( obj -> elf , obj -> ehdr32 -> e_shstrndx , shdr32 -> sh_name ) ;
if ( ret_scn -> name == NULL ) {
* error = DW_DLE_ELF_STRPTR_ERROR ;
return DW_DLV_ERROR ;
}
return DW_DLV_OK ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | xmlRegisterNodeFunc * __xmlRegisterNodeDefaultValue ( void ) {
if ( IS_MAIN_THREAD ) return ( & xmlRegisterNodeDefaultValue ) ;
else return ( & xmlGetGlobalState ( ) -> xmlRegisterNodeDefaultValue ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static uint64_t vmport_ioport_read ( void * opaque , hwaddr addr , unsigned size ) {
VMPortState * s = opaque ;
CPUX86State * env = cpu_single_env ;
unsigned char command ;
uint32_t eax ;
cpu_synchronize_state ( CPU ( x86_env_get_cpu ( env ) ) ) ;
eax = env -> regs [ R_EAX ] ;
if ( eax != VMPORT_MAGIC ) return eax ;
command = env -> regs [ R_ECX ] ;
if ( command >= VMPORT_ENTRIES ) return eax ;
if ( ! s -> func [ command ] ) {
# ifdef VMPORT_DEBUG fprintf ( stderr , "vmport: unknown command %x\n" , command ) ;
# endif return eax ;
}
return s -> func [ command ] ( s -> opaque [ command ] , addr ) ;
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | static int selinux_sb_remount ( struct super_block * sb , void * data ) {
int rc , i , * flags ;
struct security_mnt_opts opts ;
char * secdata , * * mount_options ;
struct superblock_security_struct * sbsec = sb -> s_security ;
if ( ! ( sbsec -> flags & SE_SBINITIALIZED ) ) return 0 ;
if ( ! data ) return 0 ;
if ( sb -> s_type -> fs_flags & FS_BINARY_MOUNTDATA ) return 0 ;
security_init_mnt_opts ( & opts ) ;
secdata = alloc_secdata ( ) ;
if ( ! secdata ) return - ENOMEM ;
rc = selinux_sb_copy_data ( data , secdata ) ;
if ( rc ) goto out_free_secdata ;
rc = selinux_parse_opts_str ( secdata , & opts ) ;
if ( rc ) goto out_free_secdata ;
mount_options = opts . mnt_opts ;
flags = opts . mnt_opts_flags ;
for ( i = 0 ;
i < opts . num_mnt_opts ;
i ++ ) {
u32 sid ;
if ( flags [ i ] == SBLABEL_MNT ) continue ;
rc = security_context_str_to_sid ( mount_options [ i ] , & sid , GFP_KERNEL ) ;
if ( rc ) {
printk ( KERN_WARNING "SELinux: security_context_str_to_sid" "(%s) failed for (dev %s, type %s) errno=%d\n" , mount_options [ i ] , sb -> s_id , sb -> s_type -> name , rc ) ;
goto out_free_opts ;
}
rc = - EINVAL ;
switch ( flags [ i ] ) {
case FSCONTEXT_MNT : if ( bad_option ( sbsec , FSCONTEXT_MNT , sbsec -> sid , sid ) ) goto out_bad_option ;
break ;
case CONTEXT_MNT : if ( bad_option ( sbsec , CONTEXT_MNT , sbsec -> mntpoint_sid , sid ) ) goto out_bad_option ;
break ;
case ROOTCONTEXT_MNT : {
struct inode_security_struct * root_isec ;
root_isec = backing_inode_security ( sb -> s_root ) ;
if ( bad_option ( sbsec , ROOTCONTEXT_MNT , root_isec -> sid , sid ) ) goto out_bad_option ;
break ;
}
case DEFCONTEXT_MNT : if ( bad_option ( sbsec , DEFCONTEXT_MNT , sbsec -> def_sid , sid ) ) goto out_bad_option ;
break ;
default : goto out_free_opts ;
}
}
rc = 0 ;
out_free_opts : security_free_mnt_opts ( & opts ) ;
out_free_secdata : free_secdata ( secdata ) ;
return rc ;
out_bad_option : printk ( KERN_WARNING "SELinux: unable to change security options " "during remount (dev %s, type=%s)\n" , sb -> s_id , sb -> s_type -> name ) ;
goto out_free_opts ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int mpc8_get_mask ( GetBitContext * gb , int size , int t ) {
int mask = 0 ;
if ( t && t != size ) mask = mpc8_dec_enum ( gb , FFMIN ( t , size - t ) , size ) ;
if ( ( t << 1 ) > size ) mask = ~ mask ;
return mask ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void ctl_putsys ( int varid ) {
l_fp tmp ;
char str [ 256 ] ;
u_int u ;
double kb ;
double dtemp ;
const char * ss ;
# ifdef AUTOKEY struct cert_info * cp ;
# endif # ifdef KERNEL_PLL static struct timex ntx ;
static u_long ntp_adjtime_time ;
static const double to_ms = # ifdef STA_NANO 1.0e-6 ;
# else 1.0e-3 ;
# endif if ( CS_KERN_FIRST <= varid && varid <= CS_KERN_LAST && current_time != ntp_adjtime_time ) {
ZERO ( ntx ) ;
if ( ntp_adjtime ( & ntx ) < 0 ) msyslog ( LOG_ERR , "ntp_adjtime() for mode 6 query failed: %m" ) ;
else ntp_adjtime_time = current_time ;
}
# endif switch ( varid ) {
case CS_LEAP : ctl_putuint ( sys_var [ CS_LEAP ] . text , sys_leap ) ;
break ;
case CS_STRATUM : ctl_putuint ( sys_var [ CS_STRATUM ] . text , sys_stratum ) ;
break ;
case CS_PRECISION : ctl_putint ( sys_var [ CS_PRECISION ] . text , sys_precision ) ;
break ;
case CS_ROOTDELAY : ctl_putdbl ( sys_var [ CS_ROOTDELAY ] . text , sys_rootdelay * 1e3 ) ;
break ;
case CS_ROOTDISPERSION : ctl_putdbl ( sys_var [ CS_ROOTDISPERSION ] . text , sys_rootdisp * 1e3 ) ;
break ;
case CS_REFID : if ( sys_stratum > 1 && sys_stratum < STRATUM_UNSPEC ) ctl_putadr ( sys_var [ varid ] . text , sys_refid , NULL ) ;
else ctl_putrefid ( sys_var [ varid ] . text , sys_refid ) ;
break ;
case CS_REFTIME : ctl_putts ( sys_var [ CS_REFTIME ] . text , & sys_reftime ) ;
break ;
case CS_POLL : ctl_putuint ( sys_var [ CS_POLL ] . text , sys_poll ) ;
break ;
case CS_PEERID : if ( sys_peer == NULL ) ctl_putuint ( sys_var [ CS_PEERID ] . text , 0 ) ;
else ctl_putuint ( sys_var [ CS_PEERID ] . text , sys_peer -> associd ) ;
break ;
case CS_PEERADR : if ( sys_peer != NULL && sys_peer -> dstadr != NULL ) ss = sptoa ( & sys_peer -> srcadr ) ;
else ss = "0.0.0.0:0" ;
ctl_putunqstr ( sys_var [ CS_PEERADR ] . text , ss , strlen ( ss ) ) ;
break ;
case CS_PEERMODE : u = ( sys_peer != NULL ) ? sys_peer -> hmode : MODE_UNSPEC ;
ctl_putuint ( sys_var [ CS_PEERMODE ] . text , u ) ;
break ;
case CS_OFFSET : ctl_putdbl6 ( sys_var [ CS_OFFSET ] . text , last_offset * 1e3 ) ;
break ;
case CS_DRIFT : ctl_putdbl ( sys_var [ CS_DRIFT ] . text , drift_comp * 1e6 ) ;
break ;
case CS_JITTER : ctl_putdbl6 ( sys_var [ CS_JITTER ] . text , sys_jitter * 1e3 ) ;
break ;
case CS_ERROR : ctl_putdbl ( sys_var [ CS_ERROR ] . text , clock_jitter * 1e3 ) ;
break ;
case CS_CLOCK : get_systime ( & tmp ) ;
ctl_putts ( sys_var [ CS_CLOCK ] . text , & tmp ) ;
break ;
case CS_PROCESSOR : # ifndef HAVE_UNAME ctl_putstr ( sys_var [ CS_PROCESSOR ] . text , str_processor , sizeof ( str_processor ) - 1 ) ;
# else ctl_putstr ( sys_var [ CS_PROCESSOR ] . text , utsnamebuf . machine , strlen ( utsnamebuf . machine ) ) ;
# endif break ;
case CS_SYSTEM : # ifndef HAVE_UNAME ctl_putstr ( sys_var [ CS_SYSTEM ] . text , str_system , sizeof ( str_system ) - 1 ) ;
# else snprintf ( str , sizeof ( str ) , "%s/%s" , utsnamebuf . sysname , utsnamebuf . release ) ;
ctl_putstr ( sys_var [ CS_SYSTEM ] . text , str , strlen ( str ) ) ;
# endif break ;
case CS_VERSION : ctl_putstr ( sys_var [ CS_VERSION ] . text , Version , strlen ( Version ) ) ;
break ;
case CS_STABIL : ctl_putdbl ( sys_var [ CS_STABIL ] . text , clock_stability * 1e6 ) ;
break ;
case CS_VARLIST : {
char buf [ CTL_MAX_DATA_LEN ] ;
char * buffp , * buffend ;
int firstVarName ;
const char * ss1 ;
int len ;
const struct ctl_var * k ;
buffp = buf ;
buffend = buf + sizeof ( buf ) ;
if ( buffp + strlen ( sys_var [ CS_VARLIST ] . text ) + 4 > buffend ) break ;
snprintf ( buffp , sizeof ( buf ) , "%s=\"" , sys_var [ CS_VARLIST ] . text ) ;
buffp += strlen ( buffp ) ;
firstVarName = TRUE ;
for ( k = sys_var ;
! ( k -> flags & EOV ) ;
k ++ ) {
if ( k -> flags & PADDING ) continue ;
len = strlen ( k -> text ) ;
if ( buffp + len + 1 >= buffend ) break ;
if ( ! firstVarName ) * buffp ++ = ',' ;
else firstVarName = FALSE ;
memcpy ( buffp , k -> text , len ) ;
buffp += len ;
}
for ( k = ext_sys_var ;
k && ! ( k -> flags & EOV ) ;
k ++ ) {
if ( k -> flags & PADDING ) continue ;
if ( NULL == k -> text ) continue ;
ss1 = strchr ( k -> text , '=' ) ;
if ( NULL == ss1 ) len = strlen ( k -> text ) ;
else len = ss1 - k -> text ;
if ( buffp + len + 1 >= buffend ) break ;
if ( firstVarName ) {
* buffp ++ = ',' ;
firstVarName = FALSE ;
}
memcpy ( buffp , k -> text , ( unsigned ) len ) ;
buffp += len ;
}
if ( buffp + 2 >= buffend ) break ;
* buffp ++ = '"' ;
* buffp = '\0' ;
ctl_putdata ( buf , ( unsigned ) ( buffp - buf ) , 0 ) ;
break ;
}
case CS_TAI : if ( sys_tai > 0 ) ctl_putuint ( sys_var [ CS_TAI ] . text , sys_tai ) ;
break ;
case CS_LEAPTAB : {
leap_signature_t lsig ;
leapsec_getsig ( & lsig ) ;
if ( lsig . ttime > 0 ) ctl_putfs ( sys_var [ CS_LEAPTAB ] . text , lsig . ttime ) ;
break ;
}
case CS_LEAPEND : {
leap_signature_t lsig ;
leapsec_getsig ( & lsig ) ;
if ( lsig . etime > 0 ) ctl_putfs ( sys_var [ CS_LEAPEND ] . text , lsig . etime ) ;
break ;
}
# ifdef LEAP_SMEAR case CS_LEAPSMEARINTV : if ( leap_smear_intv > 0 ) ctl_putuint ( sys_var [ CS_LEAPSMEARINTV ] . text , leap_smear_intv ) ;
break ;
case CS_LEAPSMEAROFFS : if ( leap_smear_intv > 0 ) ctl_putdbl ( sys_var [ CS_LEAPSMEAROFFS ] . text , leap_smear . doffset * 1e3 ) ;
break ;
# endif case CS_RATE : ctl_putuint ( sys_var [ CS_RATE ] . text , ntp_minpoll ) ;
break ;
case CS_MRU_ENABLED : ctl_puthex ( sys_var [ varid ] . text , mon_enabled ) ;
break ;
case CS_MRU_DEPTH : ctl_putuint ( sys_var [ varid ] . text , mru_entries ) ;
break ;
case CS_MRU_MEM : kb = mru_entries * ( sizeof ( mon_entry ) / 1024. ) ;
u = ( u_int ) kb ;
if ( kb - u >= 0.5 ) u ++ ;
ctl_putuint ( sys_var [ varid ] . text , u ) ;
break ;
case CS_MRU_DEEPEST : ctl_putuint ( sys_var [ varid ] . text , mru_peakentries ) ;
break ;
case CS_MRU_MINDEPTH : ctl_putuint ( sys_var [ varid ] . text , mru_mindepth ) ;
break ;
case CS_MRU_MAXAGE : ctl_putint ( sys_var [ varid ] . text , mru_maxage ) ;
break ;
case CS_MRU_MAXDEPTH : ctl_putuint ( sys_var [ varid ] . text , mru_maxdepth ) ;
break ;
case CS_MRU_MAXMEM : kb = mru_maxdepth * ( sizeof ( mon_entry ) / 1024. ) ;
u = ( u_int ) kb ;
if ( kb - u >= 0.5 ) u ++ ;
ctl_putuint ( sys_var [ varid ] . text , u ) ;
break ;
case CS_SS_UPTIME : ctl_putuint ( sys_var [ varid ] . text , current_time ) ;
break ;
case CS_SS_RESET : ctl_putuint ( sys_var [ varid ] . text , current_time - sys_stattime ) ;
break ;
case CS_SS_RECEIVED : ctl_putuint ( sys_var [ varid ] . text , sys_received ) ;
break ;
case CS_SS_THISVER : ctl_putuint ( sys_var [ varid ] . text , sys_newversion ) ;
break ;
case CS_SS_OLDVER : ctl_putuint ( sys_var [ varid ] . text , sys_oldversion ) ;
break ;
case CS_SS_BADFORMAT : ctl_putuint ( sys_var [ varid ] . text , sys_badlength ) ;
break ;
case CS_SS_BADAUTH : ctl_putuint ( sys_var [ varid ] . text , sys_badauth ) ;
break ;
case CS_SS_DECLINED : ctl_putuint ( sys_var [ varid ] . text , sys_declined ) ;
break ;
case CS_SS_RESTRICTED : ctl_putuint ( sys_var [ varid ] . text , sys_restricted ) ;
break ;
case CS_SS_LIMITED : ctl_putuint ( sys_var [ varid ] . text , sys_limitrejected ) ;
break ;
case CS_SS_KODSENT : ctl_putuint ( sys_var [ varid ] . text , sys_kodsent ) ;
break ;
case CS_SS_PROCESSED : ctl_putuint ( sys_var [ varid ] . text , sys_processed ) ;
break ;
case CS_BCASTDELAY : ctl_putdbl ( sys_var [ varid ] . text , sys_bdelay * 1e3 ) ;
break ;
case CS_AUTHDELAY : LFPTOD ( & sys_authdelay , dtemp ) ;
ctl_putdbl ( sys_var [ varid ] . text , dtemp * 1e3 ) ;
break ;
case CS_AUTHKEYS : ctl_putuint ( sys_var [ varid ] . text , authnumkeys ) ;
break ;
case CS_AUTHFREEK : ctl_putuint ( sys_var [ varid ] . text , authnumfreekeys ) ;
break ;
case CS_AUTHKLOOKUPS : ctl_putuint ( sys_var [ varid ] . text , authkeylookups ) ;
break ;
case CS_AUTHKNOTFOUND : ctl_putuint ( sys_var [ varid ] . text , authkeynotfound ) ;
break ;
case CS_AUTHKUNCACHED : ctl_putuint ( sys_var [ varid ] . text , authkeyuncached ) ;
break ;
case CS_AUTHKEXPIRED : ctl_putuint ( sys_var [ varid ] . text , authkeyexpired ) ;
break ;
case CS_AUTHENCRYPTS : ctl_putuint ( sys_var [ varid ] . text , authencryptions ) ;
break ;
case CS_AUTHDECRYPTS : ctl_putuint ( sys_var [ varid ] . text , authdecryptions ) ;
break ;
case CS_AUTHRESET : ctl_putuint ( sys_var [ varid ] . text , current_time - auth_timereset ) ;
break ;
# ifndef KERNEL_PLL # define CTL_IF_KERNLOOP ( putfunc , args ) ctl_putint ( sys_var [ varid ] . text , 0 ) # else # define CTL_IF_KERNLOOP ( putfunc , args ) putfunc args # endif # ifndef KERNEL_PLL # define CTL_IF_KERNPPS ( putfunc , args ) ctl_putint ( sys_var [ varid ] . text , 0 ) # else # define CTL_IF_KERNPPS ( putfunc , args ) if ( 0 == ntx . shift ) ctl_putint ( sys_var [ varid ] . text , 0 ) ;
else putfunc args # endif case CS_K_OFFSET : CTL_IF_KERNLOOP ( ctl_putdblf , ( sys_var [ varid ] . text , 0 , - 1 , to_ms * ntx . offset ) ) ;
break ;
case CS_K_FREQ : CTL_IF_KERNLOOP ( ctl_putsfp , ( sys_var [ varid ] . text , ntx . freq ) ) ;
break ;
case CS_K_MAXERR : CTL_IF_KERNLOOP ( ctl_putdblf , ( sys_var [ varid ] . text , 0 , 6 , to_ms * ntx . maxerror ) ) ;
break ;
case CS_K_ESTERR : CTL_IF_KERNLOOP ( ctl_putdblf , ( sys_var [ varid ] . text , 0 , 6 , to_ms * ntx . esterror ) ) ;
break ;
case CS_K_STFLAGS : # ifndef KERNEL_PLL ss = "" ;
# else ss = k_st_flags ( ntx . status ) ;
# endif ctl_putstr ( sys_var [ varid ] . text , ss , strlen ( ss ) ) ;
break ;
case CS_K_TIMECONST : CTL_IF_KERNLOOP ( ctl_putint , ( sys_var [ varid ] . text , ntx . constant ) ) ;
break ;
case CS_K_PRECISION : CTL_IF_KERNLOOP ( ctl_putdblf , ( sys_var [ varid ] . text , 0 , 6 , to_ms * ntx . precision ) ) ;
break ;
case CS_K_FREQTOL : CTL_IF_KERNLOOP ( ctl_putsfp , ( sys_var [ varid ] . text , ntx . tolerance ) ) ;
break ;
case CS_K_PPS_FREQ : CTL_IF_KERNPPS ( ctl_putsfp , ( sys_var [ varid ] . text , ntx . ppsfreq ) ) ;
break ;
case CS_K_PPS_STABIL : CTL_IF_KERNPPS ( ctl_putsfp , ( sys_var [ varid ] . text , ntx . stabil ) ) ;
break ;
case CS_K_PPS_JITTER : CTL_IF_KERNPPS ( ctl_putdbl , ( sys_var [ varid ] . text , to_ms * ntx . jitter ) ) ;
break ;
case CS_K_PPS_CALIBDUR : CTL_IF_KERNPPS ( ctl_putint , ( sys_var [ varid ] . text , 1 << ntx . shift ) ) ;
break ;
case CS_K_PPS_CALIBS : CTL_IF_KERNPPS ( ctl_putint , ( sys_var [ varid ] . text , ntx . calcnt ) ) ;
break ;
case CS_K_PPS_CALIBERRS : CTL_IF_KERNPPS ( ctl_putint , ( sys_var [ varid ] . text , ntx . errcnt ) ) ;
break ;
case CS_K_PPS_JITEXC : CTL_IF_KERNPPS ( ctl_putint , ( sys_var [ varid ] . text , ntx . jitcnt ) ) ;
break ;
case CS_K_PPS_STBEXC : CTL_IF_KERNPPS ( ctl_putint , ( sys_var [ varid ] . text , ntx . stbcnt ) ) ;
break ;
case CS_IOSTATS_RESET : ctl_putuint ( sys_var [ varid ] . text , current_time - io_timereset ) ;
break ;
case CS_TOTAL_RBUF : ctl_putuint ( sys_var [ varid ] . text , total_recvbuffs ( ) ) ;
break ;
case CS_FREE_RBUF : ctl_putuint ( sys_var [ varid ] . text , free_recvbuffs ( ) ) ;
break ;
case CS_USED_RBUF : ctl_putuint ( sys_var [ varid ] . text , full_recvbuffs ( ) ) ;
break ;
case CS_RBUF_LOWATER : ctl_putuint ( sys_var [ varid ] . text , lowater_additions ( ) ) ;
break ;
case CS_IO_DROPPED : ctl_putuint ( sys_var [ varid ] . text , packets_dropped ) ;
break ;
case CS_IO_IGNORED : ctl_putuint ( sys_var [ varid ] . text , packets_ignored ) ;
break ;
case CS_IO_RECEIVED : ctl_putuint ( sys_var [ varid ] . text , packets_received ) ;
break ;
case CS_IO_SENT : ctl_putuint ( sys_var [ varid ] . text , packets_sent ) ;
break ;
case CS_IO_SENDFAILED : ctl_putuint ( sys_var [ varid ] . text , packets_notsent ) ;
break ;
case CS_IO_WAKEUPS : ctl_putuint ( sys_var [ varid ] . text , handler_calls ) ;
break ;
case CS_IO_GOODWAKEUPS : ctl_putuint ( sys_var [ varid ] . text , handler_pkts ) ;
break ;
case CS_TIMERSTATS_RESET : ctl_putuint ( sys_var [ varid ] . text , current_time - timer_timereset ) ;
break ;
case CS_TIMER_OVERRUNS : ctl_putuint ( sys_var [ varid ] . text , alarm_overflow ) ;
break ;
case CS_TIMER_XMTS : ctl_putuint ( sys_var [ varid ] . text , timer_xmtcalls ) ;
break ;
case CS_FUZZ : ctl_putdbl ( sys_var [ varid ] . text , sys_fuzz * 1e3 ) ;
break ;
case CS_WANDER_THRESH : ctl_putdbl ( sys_var [ varid ] . text , wander_threshold * 1e6 ) ;
break ;
# ifdef AUTOKEY case CS_FLAGS : if ( crypto_flags ) ctl_puthex ( sys_var [ CS_FLAGS ] . text , crypto_flags ) ;
break ;
case CS_DIGEST : if ( crypto_flags ) {
strlcpy ( str , OBJ_nid2ln ( crypto_nid ) , COUNTOF ( str ) ) ;
ctl_putstr ( sys_var [ CS_DIGEST ] . text , str , strlen ( str ) ) ;
}
break ;
case CS_SIGNATURE : if ( crypto_flags ) {
const EVP_MD * dp ;
dp = EVP_get_digestbynid ( crypto_flags >> 16 ) ;
strlcpy ( str , OBJ_nid2ln ( EVP_MD_pkey_type ( dp ) ) , COUNTOF ( str ) ) ;
ctl_putstr ( sys_var [ CS_SIGNATURE ] . text , str , strlen ( str ) ) ;
}
break ;
case CS_HOST : if ( hostval . ptr != NULL ) ctl_putstr ( sys_var [ CS_HOST ] . text , hostval . ptr , strlen ( hostval . ptr ) ) ;
break ;
case CS_IDENT : if ( sys_ident != NULL ) ctl_putstr ( sys_var [ CS_IDENT ] . text , sys_ident , strlen ( sys_ident ) ) ;
break ;
case CS_CERTIF : for ( cp = cinfo ;
cp != NULL ;
cp = cp -> link ) {
snprintf ( str , sizeof ( str ) , "%s %s 0x%x" , cp -> subject , cp -> issuer , cp -> flags ) ;
ctl_putstr ( sys_var [ CS_CERTIF ] . text , str , strlen ( str ) ) ;
ctl_putcal ( sys_var [ CS_REVTIME ] . text , & ( cp -> last ) ) ;
}
break ;
case CS_PUBLIC : if ( hostval . tstamp != 0 ) ctl_putfs ( sys_var [ CS_PUBLIC ] . text , ntohl ( hostval . tstamp ) ) ;
break ;
# endif default : break ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | int decodets ( char * str , l_fp * lfp ) {
char * cp ;
char buf [ 30 ] ;
size_t b ;
if ( * str == '0' && ( * ( str + 1 ) == 'x' || * ( str + 1 ) == 'X' ) ) return hextolfp ( str + 2 , lfp ) ;
if ( * str == '"' ) {
cp = str + 1 ;
b = 0 ;
while ( '"' != * cp && '\0' != * cp && b < COUNTOF ( buf ) - 1 ) buf [ b ++ ] = * cp ++ ;
buf [ b ] = '\0' ;
return rtdatetolfp ( buf , lfp ) ;
}
if ( ( * str >= 'A' && * str <= 'F' ) || ( * str >= 'a' && * str <= 'f' ) ) return hextolfp ( str , lfp ) ;
if ( atolfp ( str , lfp ) ) return 1 ;
return rtdatetolfp ( str , lfp ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void option_error_reporter ( enum loglevel level , const char * format , ... ) {
va_list args ;
va_start ( args , format ) ;
if ( level == ERROR_LEVEL || ! opt_bootstrap || global_system_variables . log_warnings ) {
vprint_msg_to_log ( level , format , args ) ;
}
va_end ( args ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static char * fix_path_separator ( char * path ) {
# ifdef WIN32 char * result ;
char * c ;
result = pg_strdup ( path ) ;
for ( c = result ;
* c != '\0' ;
c ++ ) if ( * c == '/' ) * c = '\\' ;
return result ;
# else return path ;
# endif } | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void name ## _free ( type * a ) ;
# define DECLARE_ASN1_PRINT_FUNCTION ( stname ) DECLARE_ASN1_PRINT_FUNCTION_fname ( stname , stname ) # define DECLARE_ASN1_PRINT_FUNCTION_fname ( stname , fname ) int fname ## _print_ctx ( BIO * out , stname * x , int indent , const ASN1_PCTX * pctx ) ;
# define D2I_OF ( type ) type * ( * ) ( type * * , const unsigned char * * , long ) # define I2D_OF ( type ) int ( * ) ( type * , unsigned char * * ) # define I2D_OF_const ( type ) int ( * ) ( const type * , unsigned char * * ) # define CHECKED_D2I_OF ( type , d2i ) ( ( d2i_of_void * ) ( 1 ? d2i : ( ( D2I_OF ( type ) ) 0 ) ) ) # define CHECKED_I2D_OF ( type , i2d ) ( ( i2d_of_void * ) ( 1 ? i2d : ( ( I2D_OF ( type ) ) 0 ) ) ) # define CHECKED_NEW_OF ( type , xnew ) ( ( void * ( * ) ( void ) ) ( 1 ? xnew : ( ( type * ( * ) ( void ) ) 0 ) ) ) # define CHECKED_PTR_OF ( type , p ) ( ( void * ) ( 1 ? p : ( type * ) 0 ) ) # define CHECKED_PPTR_OF ( type , p ) ( ( void * * ) ( 1 ? p : ( type * * ) 0 ) ) # define TYPEDEF_D2I_OF ( type ) typedef type * d2i_of_ ## type ( type * * , const unsigned char * * , long ) # define TYPEDEF_I2D_OF ( type ) typedef int i2d_of_ ## type ( type * , unsigned char * * ) # define TYPEDEF_D2I2D_OF ( type ) TYPEDEF_D2I_OF ( type ) ;
TYPEDEF_I2D_OF ( type ) TYPEDEF_D2I2D_OF ( void ) ;
# ifndef OPENSSL_EXPORT_VAR_AS_FUNCTION typedef const ASN1_ITEM ASN1_ITEM_EXP ;
# define ASN1_ITEM_ptr ( iptr ) ( iptr ) # define ASN1_ITEM_ref ( iptr ) ( & ( iptr ## _it ) ) # define ASN1_ITEM_rptr ( ref ) ( & ( ref ## _it ) ) # define DECLARE_ASN1_ITEM ( name ) OPENSSL_EXTERN const ASN1_ITEM name ## _it ;
# else typedef const ASN1_ITEM * ASN1_ITEM_EXP ( void ) ;
# define ASN1_ITEM_ptr ( iptr ) ( iptr ( ) ) # define ASN1_ITEM_ref ( iptr ) ( iptr ## _it ) # define ASN1_ITEM_rptr ( ref ) ( ref ## _it ( ) ) # define DECLARE_ASN1_ITEM ( name ) const ASN1_ITEM * name ## _it ( void ) ;
# endif # define ASN1_STRFLGS_ESC_2253 1 # define ASN1_STRFLGS_ESC_CTRL 2 # define ASN1_STRFLGS_ESC_MSB 4 # define ASN1_STRFLGS_ESC_QUOTE 8 # define CHARTYPE_PRINTABLESTRING 0x10 # define CHARTYPE_FIRST_ESC_2253 0x20 # define CHARTYPE_LAST_ESC_2253 0x40 # define ASN1_STRFLGS_UTF8_CONVERT 0x10 # define ASN1_STRFLGS_IGNORE_TYPE 0x20 # define ASN1_STRFLGS_SHOW_TYPE 0x40 # define ASN1_STRFLGS_DUMP_ALL 0x80 # define ASN1_STRFLGS_DUMP_UNKNOWN 0x100 # define ASN1_STRFLGS_DUMP_DER 0x200 # define ASN1_STRFLGS_ESC_2254 0x400 # define ASN1_STRFLGS_RFC2253 ( ASN1_STRFLGS_ESC_2253 | ASN1_STRFLGS_ESC_CTRL | ASN1_STRFLGS_ESC_MSB | ASN1_STRFLGS_UTF8_CONVERT | ASN1_STRFLGS_DUMP_UNKNOWN | ASN1_STRFLGS_DUMP_DER ) DEFINE_STACK_OF ( ASN1_INTEGER ) DEFINE_STACK_OF ( ASN1_GENERALSTRING ) DEFINE_STACK_OF ( ASN1_UTF8STRING ) typedef struct asn1_type_st {
int type ;
union {
char * ptr ;
ASN1_BOOLEAN boolean ;
ASN1_STRING * asn1_string ;
ASN1_OBJECT * object ;
ASN1_INTEGER * integer ;
ASN1_ENUMERATED * enumerated ;
ASN1_BIT_STRING * bit_string ;
ASN1_OCTET_STRING * octet_string ;
ASN1_PRINTABLESTRING * printablestring ;
ASN1_T61STRING * t61string ;
ASN1_IA5STRING * ia5string ;
ASN1_GENERALSTRING * generalstring ;
ASN1_BMPSTRING * bmpstring ;
ASN1_UNIVERSALSTRING * universalstring ;
ASN1_UTCTIME * utctime ;
ASN1_GENERALIZEDTIME * generalizedtime ;
ASN1_VISIBLESTRING * visiblestring ;
ASN1_UTF8STRING * utf8string ;
ASN1_STRING * set ;
ASN1_STRING * sequence ;
ASN1_VALUE * asn1_value ;
}
value ;
}
ASN1_TYPE ;
DEFINE_STACK_OF ( ASN1_TYPE ) typedef STACK_OF ( ASN1_TYPE ) ASN1_SEQUENCE_ANY ;
DECLARE_ASN1_ENCODE_FUNCTIONS_const ( ASN1_SEQUENCE_ANY , ASN1_SEQUENCE_ANY ) DECLARE_ASN1_ENCODE_FUNCTIONS_const ( ASN1_SEQUENCE_ANY , ASN1_SET_ANY ) typedef struct BIT_STRING_BITNAME_st {
int bitnum ;
const char * lname ;
const char * sname ;
}
BIT_STRING_BITNAME ;
# define B_ASN1_TIME B_ASN1_UTCTIME | B_ASN1_GENERALIZEDTIME # define B_ASN1_PRINTABLE B_ASN1_NUMERICSTRING | B_ASN1_PRINTABLESTRING | B_ASN1_T61STRING | B_ASN1_IA5STRING | B_ASN1_BIT_STRING | B_ASN1_UNIVERSALSTRING | B_ASN1_BMPSTRING | B_ASN1_UTF8STRING | B_ASN1_SEQUENCE | B_ASN1_UNKNOWN # define B_ASN1_DIRECTORYSTRING B_ASN1_PRINTABLESTRING | B_ASN1_TELETEXSTRING | B_ASN1_BMPSTRING | B_ASN1_UNIVERSALSTRING | B_ASN1_UTF8STRING # define B_ASN1_DISPLAYTEXT B_ASN1_IA5STRING | B_ASN1_VISIBLESTRING | B_ASN1_BMPSTRING | B_ASN1_UTF8STRING DECLARE_ASN1_FUNCTIONS_fname ( ASN1_TYPE , ASN1_ANY , ASN1_TYPE ) int ASN1_TYPE_get ( const ASN1_TYPE * a ) ;
void ASN1_TYPE_set ( ASN1_TYPE * a , int type , void * value ) ;
int ASN1_TYPE_set1 ( ASN1_TYPE * a , int type , const void * value ) ;
int ASN1_TYPE_cmp ( const ASN1_TYPE * a , const ASN1_TYPE * b ) ;
ASN1_TYPE * ASN1_TYPE_pack_sequence ( const ASN1_ITEM * it , void * s , ASN1_TYPE * * t ) ;
void * ASN1_TYPE_unpack_sequence ( const ASN1_ITEM * it , const ASN1_TYPE * t ) ;
ASN1_OBJECT * ASN1_OBJECT_new ( void ) ;
void ASN1_OBJECT_free ( ASN1_OBJECT * a ) ;
int i2d_ASN1_OBJECT ( const ASN1_OBJECT * a , unsigned char * * pp ) ;
ASN1_OBJECT * d2i_ASN1_OBJECT ( ASN1_OBJECT * * a , const unsigned char * * pp , long length ) ;
DECLARE_ASN1_ITEM ( ASN1_OBJECT ) DEFINE_STACK_OF ( ASN1_OBJECT ) ASN1_STRING * ASN1_STRING_new ( void ) ;
void ASN1_STRING_free ( ASN1_STRING * a ) ;
void ASN1_STRING_clear_free ( ASN1_STRING * a ) ;
int ASN1_STRING_copy ( ASN1_STRING * dst , const ASN1_STRING * str ) ;
ASN1_STRING * ASN1_STRING_dup ( const ASN1_STRING * a ) ;
ASN1_STRING * ASN1_STRING_type_new ( int type ) ;
int ASN1_STRING_cmp ( const ASN1_STRING * a , const ASN1_STRING * b ) ;
int ASN1_STRING_set ( ASN1_STRING * str , const void * data , int len ) ;
void ASN1_STRING_set0 ( ASN1_STRING * str , void * data , int len ) ;
int ASN1_STRING_length ( const ASN1_STRING * x ) ;
void ASN1_STRING_length_set ( ASN1_STRING * x , int n ) ;
int ASN1_STRING_type ( const ASN1_STRING * x ) ;
DEPRECATEDIN_1_1_0 ( unsigned char * ASN1_STRING_data ( ASN1_STRING * x ) ) const unsigned char * ASN1_STRING_get0_data ( const ASN1_STRING * x ) ;
DECLARE_ASN1_FUNCTIONS ( ASN1_BIT_STRING ) int ASN1_BIT_STRING_set ( ASN1_BIT_STRING * a , unsigned char * d , int length ) ;
int ASN1_BIT_STRING_set_bit ( ASN1_BIT_STRING * a , int n , int value ) ;
int ASN1_BIT_STRING_get_bit ( const ASN1_BIT_STRING * a , int n ) ;
int ASN1_BIT_STRING_check ( const ASN1_BIT_STRING * a , const unsigned char * flags , int flags_len ) ;
int ASN1_BIT_STRING_name_print ( BIO * out , ASN1_BIT_STRING * bs , BIT_STRING_BITNAME * tbl , int indent ) ;
int ASN1_BIT_STRING_num_asc ( const char * name , BIT_STRING_BITNAME * tbl ) ;
int ASN1_BIT_STRING_set_asc ( ASN1_BIT_STRING * bs , const char * name , int value , BIT_STRING_BITNAME * tbl ) ;
DECLARE_ASN1_FUNCTIONS ( ASN1_INTEGER ) ASN1_INTEGER * d2i_ASN1_UINTEGER ( ASN1_INTEGER * * a , const unsigned char * * pp , long length ) ;
ASN1_INTEGER * ASN1_INTEGER_dup ( const ASN1_INTEGER * x ) ;
int ASN1_INTEGER_cmp ( const ASN1_INTEGER * x , const ASN1_INTEGER * y ) ;
DECLARE_ASN1_FUNCTIONS ( ASN1_ENUMERATED ) int ASN1_UTCTIME_check ( const ASN1_UTCTIME * a ) ;
ASN1_UTCTIME * ASN1_UTCTIME_set ( ASN1_UTCTIME * s , time_t t ) ;
ASN1_UTCTIME * ASN1_UTCTIME_adj ( ASN1_UTCTIME * s , time_t t , int offset_day , long offset_sec ) ;
int ASN1_UTCTIME_set_string ( ASN1_UTCTIME * s , const char * str ) ;
int ASN1_UTCTIME_cmp_time_t ( const ASN1_UTCTIME * s , time_t t ) ;
int ASN1_GENERALIZEDTIME_check ( const ASN1_GENERALIZEDTIME * a ) ;
ASN1_GENERALIZEDTIME * ASN1_GENERALIZEDTIME_set ( ASN1_GENERALIZEDTIME * s , time_t t ) ;
ASN1_GENERALIZEDTIME * ASN1_GENERALIZEDTIME_adj ( ASN1_GENERALIZEDTIME * s , time_t t , int offset_day , long offset_sec ) ;
int ASN1_GENERALIZEDTIME_set_string ( ASN1_GENERALIZEDTIME * s , const char * str ) ;
int ASN1_TIME_diff ( int * pday , int * psec , const ASN1_TIME * from , const ASN1_TIME * to ) ;
DECLARE_ASN1_FUNCTIONS ( ASN1_OCTET_STRING ) ASN1_OCTET_STRING * ASN1_OCTET_STRING_dup ( const ASN1_OCTET_STRING * a ) ;
int ASN1_OCTET_STRING_cmp ( const ASN1_OCTET_STRING * a , const ASN1_OCTET_STRING * b ) ;
int ASN1_OCTET_STRING_set ( ASN1_OCTET_STRING * str , const unsigned char * data , int len ) ;
DECLARE_ASN1_FUNCTIONS ( ASN1_VISIBLESTRING ) DECLARE_ASN1_FUNCTIONS ( ASN1_UNIVERSALSTRING ) DECLARE_ASN1_FUNCTIONS ( ASN1_UTF8STRING ) DECLARE_ASN1_FUNCTIONS ( ASN1_NULL ) DECLARE_ASN1_FUNCTIONS ( ASN1_BMPSTRING ) int UTF8_getc ( const unsigned char * str , int len , unsigned long * val ) ;
int UTF8_putc ( unsigned char * str , int len , unsigned long value ) ;
DECLARE_ASN1_FUNCTIONS_name ( ASN1_STRING , ASN1_PRINTABLE ) DECLARE_ASN1_FUNCTIONS_name ( ASN1_STRING , DIRECTORYSTRING ) DECLARE_ASN1_FUNCTIONS_name ( ASN1_STRING , DISPLAYTEXT ) | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static size_t unicode_to_utf16le ( char * p , size_t remaining , uint32_t uc ) {
char * utf16 = p ;
if ( uc > 0xffff ) {
if ( remaining < 4 ) return ( 0 ) ;
uc -= 0x10000 ;
archive_le16enc ( utf16 , ( ( uc >> 10 ) & 0x3ff ) + 0xD800 ) ;
archive_le16enc ( utf16 + 2 , ( uc & 0x3ff ) + 0xDC00 ) ;
return ( 4 ) ;
}
else {
if ( remaining < 2 ) return ( 0 ) ;
archive_le16enc ( utf16 , uc ) ;
return ( 2 ) ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void my_coll_agg_error ( Item * * args , uint count , const char * fname , int item_sep ) {
if ( count == 2 ) my_coll_agg_error ( args [ 0 ] -> collation , args [ item_sep ] -> collation , fname ) ;
else if ( count == 3 ) my_coll_agg_error ( args [ 0 ] -> collation , args [ item_sep ] -> collation , args [ 2 * item_sep ] -> collation , fname ) ;
else my_error ( ER_CANT_AGGREGATE_NCOLLATIONS , MYF ( 0 ) , fname ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void * evport_init ( struct event_base * base ) {
struct evport_data * evpd ;
int i ;
if ( evutil_getenv ( "EVENT_NOEVPORT" ) ) return ( NULL ) ;
if ( ! ( evpd = calloc ( 1 , sizeof ( struct evport_data ) ) ) ) return ( NULL ) ;
if ( ( evpd -> ed_port = port_create ( ) ) == - 1 ) {
free ( evpd ) ;
return ( NULL ) ;
}
evpd -> ed_fds = calloc ( DEFAULT_NFDS , sizeof ( struct fd_info ) ) ;
if ( evpd -> ed_fds == NULL ) {
close ( evpd -> ed_port ) ;
free ( evpd ) ;
return ( NULL ) ;
}
evpd -> ed_nevents = DEFAULT_NFDS ;
for ( i = 0 ;
i < EVENTS_PER_GETN ;
i ++ ) evpd -> ed_pending [ i ] = - 1 ;
evsignal_init ( base ) ;
return ( evpd ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void xps_draw_radial_gradient ( xps_document * doc , const fz_matrix * ctm , const fz_rect * area , struct stop * stops , int count , fz_xml * root , int spread ) {
float x0 , y0 , r0 ;
float x1 , y1 , r1 ;
float xrad = 1 ;
float yrad = 1 ;
float invscale ;
int i , ma = 1 ;
fz_matrix local_ctm = * ctm ;
fz_matrix inv ;
fz_rect local_area = * area ;
char * center_att = fz_xml_att ( root , "Center" ) ;
char * origin_att = fz_xml_att ( root , "GradientOrigin" ) ;
char * radius_x_att = fz_xml_att ( root , "RadiusX" ) ;
char * radius_y_att = fz_xml_att ( root , "RadiusY" ) ;
x0 = y0 = 0.0 ;
x1 = y1 = 1.0 ;
xrad = 1.0 ;
yrad = 1.0 ;
if ( origin_att ) xps_parse_point ( origin_att , & x0 , & y0 ) ;
if ( center_att ) xps_parse_point ( center_att , & x1 , & y1 ) ;
if ( radius_x_att ) xrad = fz_atof ( radius_x_att ) ;
if ( radius_y_att ) yrad = fz_atof ( radius_y_att ) ;
xrad = fz_max ( 0.01f , xrad ) ;
yrad = fz_max ( 0.01f , yrad ) ;
if ( fz_abs ( xrad ) > FLT_EPSILON ) {
fz_pre_scale ( & local_ctm , 1 , yrad / xrad ) ;
}
if ( yrad != 0.0 ) {
invscale = xrad / yrad ;
y0 = y0 * invscale ;
y1 = y1 * invscale ;
}
r0 = 0 ;
r1 = xrad ;
fz_transform_rect ( & local_area , fz_invert_matrix ( & inv , & local_ctm ) ) ;
ma = fz_maxi ( ma , ceilf ( hypotf ( local_area . x0 - x0 , local_area . y0 - y0 ) / xrad ) ) ;
ma = fz_maxi ( ma , ceilf ( hypotf ( local_area . x1 - x0 , local_area . y0 - y0 ) / xrad ) ) ;
ma = fz_maxi ( ma , ceilf ( hypotf ( local_area . x0 - x0 , local_area . y1 - y0 ) / xrad ) ) ;
ma = fz_maxi ( ma , ceilf ( hypotf ( local_area . x1 - x0 , local_area . y1 - y0 ) / xrad ) ) ;
if ( spread == SPREAD_REPEAT ) {
for ( i = ma - 1 ;
i >= 0 ;
i -- ) xps_draw_one_radial_gradient ( doc , & local_ctm , stops , count , 0 , x0 , y0 , r0 + i * xrad , x1 , y1 , r1 + i * xrad ) ;
}
else if ( spread == SPREAD_REFLECT ) {
if ( ( ma % 2 ) != 0 ) ma ++ ;
for ( i = ma - 2 ;
i >= 0 ;
i -= 2 ) {
xps_draw_one_radial_gradient ( doc , & local_ctm , stops , count , 0 , x0 , y0 , r0 + i * xrad , x1 , y1 , r1 + i * xrad ) ;
xps_draw_one_radial_gradient ( doc , & local_ctm , stops , count , 0 , x0 , y0 , r0 + ( i + 2 ) * xrad , x1 , y1 , r1 + i * xrad ) ;
}
}
else {
xps_draw_one_radial_gradient ( doc , & local_ctm , stops , count , 1 , x0 , y0 , r0 , x1 , y1 , r1 ) ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int decorrelate ( TAKDecContext * s , int c1 , int c2 , int length ) {
GetBitContext * gb = & s -> gb ;
int32_t * p1 = s -> decoded [ c1 ] + 1 ;
int32_t * p2 = s -> decoded [ c2 ] + 1 ;
int i ;
int dshift , dfactor ;
switch ( s -> dmode ) {
case 1 : for ( i = 0 ;
i < length ;
i ++ ) {
int32_t a = p1 [ i ] ;
int32_t b = p2 [ i ] ;
p2 [ i ] = a + b ;
}
break ;
case 2 : for ( i = 0 ;
i < length ;
i ++ ) {
int32_t a = p1 [ i ] ;
int32_t b = p2 [ i ] ;
p1 [ i ] = b - a ;
}
break ;
case 3 : for ( i = 0 ;
i < length ;
i ++ ) {
int32_t a = p1 [ i ] ;
int32_t b = p2 [ i ] ;
a -= b >> 1 ;
p1 [ i ] = a ;
p2 [ i ] = a + b ;
}
break ;
case 4 : FFSWAP ( int32_t * , p1 , p2 ) ;
case 5 : dshift = get_bits_esc4 ( gb ) ;
dfactor = get_sbits ( gb , 10 ) ;
for ( i = 0 ;
i < length ;
i ++ ) {
int32_t a = p1 [ i ] ;
int32_t b = p2 [ i ] ;
b = dfactor * ( b >> dshift ) + 128 >> 8 << dshift ;
p1 [ i ] = b - a ;
}
break ;
case 6 : FFSWAP ( int32_t * , p1 , p2 ) ;
case 7 : {
LOCAL_ALIGNED_16 ( int16_t , filter , [ MAX_PREDICTORS ] ) ;
int length2 , order_half , filter_order , dval1 , dval2 ;
int av_uninit ( code_size ) ;
memset ( filter , 0 , MAX_PREDICTORS * sizeof ( * filter ) ) ;
if ( length < 256 ) return AVERROR_INVALIDDATA ;
dshift = get_bits_esc4 ( gb ) ;
filter_order = 8 << get_bits1 ( gb ) ;
dval1 = get_bits1 ( gb ) ;
dval2 = get_bits1 ( gb ) ;
for ( i = 0 ;
i < filter_order ;
i ++ ) {
if ( ! ( i & 3 ) ) code_size = 14 - get_bits ( gb , 3 ) ;
filter [ i ] = get_sbits ( gb , code_size ) ;
}
order_half = filter_order / 2 ;
length2 = length - ( filter_order - 1 ) ;
if ( dval1 ) {
for ( i = 0 ;
i < order_half ;
i ++ ) {
int32_t a = p1 [ i ] ;
int32_t b = p2 [ i ] ;
p1 [ i ] = a + b ;
}
}
if ( dval2 ) {
for ( i = length2 + order_half ;
i < length ;
i ++ ) {
int32_t a = p1 [ i ] ;
int32_t b = p2 [ i ] ;
p1 [ i ] = a + b ;
}
}
av_fast_malloc ( & s -> residues , & s -> residues_buf_size , FFALIGN ( length + 16 , 16 ) * sizeof ( * s -> residues ) ) ;
if ( ! s -> residues ) return AVERROR ( ENOMEM ) ;
memset ( s -> residues , 0 , s -> residues_buf_size ) ;
for ( i = 0 ;
i < length ;
i ++ ) s -> residues [ i ] = p2 [ i ] >> dshift ;
p1 += order_half ;
for ( i = 0 ;
i < length2 ;
i ++ ) {
int v = 1 << 9 ;
v += s -> dsp . scalarproduct_int16 ( & s -> residues [ i ] , filter , FFALIGN ( filter_order , 16 ) ) ;
p1 [ i ] = ( av_clip ( v >> 10 , - 8192 , 8191 ) << dshift ) - p1 [ i ] ;
}
emms_c ( ) ;
break ;
}
}
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static const char * cmd_geo_lookup_db ( cmd_parms * cmd , void * _dcfg , const char * p1 ) {
const char * filename = resolve_relative_path ( cmd -> pool , cmd -> directive -> filename , p1 ) ;
char * error_msg ;
directory_config * dcfg = ( directory_config * ) _dcfg ;
if ( dcfg == NULL ) return NULL ;
if ( geo_init ( dcfg , filename , & error_msg ) <= 0 ) {
return error_msg ;
}
return NULL ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | PHP_FUNCTION ( locale_get_display_variant ) {
get_icu_disp_value_src_php ( LOC_VARIANT_TAG , INTERNAL_FUNCTION_PARAM_PASSTHRU ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int xhci_setup_packet ( XHCITransfer * xfer ) {
USBEndpoint * ep ;
int dir ;
dir = xfer -> in_xfer ? USB_TOKEN_IN : USB_TOKEN_OUT ;
if ( xfer -> packet . ep ) {
ep = xfer -> packet . ep ;
}
else {
ep = xhci_epid_to_usbep ( xfer -> epctx ) ;
if ( ! ep ) {
DPRINTF ( "xhci: slot %d has no device\n" , xfer -> slotid ) ;
return - 1 ;
}
}
xhci_xfer_create_sgl ( xfer , dir == USB_TOKEN_IN ) ;
usb_packet_setup ( & xfer -> packet , dir , ep , xfer -> streamid , xfer -> trbs [ 0 ] . addr , false , xfer -> int_req ) ;
usb_packet_map ( & xfer -> packet , & xfer -> sgl ) ;
DPRINTF ( "xhci: setup packet pid 0x%x addr %d ep %d\n" , xfer -> packet . pid , ep -> dev -> addr , ep -> nr ) ;
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | hidden_def ( _nss_dns_gethostbyname3_r ) enum nss_status _nss_dns_gethostbyname2_r ( const char * name , int af , struct hostent * result , char * buffer , size_t buflen , int * errnop , int * h_errnop ) {
return _nss_dns_gethostbyname3_r ( name , af , result , buffer , buflen , errnop , h_errnop , NULL , NULL ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void encode_nonrd_sb_row ( VP9_COMP * cpi , const TileInfo * const tile , int mi_row , TOKENEXTRA * * tp ) {
SPEED_FEATURES * const sf = & cpi -> sf ;
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCK * const x = & cpi -> mb ;
MACROBLOCKD * const xd = & x -> e_mbd ;
int mi_col ;
vpx_memset ( & xd -> left_context , 0 , sizeof ( xd -> left_context ) ) ;
vpx_memset ( xd -> left_seg_context , 0 , sizeof ( xd -> left_seg_context ) ) ;
for ( mi_col = tile -> mi_col_start ;
mi_col < tile -> mi_col_end ;
mi_col += MI_BLOCK_SIZE ) {
int dummy_rate = 0 ;
int64_t dummy_dist = 0 ;
const int idx_str = cm -> mi_stride * mi_row + mi_col ;
MODE_INFO * * mi = cm -> mi_grid_visible + idx_str ;
MODE_INFO * * prev_mi = cm -> prev_mi_grid_visible + idx_str ;
BLOCK_SIZE bsize ;
x -> in_static_area = 0 ;
x -> source_variance = UINT_MAX ;
vp9_zero ( x -> pred_mv ) ;
switch ( sf -> partition_search_type ) {
case VAR_BASED_PARTITION : choose_partitioning ( cpi , tile , mi_row , mi_col ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
break ;
case SOURCE_VAR_BASED_PARTITION : set_source_var_based_partition ( cpi , tile , mi , mi_row , mi_col ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
break ;
case VAR_BASED_FIXED_PARTITION : case FIXED_PARTITION : bsize = sf -> partition_search_type == FIXED_PARTITION ? sf -> always_this_block_size : get_nonrd_var_based_fixed_partition ( cpi , mi_row , mi_col ) ;
set_fixed_partitioning ( cpi , tile , mi , mi_row , mi_col , bsize ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
break ;
case REFERENCE_PARTITION : if ( sf -> partition_check || ! ( x -> in_static_area = is_background ( cpi , tile , mi_row , mi_col ) ) ) {
set_modeinfo_offsets ( cm , xd , mi_row , mi_col ) ;
auto_partition_range ( cpi , tile , mi_row , mi_col , & sf -> min_partition_size , & sf -> max_partition_size ) ;
nonrd_pick_partition ( cpi , tile , tp , mi_row , mi_col , BLOCK_64X64 , & dummy_rate , & dummy_dist , 1 , INT64_MAX , cpi -> pc_root ) ;
}
else {
copy_partitioning ( cm , mi , prev_mi ) ;
nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , BLOCK_64X64 , 1 , & dummy_rate , & dummy_dist , cpi -> pc_root ) ;
}
break ;
default : assert ( 0 ) ;
break ;
}
}
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | IN_PROC_BROWSER_TEST_P ( DetachToBrowserTabDragControllerTest , DragInSameWindow ) {
if ( input_source ( ) == INPUT_SOURCE_TOUCH ) {
VLOG ( 1 ) << "Test is DISABLED for touch input." ;
return ;
}
AddTabAndResetBrowser ( browser ( ) ) ;
TabStrip * tab_strip = GetTabStripForBrowser ( browser ( ) ) ;
TabStripModel * model = browser ( ) -> tab_strip_model ( ) ;
gfx : : Point tab_1_center ( GetCenterInScreenCoordinates ( tab_strip -> tab_at ( 1 ) ) ) ;
ASSERT_TRUE ( PressInput ( tab_1_center ) ) ;
gfx : : Point tab_0_center ( GetCenterInScreenCoordinates ( tab_strip -> tab_at ( 0 ) ) ) ;
ASSERT_TRUE ( DragInputTo ( tab_0_center ) ) ;
ASSERT_TRUE ( ReleaseInput ( ) ) ;
EXPECT_EQ ( "1 0" , IDString ( model ) ) ;
EXPECT_FALSE ( TabDragController : : IsActive ( ) ) ;
EXPECT_FALSE ( tab_strip -> IsDragSessionActive ( ) ) ;
EXPECT_FALSE ( tab_strip -> GetWidget ( ) -> HasCapture ( ) ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | int isprint ( int c ) {
return ( ( c > 31 && c < 127 ) ? 1 : 0 ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | SPL_METHOD ( SplFileInfo , func_name ) \ {
\ spl_filesystem_object * intern = ( spl_filesystem_object * ) zend_object_store_get_object ( getThis ( ) TSRMLS_CC ) ;
\ zend_error_handling error_handling ;
\ if ( zend_parse_parameters_none ( ) == FAILURE ) {
\ return ;
\ }
\ \ zend_replace_error_handling ( EH_THROW , spl_ce_RuntimeException , & error_handling TSRMLS_CC ) ;
\ spl_filesystem_object_get_file_name ( intern TSRMLS_CC ) ;
\ php_stat ( intern -> file_name , intern -> file_name_len , func_num , return_value TSRMLS_CC ) ;
\ zend_restore_error_handling ( & error_handling TSRMLS_CC ) ;
\ }
FileInfoFunction ( getPerms , FS_PERMS ) FileInfoFunction ( getInode , FS_INODE ) FileInfoFunction ( getSize , FS_SIZE ) FileInfoFunction ( getOwner , FS_OWNER ) FileInfoFunction ( getGroup , FS_GROUP ) FileInfoFunction ( getATime , FS_ATIME ) FileInfoFunction ( getMTime , FS_MTIME ) | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int main_pipe_copier ( uint8_t * pipe_buf , usize_t pipe_bufsize , size_t nread , main_file * ifile , int outfd ) {
int ret ;
xoff_t skipped = 0 ;
struct sigaction sa ;
sa . sa_handler = SIG_IGN ;
sigaction ( SIGPIPE , & sa , NULL ) ;
for ( ;
;
) {
int force_drain = 0 ;
if ( nread > 0 && ( ret = main_pipe_write ( outfd , pipe_buf , nread ) ) ) {
if ( ret == EPIPE ) {
skipped += nread ;
force_drain = 1 ;
}
else {
XPR ( NT "pipe write failed: %s\n" , xd3_mainerror ( ret ) ) ;
return ret ;
}
}
if ( nread < pipe_bufsize && ! force_drain ) {
break ;
}
if ( ( ret = main_file_read ( ifile , pipe_buf , pipe_bufsize , & nread , "pipe read failed" ) ) < 0 ) {
return ret ;
}
}
if ( option_verbose && skipped != 0 ) {
XPR ( NT "skipping %" Q "u bytes in %s\n" , skipped , ifile -> filename ) ;
}
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | IN_PROC_BROWSER_TEST_F ( DownloadExtensionTest , MAYBE_DownloadExtensionTest_OnDeterminingFilename_ReservedFilename ) {
GoOnTheRecord ( ) ;
LoadExtension ( "downloads_split" ) ;
AddFilenameDeterminer ( ) ;
ASSERT_TRUE ( StartEmbeddedTestServer ( ) ) ;
std : : string download_url = embedded_test_server ( ) -> GetURL ( "/slow?0" ) . spec ( ) ;
std : : unique_ptr < base : : Value > result ( RunFunctionAndReturnResult ( new DownloadsDownloadFunction ( ) , base : : StringPrintf ( "[{
\"url\": \"%s\"}
]" , download_url . c_str ( ) ) ) ) ;
ASSERT_TRUE ( result . get ( ) ) ;
int result_id = - 1 ;
ASSERT_TRUE ( result -> GetAsInteger ( & result_id ) ) ;
DownloadItem * item = GetCurrentManager ( ) -> GetDownload ( result_id ) ;
ASSERT_TRUE ( item ) ;
ScopedCancellingItem canceller ( item ) ;
ASSERT_EQ ( download_url , item -> GetOriginalUrl ( ) . spec ( ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnCreated : : kEventName , base : : StringPrintf ( "[{
\"danger\": \"safe\"," " \"incognito\": false," " \"id\": %d," " \"mime\": \"text/plain\"," " \"paused\": false," " \"url\": \"%s\"}
]" , result_id , download_url . c_str ( ) ) ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnDeterminingFilename : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"filename\":\"slow.txt\"}
]" , result_id ) ) ) ;
ASSERT_TRUE ( item -> GetTargetFilePath ( ) . empty ( ) ) ;
ASSERT_EQ ( DownloadItem : : IN_PROGRESS , item -> GetState ( ) ) ;
std : : string error ;
ASSERT_FALSE ( ExtensionDownloadsEventRouter : : DetermineFilename ( browser ( ) -> profile ( ) , false , GetExtensionId ( ) , result_id , base : : FilePath ( FILE_PATH_LITERAL ( "con.foo" ) ) , downloads : : FILENAME_CONFLICT_ACTION_UNIQUIFY , & error ) ) ;
EXPECT_STREQ ( errors : : kInvalidFilename , error . c_str ( ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnChanged : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"filename\": {
" " \"previous\": \"\"," " \"current\": \"%s\"}
}
]" , result_id , GetFilename ( "slow.txt" ) . c_str ( ) ) ) ) ;
ASSERT_TRUE ( WaitFor ( downloads : : OnChanged : : kEventName , base : : StringPrintf ( "[{
\"id\": %d," " \"state\": {
" " \"previous\": \"in_progress\"," " \"current\": \"complete\"}
}
]" , result_id ) ) ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | TSReturnCode TSHttpTxnConfigStringGet ( TSHttpTxn txnp , TSOverridableConfigKey conf , const char * * value , int * length ) {
sdk_assert ( sdk_sanity_check_txn ( txnp ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * * ) value ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_null_ptr ( ( void * ) length ) == TS_SUCCESS ) ;
HttpSM * sm = ( HttpSM * ) txnp ;
switch ( conf ) {
case TS_CONFIG_HTTP_RESPONSE_SERVER_STR : * value = sm -> t_state . txn_conf -> proxy_response_server_string ;
* length = sm -> t_state . txn_conf -> proxy_response_server_string_len ;
break ;
case TS_CONFIG_HTTP_GLOBAL_USER_AGENT_HEADER : * value = sm -> t_state . txn_conf -> global_user_agent_header ;
* length = sm -> t_state . txn_conf -> global_user_agent_header_size ;
break ;
case TS_CONFIG_BODY_FACTORY_TEMPLATE_BASE : * value = sm -> t_state . txn_conf -> body_factory_template_base ;
* length = sm -> t_state . txn_conf -> body_factory_template_base_len ;
break ;
default : return TS_ERROR ;
break ;
}
return TS_SUCCESS ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void sbr_hf_g_filt_c ( float ( * Y ) [ 2 ] , const float ( * X_high ) [ 40 ] [ 2 ] , const float * g_filt , int m_max , intptr_t ixh ) {
int m ;
for ( m = 0 ;
m < m_max ;
m ++ ) {
Y [ m ] [ 0 ] = X_high [ m ] [ ixh ] [ 0 ] * g_filt [ m ] ;
Y [ m ] [ 1 ] = X_high [ m ] [ ixh ] [ 1 ] * g_filt [ m ] ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void TSHttpTxnOverwriteExpireTime ( TSHttpTxn txnp , time_t expire_time ) {
sdk_assert ( sdk_sanity_check_txn ( txnp ) == TS_SUCCESS ) ;
HttpTransact : : State * s = & ( ( ( HttpSM * ) txnp ) -> t_state ) ;
s -> plugin_set_expire_time = expire_time ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | int proto_registrar_get_parent ( const int n ) {
header_field_info * hfinfo ;
PROTO_REGISTRAR_GET_NTH ( n , hfinfo ) ;
return hfinfo -> parent ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | TSReturnCode sdk_sanity_check_url_handle ( TSMLoc field ) {
if ( field == TS_NULL_MLOC ) {
return TS_ERROR ;
}
MIMEFieldSDKHandle * field_handle = ( MIMEFieldSDKHandle * ) field ;
if ( field_handle -> m_type != HDR_HEAP_OBJ_URL ) {
return TS_ERROR ;
}
return TS_SUCCESS ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void link_info_read_state_free ( LinkInfoReadState * state ) {
g_object_unref ( state -> cancellable ) ;
g_free ( state ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void * pdf_new_processor ( fz_context * ctx , int size ) {
return Memento_label ( fz_calloc ( ctx , 1 , size ) , "pdf_processor" ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | xmlHashTablePtr xmlHashCopy ( xmlHashTablePtr table , xmlHashCopier f ) {
int i ;
xmlHashEntryPtr iter ;
xmlHashEntryPtr next ;
xmlHashTablePtr ret ;
if ( table == NULL ) return ( NULL ) ;
if ( f == NULL ) return ( NULL ) ;
ret = xmlHashCreate ( table -> size ) ;
if ( ret == NULL ) return ( NULL ) ;
if ( table -> table ) {
for ( i = 0 ;
i < table -> size ;
i ++ ) {
if ( table -> table [ i ] . valid == 0 ) continue ;
iter = & ( table -> table [ i ] ) ;
while ( iter ) {
next = iter -> next ;
xmlHashAddEntry3 ( ret , iter -> name , iter -> name2 , iter -> name3 , f ( iter -> payload , iter -> name ) ) ;
iter = next ;
}
}
}
ret -> nbElems = table -> nbElems ;
return ( ret ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void nlm_match_fhandle_request ( packet_info * pinfo , proto_tree * tree ) {
nlm_msg_res_matched_data * md ;
md = ( nlm_msg_res_matched_data * ) g_hash_table_lookup ( nlm_msg_res_matched , GINT_TO_POINTER ( pinfo -> fd -> num ) ) ;
if ( md && md -> rep_frame ) {
dissect_fhandle_hidden ( pinfo , tree , md -> rep_frame ) ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static vpx_codec_err_t ctrl_get_reference ( vpx_codec_alg_priv_t * ctx , va_list args ) {
vp9_ref_frame_t * const frame = va_arg ( args , vp9_ref_frame_t * ) ;
if ( frame != NULL ) {
YV12_BUFFER_CONFIG * fb = get_ref_frame ( & ctx -> cpi -> common , frame -> idx ) ;
if ( fb == NULL ) return VPX_CODEC_ERROR ;
yuvconfig2image ( & frame -> img , fb , NULL ) ;
return VPX_CODEC_OK ;
}
else {
return VPX_CODEC_INVALID_PARAM ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void auto_partition_range ( VP9_COMP * cpi , const TileInfo * const tile , int mi_row , int mi_col , BLOCK_SIZE * min_block_size , BLOCK_SIZE * max_block_size ) {
VP9_COMMON * const cm = & cpi -> common ;
MACROBLOCKD * const xd = & cpi -> mb . e_mbd ;
MODE_INFO * * mi_8x8 = xd -> mi ;
const int left_in_image = xd -> left_available && mi_8x8 [ - 1 ] ;
const int above_in_image = xd -> up_available && mi_8x8 [ - xd -> mi_stride ] ;
int row8x8_remaining = tile -> mi_row_end - mi_row ;
int col8x8_remaining = tile -> mi_col_end - mi_col ;
int bh , bw ;
BLOCK_SIZE min_size = BLOCK_32X32 ;
BLOCK_SIZE max_size = BLOCK_8X8 ;
int bsl = mi_width_log2 ( BLOCK_64X64 ) ;
const int search_range_ctrl = ( ( ( mi_row + mi_col ) >> bsl ) + get_chessboard_index ( cm -> current_video_frame ) ) & 0x1 ;
if ( search_range_ctrl && ( left_in_image || above_in_image || cm -> frame_type != KEY_FRAME ) ) {
int block ;
MODE_INFO * * mi ;
BLOCK_SIZE sb_type ;
if ( left_in_image ) {
MODE_INFO * cur_mi ;
mi = & mi_8x8 [ - 1 ] ;
for ( block = 0 ;
block < MI_BLOCK_SIZE ;
++ block ) {
cur_mi = mi [ block * xd -> mi_stride ] ;
sb_type = cur_mi ? cur_mi -> mbmi . sb_type : 0 ;
min_size = MIN ( min_size , sb_type ) ;
max_size = MAX ( max_size , sb_type ) ;
}
}
if ( above_in_image ) {
mi = & mi_8x8 [ - xd -> mi_stride * MI_BLOCK_SIZE ] ;
for ( block = 0 ;
block < MI_BLOCK_SIZE ;
++ block ) {
sb_type = mi [ block ] ? mi [ block ] -> mbmi . sb_type : 0 ;
min_size = MIN ( min_size , sb_type ) ;
max_size = MAX ( max_size , sb_type ) ;
}
}
min_size = min_partition_size [ min_size ] ;
max_size = find_partition_size ( max_size , row8x8_remaining , col8x8_remaining , & bh , & bw ) ;
min_size = MIN ( min_size , max_size ) ;
min_size = MAX ( min_size , BLOCK_8X8 ) ;
max_size = MIN ( max_size , BLOCK_32X32 ) ;
}
else {
min_size = BLOCK_8X8 ;
max_size = BLOCK_32X32 ;
}
* min_block_size = min_size ;
* max_block_size = max_size ;
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | static bool async_pf_msr_needed ( void * opaque ) {
X86CPU * cpu = opaque ;
return cpu -> env . async_pf_en_msr != 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | xmlLinkPtr xmlListEnd ( xmlListPtr l ) {
if ( l == NULL ) return ( NULL ) ;
return ( l -> sentinel -> prev ) ;
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | static toff_t _tiffSizeProc ( thandle_t fd ) {
_TIFF_stat_s sb ;
return ( toff_t ) ( _TIFF_fstat_f ( ( int ) fd , & sb ) < 0 ? 0 : sb . st_size ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | vpx_codec_err_t vpx_codec_set_cx_data_buf ( vpx_codec_ctx_t * ctx , const vpx_fixed_buf_t * buf , unsigned int pad_before , unsigned int pad_after ) {
if ( ! ctx || ! ctx -> priv ) return VPX_CODEC_INVALID_PARAM ;
if ( buf ) {
ctx -> priv -> enc . cx_data_dst_buf = * buf ;
ctx -> priv -> enc . cx_data_pad_before = pad_before ;
ctx -> priv -> enc . cx_data_pad_after = pad_after ;
}
else {
ctx -> priv -> enc . cx_data_dst_buf . buf = NULL ;
ctx -> priv -> enc . cx_data_dst_buf . sz = 0 ;
ctx -> priv -> enc . cx_data_pad_before = 0 ;
ctx -> priv -> enc . cx_data_pad_after = 0 ;
}
return VPX_CODEC_OK ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | struct zip_cdir * _zip_cdir_new ( int nentry , struct zip_error * error ) {
struct zip_cdir * cd ;
if ( ( cd = ( struct zip_cdir * ) malloc ( sizeof ( * cd ) ) ) == NULL ) {
_zip_error_set ( error , ZIP_ER_MEMORY , 0 ) ;
return NULL ;
}
if ( ( cd -> entry = ( struct zip_dirent * ) malloc ( sizeof ( * ( cd -> entry ) ) * nentry ) ) == NULL ) {
_zip_error_set ( error , ZIP_ER_MEMORY , 0 ) ;
free ( cd ) ;
return NULL ;
}
cd -> nentry = nentry ;
cd -> size = cd -> offset = 0 ;
cd -> comment = NULL ;
cd -> comment_len = 0 ;
return cd ;
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | static void idr_set_num_beutf16 ( unsigned char * p , int num ) {
static const uint16_t xdig [ ] = {
0x0030 , 0x0031 , 0x0032 , 0x0033 , 0x0034 , 0x0035 , 0x0036 , 0x0037 , 0x0038 , 0x0039 , 0x0041 , 0x0042 , 0x0043 , 0x0044 , 0x0045 , 0x0046 , 0x0047 , 0x0048 , 0x0049 , 0x004A , 0x004B , 0x004C , 0x004D , 0x004E , 0x004F , 0x0050 , 0x0051 , 0x0052 , 0x0053 , 0x0054 , 0x0055 , 0x0056 , 0x0057 , 0x0058 , 0x0059 , 0x005A }
;
# define XDIG_CNT ( sizeof ( xdig ) / sizeof ( xdig [ 0 ] ) ) num %= XDIG_CNT * XDIG_CNT * XDIG_CNT ;
archive_be16enc ( p , xdig [ ( num / ( XDIG_CNT * XDIG_CNT ) ) ] ) ;
num %= XDIG_CNT * XDIG_CNT ;
archive_be16enc ( p + 2 , xdig [ ( num / XDIG_CNT ) ] ) ;
num %= XDIG_CNT ;
archive_be16enc ( p + 4 , xdig [ num ] ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int tipc_nl_compat_name_table_dump ( struct tipc_nl_compat_msg * msg , struct nlattr * * attrs ) {
char port_str [ 27 ] ;
struct tipc_name_table_query * ntq ;
struct nlattr * nt [ TIPC_NLA_NAME_TABLE_MAX + 1 ] ;
struct nlattr * publ [ TIPC_NLA_PUBL_MAX + 1 ] ;
u32 node , depth , type , lowbound , upbound ;
static const char * const scope_str [ ] = {
"" , " zone" , " cluster" , " node" }
;
int err ;
if ( ! attrs [ TIPC_NLA_NAME_TABLE ] ) return - EINVAL ;
err = nla_parse_nested ( nt , TIPC_NLA_NAME_TABLE_MAX , attrs [ TIPC_NLA_NAME_TABLE ] , NULL ) ;
if ( err ) return err ;
if ( ! nt [ TIPC_NLA_NAME_TABLE_PUBL ] ) return - EINVAL ;
err = nla_parse_nested ( publ , TIPC_NLA_PUBL_MAX , nt [ TIPC_NLA_NAME_TABLE_PUBL ] , NULL ) ;
if ( err ) return err ;
ntq = ( struct tipc_name_table_query * ) TLV_DATA ( msg -> req ) ;
depth = ntohl ( ntq -> depth ) ;
type = ntohl ( ntq -> type ) ;
lowbound = ntohl ( ntq -> lowbound ) ;
upbound = ntohl ( ntq -> upbound ) ;
if ( ! ( depth & TIPC_NTQ_ALLTYPES ) && ( type != nla_get_u32 ( publ [ TIPC_NLA_PUBL_TYPE ] ) ) ) return 0 ;
if ( lowbound && ( lowbound > nla_get_u32 ( publ [ TIPC_NLA_PUBL_UPPER ] ) ) ) return 0 ;
if ( upbound && ( upbound < nla_get_u32 ( publ [ TIPC_NLA_PUBL_LOWER ] ) ) ) return 0 ;
tipc_tlv_sprintf ( msg -> rep , "%-10u " , nla_get_u32 ( publ [ TIPC_NLA_PUBL_TYPE ] ) ) ;
if ( depth == 1 ) goto out ;
tipc_tlv_sprintf ( msg -> rep , "%-10u %-10u " , nla_get_u32 ( publ [ TIPC_NLA_PUBL_LOWER ] ) , nla_get_u32 ( publ [ TIPC_NLA_PUBL_UPPER ] ) ) ;
if ( depth == 2 ) goto out ;
node = nla_get_u32 ( publ [ TIPC_NLA_PUBL_NODE ] ) ;
sprintf ( port_str , "<%u.%u.%u:%u>" , tipc_zone ( node ) , tipc_cluster ( node ) , tipc_node ( node ) , nla_get_u32 ( publ [ TIPC_NLA_PUBL_REF ] ) ) ;
tipc_tlv_sprintf ( msg -> rep , "%-26s " , port_str ) ;
if ( depth == 3 ) goto out ;
tipc_tlv_sprintf ( msg -> rep , "%-10u %s" , nla_get_u32 ( publ [ TIPC_NLA_PUBL_KEY ] ) , scope_str [ nla_get_u32 ( publ [ TIPC_NLA_PUBL_SCOPE ] ) ] ) ;
out : tipc_tlv_sprintf ( msg -> rep , "\n" ) ;
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void vp9_print_modes_and_motion_vectors ( VP9_COMMON * cm , const char * file ) {
int mi_row ;
int mi_col ;
int mi_index = 0 ;
FILE * mvs = fopen ( file , "a" ) ;
MODE_INFO * * mi = cm -> mi_grid_visible ;
int rows = cm -> mi_rows ;
int cols = cm -> mi_cols ;
print_mi_data ( cm , mvs , "Partitions:" , offsetof ( MB_MODE_INFO , sb_type ) ) ;
print_mi_data ( cm , mvs , "Modes:" , offsetof ( MB_MODE_INFO , mode ) ) ;
print_mi_data ( cm , mvs , "Skips:" , offsetof ( MB_MODE_INFO , skip ) ) ;
print_mi_data ( cm , mvs , "Ref frame:" , offsetof ( MB_MODE_INFO , ref_frame [ 0 ] ) ) ;
print_mi_data ( cm , mvs , "Transform:" , offsetof ( MB_MODE_INFO , tx_size ) ) ;
print_mi_data ( cm , mvs , "UV Modes:" , offsetof ( MB_MODE_INFO , uv_mode ) ) ;
log_frame_info ( cm , "Vectors " , mvs ) ;
for ( mi_row = 0 ;
mi_row < rows ;
mi_row ++ ) {
fprintf ( mvs , "V " ) ;
for ( mi_col = 0 ;
mi_col < cols ;
mi_col ++ ) {
fprintf ( mvs , "%4d:%4d " , mi [ mi_index ] -> mbmi . mv [ 0 ] . as_mv . row , mi [ mi_index ] -> mbmi . mv [ 0 ] . as_mv . col ) ;
mi_index ++ ;
}
fprintf ( mvs , "\n" ) ;
mi_index += 8 ;
}
fprintf ( mvs , "\n" ) ;
fclose ( mvs ) ;
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | static void gx_ttfReader__Seek ( ttfReader * self , int nPos ) {
gx_ttfReader * r = ( gx_ttfReader * ) self ;
r -> pos = nPos ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void set_alloc_limit ( size_t size ) {
alloc_limit = size ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int s_aos_available ( stream * s , gs_offset_t * pl ) {
* pl = ( ( aos_state_t * ) s -> state ) -> file_sz - stell ( s ) ;
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | Selectivity boolvarsel ( PlannerInfo * root , Node * arg , int varRelid ) {
VariableStatData vardata ;
double selec ;
examine_variable ( root , arg , varRelid , & vardata ) ;
if ( HeapTupleIsValid ( vardata . statsTuple ) ) {
selec = var_eq_const ( & vardata , BooleanEqualOperator , BoolGetDatum ( true ) , false , true ) ;
}
else if ( is_funcclause ( arg ) ) {
selec = 0.3333333 ;
}
else {
selec = 0.5 ;
}
ReleaseVariableStats ( vardata ) ;
return selec ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static inline void e1000e_read_ext_rx_descr ( E1000ECore * core , uint8_t * desc , hwaddr * buff_addr ) {
union e1000_rx_desc_extended * d = ( union e1000_rx_desc_extended * ) desc ;
* buff_addr = le64_to_cpu ( d -> read . buffer_addr ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static guint prplcb_ev_input_add ( int fd , PurpleInputCondition cond , PurpleInputFunction func , gpointer udata ) {
return b_input_add ( fd , cond | B_EV_FLAG_FORCE_REPEAT , ( b_event_handler ) func , udata ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void ImportGrayQuantum ( const Image * image , QuantumInfo * quantum_info , const MagickSizeType number_pixels , const unsigned char * magick_restrict p , Quantum * magick_restrict q , ExceptionInfo * exception ) {
QuantumAny range ;
register ssize_t x ;
ssize_t bit ;
unsigned int pixel ;
assert ( image != ( Image * ) NULL ) ;
assert ( image -> signature == MagickCoreSignature ) ;
switch ( quantum_info -> depth ) {
case 1 : {
register Quantum black , white ;
black = 0 ;
white = QuantumRange ;
if ( quantum_info -> min_is_white != MagickFalse ) {
black = QuantumRange ;
white = 0 ;
}
for ( x = 0 ;
x < ( ( ssize_t ) number_pixels - 7 ) ;
x += 8 ) {
for ( bit = 0 ;
bit < 8 ;
bit ++ ) {
SetPixelGray ( image , ( ( * p ) & ( 1 << ( 7 - bit ) ) ) == 0 ? black : white , q ) ;
q += GetPixelChannels ( image ) ;
}
p ++ ;
}
for ( bit = 0 ;
bit < ( ssize_t ) ( number_pixels % 8 ) ;
bit ++ ) {
SetPixelGray ( image , ( ( * p ) & ( 0x01 << ( 7 - bit ) ) ) == 0 ? black : white , q ) ;
q += GetPixelChannels ( image ) ;
}
if ( bit != 0 ) p ++ ;
break ;
}
case 4 : {
register unsigned char pixel ;
range = GetQuantumRange ( quantum_info -> depth ) ;
for ( x = 0 ;
x < ( ( ssize_t ) number_pixels - 1 ) ;
x += 2 ) {
pixel = ( unsigned char ) ( ( * p >> 4 ) & 0xf ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
pixel = ( unsigned char ) ( ( * p ) & 0xf ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p ++ ;
q += GetPixelChannels ( image ) ;
}
for ( bit = 0 ;
bit < ( ssize_t ) ( number_pixels % 2 ) ;
bit ++ ) {
pixel = ( unsigned char ) ( * p ++ >> 4 ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 8 : {
unsigned char pixel ;
if ( quantum_info -> min_is_white != MagickFalse ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushCharPixel ( p , & pixel ) ;
SetPixelGray ( image , ScaleCharToQuantum ( pixel ) , q ) ;
SetPixelAlpha ( image , OpaqueAlpha , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushCharPixel ( p , & pixel ) ;
SetPixelGray ( image , ScaleCharToQuantum ( pixel ) , q ) ;
SetPixelAlpha ( image , OpaqueAlpha , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 10 : {
range = GetQuantumRange ( quantum_info -> depth ) ;
if ( quantum_info -> pack == MagickFalse ) {
if ( image -> endian == LSBEndian ) {
for ( x = 0 ;
x < ( ssize_t ) ( number_pixels - 2 ) ;
x += 3 ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 22 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 12 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 2 ) & 0x3ff , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
if ( x ++ < ( ssize_t ) ( number_pixels - 1 ) ) {
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 22 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
if ( x ++ < ( ssize_t ) number_pixels ) {
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 12 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) ( number_pixels - 2 ) ;
x += 3 ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 2 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 12 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 22 ) & 0x3ff , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
if ( x ++ < ( ssize_t ) ( number_pixels - 1 ) ) {
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 2 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
if ( x ++ < ( ssize_t ) number_pixels ) {
SetPixelGray ( image , ScaleAnyToQuantum ( ( pixel >> 12 ) & 0x3ff , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 12 : {
range = GetQuantumRange ( quantum_info -> depth ) ;
if ( quantum_info -> pack == MagickFalse ) {
unsigned short pixel ;
for ( x = 0 ;
x < ( ssize_t ) ( number_pixels - 1 ) ;
x += 2 ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
q += GetPixelChannels ( image ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
for ( bit = 0 ;
bit < ( ssize_t ) ( number_pixels % 2 ) ;
bit ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
if ( bit != 0 ) p ++ ;
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 16 : {
unsigned short pixel ;
if ( quantum_info -> min_is_white != MagickFalse ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 32 : {
unsigned int pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
float pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelGray ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGray ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 64 : {
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
double pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelGray ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
default : {
range = GetQuantumRange ( quantum_info -> depth ) ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGray ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int dissect_h245_NewATMVCCommand ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_NewATMVCCommand , NewATMVCCommand_sequence ) ;
return offset ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static LZWInfo * AcquireLZWInfo ( Image * image , const size_t data_size ) {
LZWInfo * lzw_info ;
register ssize_t i ;
size_t one ;
lzw_info = ( LZWInfo * ) AcquireMagickMemory ( sizeof ( * lzw_info ) ) ;
if ( lzw_info == ( LZWInfo * ) NULL ) return ( ( LZWInfo * ) NULL ) ;
( void ) ResetMagickMemory ( lzw_info , 0 , sizeof ( * lzw_info ) ) ;
lzw_info -> image = image ;
lzw_info -> data_size = data_size ;
one = 1 ;
lzw_info -> maximum_data_value = ( one << data_size ) - 1 ;
lzw_info -> clear_code = lzw_info -> maximum_data_value + 1 ;
lzw_info -> end_code = lzw_info -> maximum_data_value + 2 ;
lzw_info -> table [ 0 ] = ( size_t * ) AcquireQuantumMemory ( MaximumLZWCode , sizeof ( * * lzw_info -> table ) ) ;
lzw_info -> table [ 1 ] = ( size_t * ) AcquireQuantumMemory ( MaximumLZWCode , sizeof ( * * lzw_info -> table ) ) ;
if ( ( lzw_info -> table [ 0 ] == ( size_t * ) NULL ) || ( lzw_info -> table [ 1 ] == ( size_t * ) NULL ) ) {
lzw_info = RelinquishLZWInfo ( lzw_info ) ;
return ( ( LZWInfo * ) NULL ) ;
}
for ( i = 0 ;
i <= ( ssize_t ) lzw_info -> maximum_data_value ;
i ++ ) {
lzw_info -> table [ 0 ] [ i ] = 0 ;
lzw_info -> table [ 1 ] [ i ] = ( size_t ) i ;
}
ResetLZWInfo ( lzw_info ) ;
lzw_info -> code_info . buffer [ 0 ] = '\0' ;
lzw_info -> code_info . buffer [ 1 ] = '\0' ;
lzw_info -> code_info . count = 2 ;
lzw_info -> code_info . bit = 8 * lzw_info -> code_info . count ;
lzw_info -> code_info . eof = MagickFalse ;
lzw_info -> genesis = MagickTrue ;
lzw_info -> stack = ( LZWStack * ) AcquireMagickMemory ( sizeof ( * lzw_info -> stack ) ) ;
if ( lzw_info -> stack == ( LZWStack * ) NULL ) {
lzw_info = RelinquishLZWInfo ( lzw_info ) ;
return ( ( LZWInfo * ) NULL ) ;
}
lzw_info -> stack -> codes = ( size_t * ) AcquireQuantumMemory ( 2UL * MaximumLZWCode , sizeof ( * lzw_info -> stack -> codes ) ) ;
if ( lzw_info -> stack -> codes == ( size_t * ) NULL ) {
lzw_info = RelinquishLZWInfo ( lzw_info ) ;
return ( ( LZWInfo * ) NULL ) ;
}
lzw_info -> stack -> index = lzw_info -> stack -> codes ;
lzw_info -> stack -> top = lzw_info -> stack -> codes + 2 * MaximumLZWCode ;
return ( lzw_info ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | bool HasPendingUncleanExit ( Profile * profile ) {
return profile -> GetLastSessionExitType ( ) == Profile : : EXIT_CRASHED && ! profile_launch_observer . Get ( ) . HasBeenLaunched ( profile ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static const u_char * print_sl_winchange ( netdissect_options * ndo , register const u_char * cp ) {
register short i ;
if ( ( i = * cp ++ ) == 0 ) {
i = EXTRACT_16BITS ( cp ) ;
cp += 2 ;
}
if ( i >= 0 ) ND_PRINT ( ( ndo , " W+%d" , i ) ) ;
else ND_PRINT ( ( ndo , " W%d" , i ) ) ;
return ( cp ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void finish_info_provider ( NautilusDirectory * directory , NautilusFile * file , NautilusInfoProvider * provider ) {
file -> details -> pending_info_providers = g_list_remove ( file -> details -> pending_info_providers , provider ) ;
g_object_unref ( provider ) ;
nautilus_directory_async_state_changed ( directory ) ;
if ( file -> details -> pending_info_providers == NULL ) {
nautilus_file_info_providers_done ( file ) ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int dissect_FORM_1 ( tvbuff_t * tvb , int offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep ) {
proto_tree * subtree ;
guint32 flags ;
subtree = proto_tree_add_subtree ( tree , tvb , offset , 0 , ett_FORM_1 , NULL , "Form level 1" ) ;
offset = dissect_ndr_str_pointer_item ( tvb , offset , pinfo , subtree , di , drep , NDR_POINTER_UNIQUE , "Name" , hf_form_name , 0 ) ;
if ( tvb_reported_length_remaining ( tvb , offset ) <= 0 ) goto done ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_flags , & flags ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_unknown , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_width , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_height , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_left_margin , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_top_margin , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_horiz_len , NULL ) ;
offset = dissect_ndr_uint32 ( tvb , offset , pinfo , subtree , di , drep , hf_form_vert_len , NULL ) ;
done : return offset ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void read_intra_frame_mode_info ( VP9_COMMON * const cm , MACROBLOCKD * const xd , int mi_row , int mi_col , vp9_reader * r ) {
MODE_INFO * const mi = xd -> mi [ 0 ] . src_mi ;
MB_MODE_INFO * const mbmi = & mi -> mbmi ;
const MODE_INFO * above_mi = xd -> mi [ - cm -> mi_stride ] . src_mi ;
const MODE_INFO * left_mi = xd -> left_available ? xd -> mi [ - 1 ] . src_mi : NULL ;
const BLOCK_SIZE bsize = mbmi -> sb_type ;
int i ;
mbmi -> segment_id = read_intra_segment_id ( cm , xd , mi_row , mi_col , r ) ;
mbmi -> skip = read_skip ( cm , xd , mbmi -> segment_id , r ) ;
mbmi -> tx_size = read_tx_size ( cm , xd , cm -> tx_mode , bsize , 1 , r ) ;
mbmi -> ref_frame [ 0 ] = INTRA_FRAME ;
mbmi -> ref_frame [ 1 ] = NONE ;
switch ( bsize ) {
case BLOCK_4X4 : for ( i = 0 ;
i < 4 ;
++ i ) mi -> bmi [ i ] . as_mode = read_intra_mode ( r , get_y_mode_probs ( mi , above_mi , left_mi , i ) ) ;
mbmi -> mode = mi -> bmi [ 3 ] . as_mode ;
break ;
case BLOCK_4X8 : mi -> bmi [ 0 ] . as_mode = mi -> bmi [ 2 ] . as_mode = read_intra_mode ( r , get_y_mode_probs ( mi , above_mi , left_mi , 0 ) ) ;
mi -> bmi [ 1 ] . as_mode = mi -> bmi [ 3 ] . as_mode = mbmi -> mode = read_intra_mode ( r , get_y_mode_probs ( mi , above_mi , left_mi , 1 ) ) ;
break ;
case BLOCK_8X4 : mi -> bmi [ 0 ] . as_mode = mi -> bmi [ 1 ] . as_mode = read_intra_mode ( r , get_y_mode_probs ( mi , above_mi , left_mi , 0 ) ) ;
mi -> bmi [ 2 ] . as_mode = mi -> bmi [ 3 ] . as_mode = mbmi -> mode = read_intra_mode ( r , get_y_mode_probs ( mi , above_mi , left_mi , 2 ) ) ;
break ;
default : mbmi -> mode = read_intra_mode ( r , get_y_mode_probs ( mi , above_mi , left_mi , 0 ) ) ;
}
mbmi -> uv_mode = read_intra_mode ( r , vp9_kf_uv_mode_prob [ mbmi -> mode ] ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int dissect_h245_RequestMode ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_RequestMode , RequestMode_sequence ) ;
return offset ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int loosened_object_can_be_discarded ( const unsigned char * sha1 , unsigned long mtime ) {
if ( ! unpack_unreachable_expiration ) return 0 ;
if ( mtime > unpack_unreachable_expiration ) return 0 ;
if ( sha1_array_lookup ( & recent_objects , sha1 ) >= 0 ) return 0 ;
return 1 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void min_heap_ctor ( min_heap_t * s ) {
s -> p = 0 ;
s -> n = 0 ;
s -> a = 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int pfkey_create ( struct net * net , struct socket * sock , int protocol , int kern ) {
struct netns_pfkey * net_pfkey = net_generic ( net , pfkey_net_id ) ;
struct sock * sk ;
int err ;
if ( ! ns_capable ( net -> user_ns , CAP_NET_ADMIN ) ) return - EPERM ;
if ( sock -> type != SOCK_RAW ) return - ESOCKTNOSUPPORT ;
if ( protocol != PF_KEY_V2 ) return - EPROTONOSUPPORT ;
err = - ENOMEM ;
sk = sk_alloc ( net , PF_KEY , GFP_KERNEL , & key_proto ) ;
if ( sk == NULL ) goto out ;
sock -> ops = & pfkey_ops ;
sock_init_data ( sock , sk ) ;
sk -> sk_family = PF_KEY ;
sk -> sk_destruct = pfkey_sock_destruct ;
atomic_inc ( & net_pfkey -> socks_nr ) ;
pfkey_insert ( sk ) ;
return 0 ;
out : return err ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static inline PixelChannel GetPixelChannelChannel ( const Image * restrict image , const ssize_t offset ) {
return ( image -> channel_map [ offset ] . channel ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | extern int name ( int ) __THROW __exctype ( isalnum ) ;
__exctype ( isalpha ) ;
__exctype ( iscntrl ) ;
__exctype ( isdigit ) ;
__exctype ( islower ) ;
__exctype ( isgraph ) ;
__exctype ( isprint ) | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | 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 ) sadMxNxK ( 64 , 64 , 3 ) sadMxNxK ( 64 , 64 , 8 ) sadMxNx4D ( 64 , 64 ) sadMxN ( 64 , 32 ) sadMxNx4D ( 64 , 32 ) sadMxN ( 32 , 64 ) sadMxNx4D ( 32 , 64 ) sadMxN ( 32 , 32 ) sadMxNxK ( 32 , 32 , 3 ) sadMxNxK ( 32 , 32 , 8 ) sadMxNx4D ( 32 , 32 ) sadMxN ( 32 , 16 ) sadMxNx4D ( 32 , 16 ) sadMxN ( 16 , 32 ) sadMxNx4D ( 16 , 32 ) sadMxN ( 16 , 16 ) sadMxNxK ( 16 , 16 , 3 ) | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | int change_logfile ( const char * fname , int leave_crumbs ) {
FILE * new_file ;
const char * log_fname ;
char * abs_fname ;
# if ! defined ( SYS_WINNT ) && ! defined ( SYS_VXWORKS ) && ! defined ( VMS ) char curdir [ 512 ] ;
size_t cd_octets ;
size_t octets ;
# endif REQUIRE ( fname != NULL ) ;
log_fname = fname ;
if ( syslog_file != NULL && syslog_fname != NULL && == strcmp ( syslog_fname , log_fname ) ) return 0 ;
if ( 0 == strcmp ( log_fname , "stderr" ) ) {
new_file = stderr ;
abs_fname = estrdup ( log_fname ) ;
}
else if ( 0 == strcmp ( log_fname , "stdout" ) ) {
new_file = stdout ;
abs_fname = estrdup ( log_fname ) ;
}
else {
if ( syslog_fname != NULL && == strcmp ( log_fname , syslog_fname ) ) log_fname = syslog_abs_fname ;
# if ! defined ( SYS_WINNT ) && ! defined ( SYS_VXWORKS ) && ! defined ( VMS ) if ( log_fname != syslog_abs_fname && DIR_SEP != log_fname [ 0 ] && != strcmp ( log_fname , "stderr" ) && != strcmp ( log_fname , "stdout" ) && NULL != getcwd ( curdir , sizeof ( curdir ) ) ) {
cd_octets = strlen ( curdir ) ;
if ( cd_octets > 1 && DIR_SEP == curdir [ cd_octets - 1 ] ) cd_octets -- ;
octets = cd_octets ;
octets += 1 ;
octets += strlen ( log_fname ) ;
octets += 1 ;
abs_fname = emalloc ( octets ) ;
snprintf ( abs_fname , octets , "%.*s%c%s" , ( int ) cd_octets , curdir , DIR_SEP , log_fname ) ;
}
else # endif abs_fname = estrdup ( log_fname ) ;
TRACE ( 1 , ( "attempting to open log %s\n" , abs_fname ) ) ;
new_file = fopen ( abs_fname , "a" ) ;
}
if ( NULL == new_file ) {
free ( abs_fname ) ;
return - 1 ;
}
if ( leave_crumbs && ( syslogit || log_fname != syslog_abs_fname ) ) msyslog ( LOG_NOTICE , "switching logging to file %s" , abs_fname ) ;
if ( syslog_file != NULL && syslog_file != stderr && syslog_file != stdout && fileno ( syslog_file ) != fileno ( new_file ) ) fclose ( syslog_file ) ;
syslog_file = new_file ;
if ( log_fname == syslog_abs_fname ) {
free ( abs_fname ) ;
}
else {
if ( syslog_abs_fname != NULL && syslog_abs_fname != syslog_fname ) free ( syslog_abs_fname ) ;
if ( syslog_fname != NULL ) free ( syslog_fname ) ;
syslog_fname = estrdup ( log_fname ) ;
syslog_abs_fname = abs_fname ;
}
syslogit = FALSE ;
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static mtime_t DecoderGetDisplayDate ( decoder_t * p_dec , mtime_t i_ts ) {
decoder_owner_sys_t * p_owner = p_dec -> p_owner ;
vlc_mutex_lock ( & p_owner -> lock ) ;
if ( p_owner -> b_waiting || p_owner -> b_paused ) i_ts = VLC_TS_INVALID ;
vlc_mutex_unlock ( & p_owner -> lock ) ;
if ( ! p_owner -> p_clock || i_ts <= VLC_TS_INVALID ) return i_ts ;
if ( input_clock_ConvertTS ( VLC_OBJECT ( p_dec ) , p_owner -> p_clock , NULL , & i_ts , NULL , INT64_MAX ) ) {
msg_Err ( p_dec , "Could not get display date for timestamp %" PRId64 "" , i_ts ) ;
return VLC_TS_INVALID ;
}
return i_ts ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | TEST_F ( IconLabelBubbleViewTest , AnimateLayout ) {
VerifyWithAnimationStep ( 1 ) ;
VerifyWithAnimationStep ( 5 ) ;
VerifyWithAnimationStep ( 10 ) ;
VerifyWithAnimationStep ( 25 ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void pxa2xx_rtc_piupdate ( PXA2xxRTCState * s ) {
int64_t rt = qemu_get_clock_ms ( rtc_clock ) ;
if ( s -> rtsr & ( 1 << 15 ) ) s -> last_swcr += rt - s -> last_pi ;
s -> last_pi = rt ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void vp9_ ## type ## _predictor_ ## size ## x ## size ## _c ( uint8_t * dst , ptrdiff_t stride , const uint8_t * above , const uint8_t * left ) {
type ## _predictor ( dst , stride , size , above , left ) ;
}
# define intra_pred_allsizes ( type ) intra_pred_sized ( type , 4 ) intra_pred_sized ( type , 8 ) intra_pred_sized ( type , 16 ) intra_pred_sized ( type , 32 ) static INLINE void d207_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
( void ) above ;
for ( r = 0 ;
r < bs - 1 ;
++ r ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r ] + left [ r + 1 ] , 1 ) ;
dst [ ( bs - 1 ) * stride ] = left [ bs - 1 ] ;
dst ++ ;
for ( r = 0 ;
r < bs - 2 ;
++ r ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r ] + left [ r + 1 ] * 2 + left [ r + 2 ] , 2 ) ;
dst [ ( bs - 2 ) * stride ] = ROUND_POWER_OF_TWO ( left [ bs - 2 ] + left [ bs - 1 ] * 3 , 2 ) ;
dst [ ( bs - 1 ) * stride ] = left [ bs - 1 ] ;
dst ++ ;
for ( c = 0 ;
c < bs - 2 ;
++ c ) dst [ ( bs - 1 ) * stride + c ] = left [ bs - 1 ] ;
for ( r = bs - 2 ;
r >= 0 ;
-- r ) for ( c = 0 ;
c < bs - 2 ;
++ c ) dst [ r * stride + c ] = dst [ ( r + 1 ) * stride + c - 2 ] ;
}
intra_pred_allsizes ( d207 ) static INLINE void d63_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
( void ) left ;
for ( r = 0 ;
r < bs ;
++ r ) {
for ( c = 0 ;
c < bs ;
++ c ) dst [ c ] = r & 1 ? ROUND_POWER_OF_TWO ( above [ r / 2 + c ] + above [ r / 2 + c + 1 ] * 2 + above [ r / 2 + c + 2 ] , 2 ) : ROUND_POWER_OF_TWO ( above [ r / 2 + c ] + above [ r / 2 + c + 1 ] , 1 ) ;
dst += stride ;
}
}
intra_pred_allsizes ( d63 ) static INLINE void d45_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
( void ) left ;
for ( r = 0 ;
r < bs ;
++ r ) {
for ( c = 0 ;
c < bs ;
++ c ) dst [ c ] = r + c + 2 < bs * 2 ? ROUND_POWER_OF_TWO ( above [ r + c ] + above [ r + c + 1 ] * 2 + above [ r + c + 2 ] , 2 ) : above [ bs * 2 - 1 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d45 ) static INLINE void d117_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
for ( c = 0 ;
c < bs ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 1 ] + above [ c ] , 1 ) ;
dst += stride ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( left [ 0 ] + above [ - 1 ] * 2 + above [ 0 ] , 2 ) ;
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 2 ] + above [ c - 1 ] * 2 + above [ c ] , 2 ) ;
dst += stride ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] * 2 + left [ 1 ] , 2 ) ;
for ( r = 3 ;
r < bs ;
++ r ) dst [ ( r - 2 ) * stride ] = ROUND_POWER_OF_TWO ( left [ r - 3 ] + left [ r - 2 ] * 2 + left [ r - 1 ] , 2 ) ;
for ( r = 2 ;
r < bs ;
++ r ) {
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = dst [ - 2 * stride + c - 1 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d117 ) static INLINE void d135_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( left [ 0 ] + above [ - 1 ] * 2 + above [ 0 ] , 2 ) ;
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 2 ] + above [ c - 1 ] * 2 + above [ c ] , 2 ) ;
dst [ stride ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] * 2 + left [ 1 ] , 2 ) ;
for ( r = 2 ;
r < bs ;
++ r ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r - 2 ] + left [ r - 1 ] * 2 + left [ r ] , 2 ) ;
dst += stride ;
for ( r = 1 ;
r < bs ;
++ r ) {
for ( c = 1 ;
c < bs ;
c ++ ) dst [ c ] = dst [ - stride + c - 1 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d135 ) static INLINE void d153_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r , c ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] , 1 ) ;
for ( r = 1 ;
r < bs ;
r ++ ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r - 1 ] + left [ r ] , 1 ) ;
dst ++ ;
dst [ 0 ] = ROUND_POWER_OF_TWO ( left [ 0 ] + above [ - 1 ] * 2 + above [ 0 ] , 2 ) ;
dst [ stride ] = ROUND_POWER_OF_TWO ( above [ - 1 ] + left [ 0 ] * 2 + left [ 1 ] , 2 ) ;
for ( r = 2 ;
r < bs ;
r ++ ) dst [ r * stride ] = ROUND_POWER_OF_TWO ( left [ r - 2 ] + left [ r - 1 ] * 2 + left [ r ] , 2 ) ;
dst ++ ;
for ( c = 0 ;
c < bs - 2 ;
c ++ ) dst [ c ] = ROUND_POWER_OF_TWO ( above [ c - 1 ] + above [ c ] * 2 + above [ c + 1 ] , 2 ) ;
dst += stride ;
for ( r = 1 ;
r < bs ;
++ r ) {
for ( c = 0 ;
c < bs - 2 ;
c ++ ) dst [ c ] = dst [ - stride + c - 2 ] ;
dst += stride ;
}
}
intra_pred_allsizes ( d153 ) static INLINE void v_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r ;
( void ) left ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memcpy ( dst , above , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( v ) static INLINE void h_predictor ( uint8_t * dst , ptrdiff_t stride , int bs , const uint8_t * above , const uint8_t * left ) {
int r ;
( void ) above ;
for ( r = 0 ;
r < bs ;
r ++ ) {
vpx_memset ( dst , left [ r ] , bs ) ;
dst += stride ;
}
}
intra_pred_allsizes ( h ) | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | void jpc_ft_invlift_colres ( jpc_fix_t * a , int numrows , int numcols , int stride , int parity ) {
jpc_fix_t * lptr ;
jpc_fix_t * hptr ;
register jpc_fix_t * lptr2 ;
register jpc_fix_t * hptr2 ;
register int n ;
register int i ;
int llen ;
llen = ( numrows + 1 - parity ) >> 1 ;
if ( numrows > 1 ) {
lptr = & a [ 0 ] ;
hptr = & a [ llen * stride ] ;
if ( ! parity ) {
lptr2 = lptr ;
hptr2 = hptr ;
for ( i = 0 ;
i < numcols ;
++ i ) {
lptr2 [ 0 ] -= jpc_fix_asr ( hptr2 [ 0 ] + 1 , 1 ) ;
++ lptr2 ;
++ hptr2 ;
}
lptr += stride ;
}
n = llen - ( ! parity ) - ( parity != ( numrows & 1 ) ) ;
while ( n -- > 0 ) {
lptr2 = lptr ;
hptr2 = hptr ;
for ( i = 0 ;
i < numcols ;
++ i ) {
lptr2 [ 0 ] -= jpc_fix_asr ( hptr2 [ 0 ] + hptr2 [ stride ] + 2 , 2 ) ;
++ lptr2 ;
++ hptr2 ;
}
lptr += stride ;
hptr += stride ;
}
if ( parity != ( numrows & 1 ) ) {
lptr2 = lptr ;
hptr2 = hptr ;
for ( i = 0 ;
i < numcols ;
++ i ) {
lptr2 [ 0 ] -= jpc_fix_asr ( hptr2 [ 0 ] + 1 , 1 ) ;
++ lptr2 ;
++ hptr2 ;
}
}
lptr = & a [ 0 ] ;
hptr = & a [ llen * stride ] ;
if ( parity ) {
lptr2 = lptr ;
hptr2 = hptr ;
for ( i = 0 ;
i < numcols ;
++ i ) {
hptr2 [ 0 ] += lptr2 [ 0 ] ;
++ hptr2 ;
++ lptr2 ;
}
hptr += stride ;
}
n = numrows - llen - parity - ( parity == ( numrows & 1 ) ) ;
while ( n -- > 0 ) {
lptr2 = lptr ;
hptr2 = hptr ;
for ( i = 0 ;
i < numcols ;
++ i ) {
hptr2 [ 0 ] += jpc_fix_asr ( lptr2 [ 0 ] + lptr2 [ stride ] , 1 ) ;
++ lptr2 ;
++ hptr2 ;
}
hptr += stride ;
lptr += stride ;
}
if ( parity == ( numrows & 1 ) ) {
lptr2 = lptr ;
hptr2 = hptr ;
for ( i = 0 ;
i < numcols ;
++ i ) {
hptr2 [ 0 ] += lptr2 [ 0 ] ;
++ lptr2 ;
++ hptr2 ;
}
}
}
else {
if ( parity ) {
lptr2 = & a [ 0 ] ;
for ( i = 0 ;
i < numcols ;
++ i ) {
lptr2 [ 0 ] = jpc_fix_asr ( lptr2 [ 0 ] , 1 ) ;
++ lptr2 ;
}
}
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | IN_PROC_BROWSER_TEST_F ( BookmarkBubbleSignInDelegateTest , BrowserRemoved ) {
Browser * extra_browser = CreateBrowser ( profile ( ) ) ;
ReplaceBlank ( extra_browser ) ;
int starting_tab_count = extra_browser -> tab_strip_model ( ) -> count ( ) ;
scoped_ptr < BookmarkBubbleDelegate > delegate ;
delegate . reset ( new BookmarkBubbleSignInDelegate ( browser ( ) ) ) ;
BrowserList : : SetLastActive ( extra_browser ) ;
browser ( ) -> tab_strip_model ( ) -> CloseAllTabs ( ) ;
content : : RunAllPendingInMessageLoop ( ) ;
delegate -> OnSignInLinkClicked ( ) ;
int tab_count = extra_browser -> tab_strip_model ( ) -> count ( ) ;
EXPECT_EQ ( starting_tab_count + 1 , tab_count ) ;
} | 1True
|
Categorize the following code snippet as vulnerable or not. True or False | static inline int vc1_pred_dc ( MpegEncContext * s , int overlap , int pq , int n , int a_avail , int c_avail , int16_t * * dc_val_ptr , int * dir_ptr ) {
int a , b , c , wrap , pred ;
int16_t * dc_val ;
int mb_pos = s -> mb_x + s -> mb_y * s -> mb_stride ;
int q1 , q2 = 0 ;
int dqscale_index ;
wrap = s -> block_wrap [ n ] ;
dc_val = s -> dc_val [ 0 ] + s -> block_index [ n ] ;
c = dc_val [ - 1 ] ;
b = dc_val [ - 1 - wrap ] ;
a = dc_val [ - wrap ] ;
q1 = s -> current_picture . qscale_table [ mb_pos ] ;
dqscale_index = s -> y_dc_scale_table [ q1 ] - 1 ;
if ( dqscale_index < 0 ) return 0 ;
if ( c_avail && ( n != 1 && n != 3 ) ) {
q2 = s -> current_picture . qscale_table [ mb_pos - 1 ] ;
if ( q2 && q2 != q1 ) c = ( c * s -> y_dc_scale_table [ q2 ] * ff_vc1_dqscale [ dqscale_index ] + 0x20000 ) >> 18 ;
}
if ( a_avail && ( n != 2 && n != 3 ) ) {
q2 = s -> current_picture . qscale_table [ mb_pos - s -> mb_stride ] ;
if ( q2 && q2 != q1 ) a = ( a * s -> y_dc_scale_table [ q2 ] * ff_vc1_dqscale [ dqscale_index ] + 0x20000 ) >> 18 ;
}
if ( a_avail && c_avail && ( n != 3 ) ) {
int off = mb_pos ;
if ( n != 1 ) off -- ;
if ( n != 2 ) off -= s -> mb_stride ;
q2 = s -> current_picture . qscale_table [ off ] ;
if ( q2 && q2 != q1 ) b = ( b * s -> y_dc_scale_table [ q2 ] * ff_vc1_dqscale [ dqscale_index ] + 0x20000 ) >> 18 ;
}
if ( a_avail && c_avail ) {
if ( abs ( a - b ) <= abs ( b - c ) ) {
pred = c ;
* dir_ptr = 1 ;
}
else {
pred = a ;
* dir_ptr = 0 ;
}
}
else if ( a_avail ) {
pred = a ;
* dir_ptr = 0 ;
}
else if ( c_avail ) {
pred = c ;
* dir_ptr = 1 ;
}
else {
pred = 0 ;
* dir_ptr = 1 ;
}
* dc_val_ptr = & dc_val [ 0 ] ;
return pred ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void encode_txfm_probs ( VP9_COMMON * cm , vp9_writer * w ) {
vp9_write_literal ( w , MIN ( cm -> tx_mode , ALLOW_32X32 ) , 2 ) ;
if ( cm -> tx_mode >= ALLOW_32X32 ) vp9_write_bit ( w , cm -> tx_mode == TX_MODE_SELECT ) ;
if ( cm -> tx_mode == TX_MODE_SELECT ) {
int i , j ;
unsigned int ct_8x8p [ TX_SIZES - 3 ] [ 2 ] ;
unsigned int ct_16x16p [ TX_SIZES - 2 ] [ 2 ] ;
unsigned int ct_32x32p [ TX_SIZES - 1 ] [ 2 ] ;
for ( i = 0 ;
i < TX_SIZE_CONTEXTS ;
i ++ ) {
tx_counts_to_branch_counts_8x8 ( cm -> counts . tx . p8x8 [ i ] , ct_8x8p ) ;
for ( j = 0 ;
j < TX_SIZES - 3 ;
j ++ ) vp9_cond_prob_diff_update ( w , & cm -> fc . tx_probs . p8x8 [ i ] [ j ] , ct_8x8p [ j ] ) ;
}
for ( i = 0 ;
i < TX_SIZE_CONTEXTS ;
i ++ ) {
tx_counts_to_branch_counts_16x16 ( cm -> counts . tx . p16x16 [ i ] , ct_16x16p ) ;
for ( j = 0 ;
j < TX_SIZES - 2 ;
j ++ ) vp9_cond_prob_diff_update ( w , & cm -> fc . tx_probs . p16x16 [ i ] [ j ] , ct_16x16p [ j ] ) ;
}
for ( i = 0 ;
i < TX_SIZE_CONTEXTS ;
i ++ ) {
tx_counts_to_branch_counts_32x32 ( cm -> counts . tx . p32x32 [ i ] , ct_32x32p ) ;
for ( j = 0 ;
j < TX_SIZES - 1 ;
j ++ ) vp9_cond_prob_diff_update ( w , & cm -> fc . tx_probs . p32x32 [ i ] [ j ] , ct_32x32p [ j ] ) ;
}
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int64_t timebase_units_to_ticks ( const vpx_rational_t * timebase , int64_t n ) {
return n * TICKS_PER_SEC * timebase -> num / timebase -> den ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int transform_hook_handler ( TSCont contp , TSEvent event , void * edata ) {
TSHttpTxn txnp = nullptr ;
TransformTestData * data = nullptr ;
CHECK_SPURIOUS_EVENT ( contp , event , edata ) ;
data = ( TransformTestData * ) TSContDataGet ( contp ) ;
switch ( event ) {
case TS_EVENT_HTTP_READ_REQUEST_HDR : txnp = ( TSHttpTxn ) edata ;
TSSkipRemappingSet ( txnp , 1 ) ;
TSHttpTxnReenable ( txnp , TS_EVENT_HTTP_CONTINUE ) ;
break ;
case TS_EVENT_HTTP_READ_RESPONSE_HDR : txnp = ( TSHttpTxn ) edata ;
if ( transformable ( txnp , data ) ) {
transform_add ( txnp , data ) ;
}
{
TSMBuffer bufp ;
TSMLoc hdr ;
TSMLoc field ;
if ( TSHttpTxnClientReqGet ( txnp , & bufp , & hdr ) != TS_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransform" , "TestCase" , TC_FAIL , "TSHttpTxnClientReqGet returns 0" ) ;
}
else {
if ( TS_NULL_MLOC == ( field = TSMimeHdrFieldFind ( bufp , hdr , "Request" , - 1 ) ) ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransform" , "TestCase" , TC_FAIL , "Didn't find field request" ) ;
}
else {
int reqid = TSMimeHdrFieldValueIntGet ( bufp , hdr , field , 0 ) ;
if ( reqid == 1 ) {
TSHttpTxnTransformedRespCache ( txnp , 0 ) ;
TSHttpTxnUntransformedRespCache ( txnp , 1 ) ;
}
if ( reqid == 2 ) {
TSHttpTxnTransformedRespCache ( txnp , 1 ) ;
TSHttpTxnUntransformedRespCache ( txnp , 0 ) ;
}
if ( TSHandleMLocRelease ( bufp , hdr , field ) != TS_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransform" , "TestCase" , TC_FAIL , "Unable to release handle to field in Client request" ) ;
}
}
if ( TSHandleMLocRelease ( bufp , TS_NULL_MLOC , hdr ) != TS_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransform" , "TestCase" , TC_FAIL , "Unable to release handle to Client request" ) ;
}
}
}
TSHttpTxnHookAdd ( txnp , TS_HTTP_SEND_RESPONSE_HDR_HOOK , contp ) ;
TSHttpTxnReenable ( txnp , TS_EVENT_HTTP_CONTINUE ) ;
break ;
case TS_EVENT_HTTP_SEND_RESPONSE_HDR : {
TSMBuffer bufp ;
TSMLoc hdr ;
txnp = ( TSHttpTxn ) edata ;
if ( TSHttpTxnTransformRespGet ( txnp , & bufp , & hdr ) != TS_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransformRespGet" , "TestCase" , TC_FAIL , "TSHttpTxnTransformRespGet returns 0" ) ;
data -> test_passed_txn_transform_resp_get = false ;
}
else {
if ( ( bufp == reinterpret_cast < TSMBuffer > ( & ( ( ( HttpSM * ) txnp ) -> t_state . hdr_info . transform_response ) ) ) && ( hdr == reinterpret_cast < TSMLoc > ( ( & ( ( ( HttpSM * ) txnp ) -> t_state . hdr_info . transform_response ) ) -> m_http ) ) ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransformRespGet" , "TestCase" , TC_PASS , "ok" ) ;
}
else {
SDK_RPRINT ( data -> test , "TSHttpTxnTransformRespGet" , "TestCase" , TC_FAIL , "Value's Mismatch" ) ;
data -> test_passed_txn_transform_resp_get = false ;
}
if ( TSHandleMLocRelease ( bufp , TS_NULL_MLOC , hdr ) != TS_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransformRespGet" , "TestCase" , TC_FAIL , "Unable to release handle to Transform header handle" ) ;
}
}
}
TSHttpTxnReenable ( txnp , TS_EVENT_HTTP_CONTINUE ) ;
break ;
case TS_EVENT_IMMEDIATE : case TS_EVENT_TIMEOUT : switch ( data -> req_no ) {
case 1 : if ( data -> browser1 -> status == REQUEST_INPROGRESS ) {
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
}
data -> req_no ++ ;
Debug ( UTDBG_TAG "_transform" , "Running Browser 2" ) ;
synclient_txn_send_request ( data -> browser2 , data -> request2 ) ;
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
case 2 : if ( data -> browser2 -> status == REQUEST_INPROGRESS ) {
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
}
data -> req_no ++ ;
Debug ( UTDBG_TAG "_transform" , "Running Browser 3" ) ;
synclient_txn_send_request ( data -> browser3 , data -> request1 ) ;
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
case 3 : if ( data -> browser3 -> status == REQUEST_INPROGRESS ) {
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
}
data -> req_no ++ ;
Debug ( UTDBG_TAG "_transform" , "Running Browser 4" ) ;
synclient_txn_send_request ( data -> browser4 , data -> request2 ) ;
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
case 4 : if ( data -> browser4 -> status == REQUEST_INPROGRESS ) {
TSContSchedule ( contp , 25 , TS_THREAD_POOL_DEFAULT ) ;
return 0 ;
}
synserver_delete ( data -> os ) ;
data -> os = nullptr ;
data -> req_no ++ ;
TSfree ( data -> request1 ) ;
TSfree ( data -> request2 ) ;
break ;
default : SDK_RPRINT ( data -> test , "TSHttpTxnTransform" , "TestCase" , TC_FAIL , "Something terribly wrong with the test" ) ;
exit ( 0 ) ;
}
{
if ( ( strstr ( data -> browser1 -> response , TRANSFORM_APPEND_STRING ) != nullptr ) && ( strstr ( data -> browser3 -> response , TRANSFORM_APPEND_STRING ) == nullptr ) ) {
SDK_RPRINT ( data -> test , "TSHttpTxnUntransformedResponseCache" , "TestCase1" , TC_PASS , "ok" ) ;
data -> test_passed_txn_untransformed_resp_cache = true ;
}
else {
SDK_RPRINT ( data -> test , "TSHttpTxnUntransformedResponseCache" , "TestCase1" , TC_FAIL , "Value's Mismatch" ) ;
}
if ( ( strstr ( data -> browser2 -> response , TRANSFORM_APPEND_STRING ) != nullptr ) && ( strstr ( data -> browser4 -> response , TRANSFORM_APPEND_STRING ) != nullptr ) ) {
SDK_RPRINT ( data -> test , "TSHttpTxnTransformedResponseCache" , "TestCase1" , TC_PASS , "ok" ) ;
data -> test_passed_txn_transformed_resp_cache = true ;
}
else {
SDK_RPRINT ( data -> test , "TSHttpTxnTransformedResponseCache" , "TestCase1" , TC_FAIL , "Value's Mismatch" ) ;
}
* ( data -> pstatus ) = REGRESSION_TEST_PASSED ;
if ( data -> browser1 -> status != REQUEST_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "Browser 1 status was not REQUEST_SUCCESS" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> browser2 -> status != REQUEST_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "Browser 2 status was not REQUEST_SUCCESS" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> browser3 -> status != REQUEST_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "Browser 3 status was not REQUEST_SUCCESS" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> browser4 -> status != REQUEST_SUCCESS ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "Browser 4 status was not REQUEST_SUCCESS" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> test_passed_txn_transform_resp_get != true ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "did not pass transform_resp_get" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> test_passed_txn_transformed_resp_cache != true ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "did not pass transformed_resp_cache" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> test_passed_txn_untransformed_resp_cache != true ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "did not pass untransformed_resp_cache" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
if ( data -> test_passed_transform_create != true ) {
SDK_RPRINT ( data -> test , "TSTransformCreate" , "TestCase1" , TC_FAIL , "did not pass transform_create" ) ;
* ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
}
synclient_txn_delete ( data -> browser1 ) ;
synclient_txn_delete ( data -> browser2 ) ;
synclient_txn_delete ( data -> browser3 ) ;
synclient_txn_delete ( data -> browser4 ) ;
TSContDataSet ( contp , nullptr ) ;
data -> magic = MAGIC_DEAD ;
TSfree ( data ) ;
}
break ;
default : * ( data -> pstatus ) = REGRESSION_TEST_FAILED ;
SDK_RPRINT ( data -> test , "TSHttpTxnTransform" , "TestCase1" , TC_FAIL , "Unexpected event %d" , event ) ;
break ;
}
return 0 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int ebml_read_num ( MatroskaDemuxContext * matroska , AVIOContext * pb , int max_size , uint64_t * number ) {
int read = 1 , n = 1 ;
uint64_t total = 0 ;
if ( ! ( total = avio_r8 ( pb ) ) ) {
if ( ! pb -> eof_reached ) {
int64_t pos = avio_tell ( pb ) ;
av_log ( matroska -> ctx , AV_LOG_ERROR , "Read error at pos. %" PRIu64 " (0x%" PRIx64 ")\n" , pos , pos ) ;
return pb -> error ? pb -> error : AVERROR ( EIO ) ;
}
return AVERROR_EOF ;
}
read = 8 - ff_log2_tab [ total ] ;
if ( read > max_size ) {
int64_t pos = avio_tell ( pb ) - 1 ;
av_log ( matroska -> ctx , AV_LOG_ERROR , "Invalid EBML number size tag 0x%02x at pos %" PRIu64 " (0x%" PRIx64 ")\n" , ( uint8_t ) total , pos , pos ) ;
return AVERROR_INVALIDDATA ;
}
total ^= 1 << ff_log2_tab [ total ] ;
while ( n ++ < read ) total = ( total << 8 ) | avio_r8 ( pb ) ;
* number = total ;
return read ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void * Type_Text_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
char * Text = NULL ;
cmsMLU * mlu = NULL ;
mlu = cmsMLUalloc ( self -> ContextID , 1 ) ;
if ( mlu == NULL ) return NULL ;
* nItems = 0 ;
if ( SizeOfTag == UINT_MAX ) goto Error ;
Text = ( char * ) _cmsMalloc ( self -> ContextID , SizeOfTag + 1 ) ;
if ( Text == NULL ) goto Error ;
if ( io -> Read ( io , Text , sizeof ( char ) , SizeOfTag ) != SizeOfTag ) goto Error ;
Text [ SizeOfTag ] = 0 ;
* nItems = 1 ;
if ( ! cmsMLUsetASCII ( mlu , cmsNoLanguage , cmsNoCountry , Text ) ) goto Error ;
_cmsFree ( self -> ContextID , Text ) ;
return ( void * ) mlu ;
Error : if ( mlu != NULL ) cmsMLUfree ( mlu ) ;
if ( Text != NULL ) _cmsFree ( self -> ContextID , Text ) ;
return NULL ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static bfd_boolean srec_get_section_contents ( bfd * abfd , asection * section , void * location , file_ptr offset , bfd_size_type count ) {
if ( count == 0 ) return TRUE ;
if ( offset + count < count || offset + count > section -> size ) {
bfd_set_error ( bfd_error_invalid_operation ) ;
return FALSE ;
}
if ( section -> used_by_bfd == NULL ) {
section -> used_by_bfd = bfd_alloc ( abfd , section -> size ) ;
if ( section -> used_by_bfd == NULL ) return FALSE ;
if ( ! srec_read_section ( abfd , section , ( bfd_byte * ) section -> used_by_bfd ) ) return FALSE ;
}
memcpy ( location , ( bfd_byte * ) section -> used_by_bfd + offset , ( size_t ) count ) ;
return TRUE ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void _LMBCSOpenWorker ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err , ulmbcs_byte_t OptGroup ) {
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) uprv_malloc ( sizeof ( UConverterDataLMBCS ) ) ;
_this -> extraInfo = extraInfo ;
if ( extraInfo != NULL ) {
UConverterNamePieces stackPieces ;
UConverterLoadArgs stackArgs = UCNV_LOAD_ARGS_INITIALIZER ;
ulmbcs_byte_t i ;
uprv_memset ( extraInfo , 0 , sizeof ( UConverterDataLMBCS ) ) ;
stackArgs . onlyTestIsLoadable = pArgs -> onlyTestIsLoadable ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST && U_SUCCESS ( * err ) ;
i ++ ) {
if ( OptGroupByteToCPName [ i ] != NULL ) {
extraInfo -> OptGrpConverter [ i ] = ucnv_loadSharedData ( OptGroupByteToCPName [ i ] , & stackPieces , & stackArgs , err ) ;
}
}
if ( U_FAILURE ( * err ) || pArgs -> onlyTestIsLoadable ) {
_LMBCSClose ( _this ) ;
return ;
}
extraInfo -> OptGroup = OptGroup ;
extraInfo -> localeConverterIndex = FindLMBCSLocale ( pArgs -> locale ) ;
}
else {
* err = U_MEMORY_ALLOCATION_ERROR ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void mclms_update ( WmallDecodeCtx * s , int icoef , int * pred ) {
int i , j , ich , pred_error ;
int order = s -> mclms_order ;
int num_channels = s -> num_channels ;
int range = 1 << ( s -> bits_per_sample - 1 ) ;
for ( ich = 0 ;
ich < num_channels ;
ich ++ ) {
pred_error = s -> channel_residues [ ich ] [ icoef ] - pred [ ich ] ;
if ( pred_error > 0 ) {
for ( i = 0 ;
i < order * num_channels ;
i ++ ) s -> mclms_coeffs [ i + ich * order * num_channels ] += s -> mclms_updates [ s -> mclms_recent + i ] ;
for ( j = 0 ;
j < ich ;
j ++ ) {
if ( s -> channel_residues [ j ] [ icoef ] > 0 ) s -> mclms_coeffs_cur [ ich * num_channels + j ] += 1 ;
else if ( s -> channel_residues [ j ] [ icoef ] < 0 ) s -> mclms_coeffs_cur [ ich * num_channels + j ] -= 1 ;
}
}
else if ( pred_error < 0 ) {
for ( i = 0 ;
i < order * num_channels ;
i ++ ) s -> mclms_coeffs [ i + ich * order * num_channels ] -= s -> mclms_updates [ s -> mclms_recent + i ] ;
for ( j = 0 ;
j < ich ;
j ++ ) {
if ( s -> channel_residues [ j ] [ icoef ] > 0 ) s -> mclms_coeffs_cur [ ich * num_channels + j ] -= 1 ;
else if ( s -> channel_residues [ j ] [ icoef ] < 0 ) s -> mclms_coeffs_cur [ ich * num_channels + j ] += 1 ;
}
}
}
for ( ich = num_channels - 1 ;
ich >= 0 ;
ich -- ) {
s -> mclms_recent -- ;
s -> mclms_prevvalues [ s -> mclms_recent ] = s -> channel_residues [ ich ] [ icoef ] ;
if ( s -> channel_residues [ ich ] [ icoef ] > range - 1 ) s -> mclms_prevvalues [ s -> mclms_recent ] = range - 1 ;
else if ( s -> channel_residues [ ich ] [ icoef ] < - range ) s -> mclms_prevvalues [ s -> mclms_recent ] = - range ;
s -> mclms_updates [ s -> mclms_recent ] = 0 ;
if ( s -> channel_residues [ ich ] [ icoef ] > 0 ) s -> mclms_updates [ s -> mclms_recent ] = 1 ;
else if ( s -> channel_residues [ ich ] [ icoef ] < 0 ) s -> mclms_updates [ s -> mclms_recent ] = - 1 ;
}
if ( s -> mclms_recent == 0 ) {
memcpy ( & s -> mclms_prevvalues [ order * num_channels ] , s -> mclms_prevvalues , 2 * order * num_channels ) ;
memcpy ( & s -> mclms_updates [ order * num_channels ] , s -> mclms_updates , 2 * order * num_channels ) ;
s -> mclms_recent = num_channels * order ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void printout_rate_control_summary ( struct RateControlMetrics * rc , vpx_codec_enc_cfg_t * cfg , int frame_cnt ) {
unsigned int i = 0 ;
int tot_num_frames = 0 ;
printf ( "Total number of processed frames: %d\n\n" , frame_cnt - 1 ) ;
printf ( "Rate control layer stats for %d layer(s):\n\n" , cfg -> ts_number_layers ) ;
for ( i = 0 ;
i < cfg -> ts_number_layers ;
++ i ) {
const int num_dropped = ( i > 0 ) ? ( rc -> layer_input_frames [ i ] - rc -> layer_enc_frames [ i ] ) : ( rc -> layer_input_frames [ i ] - rc -> layer_enc_frames [ i ] - 1 ) ;
tot_num_frames += rc -> layer_input_frames [ i ] ;
rc -> layer_encoding_bitrate [ i ] = 0.001 * rc -> layer_framerate [ i ] * rc -> layer_encoding_bitrate [ i ] / tot_num_frames ;
rc -> layer_avg_frame_size [ i ] = rc -> layer_avg_frame_size [ i ] / rc -> layer_enc_frames [ i ] ;
rc -> layer_avg_rate_mismatch [ i ] = 100.0 * rc -> layer_avg_rate_mismatch [ i ] / rc -> layer_enc_frames [ i ] ;
printf ( "For layer#: %d \n" , i ) ;
printf ( "Bitrate (target vs actual): %d %f \n" , cfg -> ts_target_bitrate [ i ] , rc -> layer_encoding_bitrate [ i ] ) ;
printf ( "Average frame size (target vs actual): %f %f \n" , rc -> layer_pfb [ i ] , rc -> layer_avg_frame_size [ i ] ) ;
printf ( "Average rate_mismatch: %f \n" , rc -> layer_avg_rate_mismatch [ i ] ) ;
printf ( "Number of input frames, encoded (non-key) frames, " "and perc dropped frames: %d %d %f \n" , rc -> layer_input_frames [ i ] , rc -> layer_enc_frames [ i ] , 100.0 * num_dropped / rc -> layer_input_frames [ i ] ) ;
printf ( "\n" ) ;
}
if ( ( frame_cnt - 1 ) != tot_num_frames ) die ( "Error: Number of input frames not equal to output! \n" ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static guint16 de_cld_party_sub_addr ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len , gchar * add_string _U_ , int string_len _U_ ) {
gchar * extr_addr ;
de_sub_addr ( tvb , tree , pinfo , offset , len , & extr_addr ) ;
if ( extr_addr && add_string ) g_snprintf ( add_string , string_len , " - (%s)" , extr_addr ) ;
return ( len ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static guint16 de_prio ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len _U_ , gchar * add_string _U_ , int string_len _U_ ) {
guint32 curr_offset ;
curr_offset = offset ;
proto_tree_add_item ( tree , hf_gsm_a_b8spare , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_bits_item ( tree , hf_gsm_a_call_prio , tvb , ( curr_offset << 3 ) + 5 , 3 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
return ( curr_offset - offset ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static inline void handle_variation_selector_cluster ( const hb_ot_shape_normalize_context_t * c , unsigned int end , bool short_circuit ) {
hb_buffer_t * const buffer = c -> buffer ;
hb_font_t * const font = c -> font ;
for ( ;
buffer -> idx < end - 1 ;
) {
if ( unlikely ( buffer -> unicode -> is_variation_selector ( buffer -> cur ( + 1 ) . codepoint ) ) ) {
if ( font -> get_glyph ( buffer -> cur ( ) . codepoint , buffer -> cur ( + 1 ) . codepoint , & buffer -> cur ( ) . glyph_index ( ) ) ) {
buffer -> replace_glyphs ( 2 , 1 , & buffer -> cur ( ) . codepoint ) ;
}
else {
set_glyph ( buffer -> cur ( ) , font ) ;
buffer -> next_glyph ( ) ;
set_glyph ( buffer -> cur ( ) , font ) ;
buffer -> next_glyph ( ) ;
}
while ( buffer -> idx < end && unlikely ( buffer -> unicode -> is_variation_selector ( buffer -> cur ( ) . codepoint ) ) ) {
set_glyph ( buffer -> cur ( ) , font ) ;
buffer -> next_glyph ( ) ;
}
}
else {
set_glyph ( buffer -> cur ( ) , font ) ;
buffer -> next_glyph ( ) ;
}
}
if ( likely ( buffer -> idx < end ) ) {
set_glyph ( buffer -> cur ( ) , font ) ;
buffer -> next_glyph ( ) ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void _uhash_allocate ( UHashtable * hash , int32_t primeIndex , UErrorCode * status ) {
UHashElement * p , * limit ;
UHashTok emptytok ;
if ( U_FAILURE ( * status ) ) return ;
U_ASSERT ( primeIndex >= 0 && primeIndex < PRIMES_LENGTH ) ;
hash -> primeIndex = primeIndex ;
hash -> length = PRIMES [ primeIndex ] ;
p = hash -> elements = ( UHashElement * ) uprv_malloc ( sizeof ( UHashElement ) * hash -> length ) ;
if ( hash -> elements == NULL ) {
* status = U_MEMORY_ALLOCATION_ERROR ;
return ;
}
emptytok . pointer = NULL ;
emptytok . integer = 0 ;
limit = p + hash -> length ;
while ( p < limit ) {
p -> key = emptytok ;
p -> value = emptytok ;
p -> hashcode = HASH_EMPTY ;
++ p ;
}
hash -> count = 0 ;
hash -> lowWaterMark = ( int32_t ) ( hash -> length * hash -> lowWaterRatio ) ;
hash -> highWaterMark = ( int32_t ) ( hash -> length * hash -> highWaterRatio ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void report_type_length_mismatch ( proto_tree * tree , const gchar * descr , int length , gboolean is_error ) {
if ( is_error ) {
expert_add_info_format ( NULL , tree , & ei_type_length_mismatch_error , "Trying to fetch %s with length %d" , descr , length ) ;
}
else {
expert_add_info_format ( NULL , tree , & ei_type_length_mismatch_warn , "Trying to fetch %s with length %d" , descr , length ) ;
}
if ( is_error ) {
THROW ( ReportedBoundsError ) ;
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void scale_and_extend_frame ( const YV12_BUFFER_CONFIG * src , YV12_BUFFER_CONFIG * dst ) {
const int src_w = src -> y_crop_width ;
const int src_h = src -> y_crop_height ;
const int dst_w = dst -> y_crop_width ;
const int dst_h = dst -> y_crop_height ;
const uint8_t * const srcs [ 3 ] = {
src -> y_buffer , src -> u_buffer , src -> v_buffer }
;
const int src_strides [ 3 ] = {
src -> y_stride , src -> uv_stride , src -> uv_stride }
;
uint8_t * const dsts [ 3 ] = {
dst -> y_buffer , dst -> u_buffer , dst -> v_buffer }
;
const int dst_strides [ 3 ] = {
dst -> y_stride , dst -> uv_stride , dst -> uv_stride }
;
const InterpKernel * const kernel = vp9_get_interp_kernel ( EIGHTTAP ) ;
int x , y , i ;
for ( y = 0 ;
y < dst_h ;
y += 16 ) {
for ( x = 0 ;
x < dst_w ;
x += 16 ) {
for ( i = 0 ;
i < MAX_MB_PLANE ;
++ i ) {
const int factor = ( i == 0 || i == 3 ? 1 : 2 ) ;
const int x_q4 = x * ( 16 / factor ) * src_w / dst_w ;
const int y_q4 = y * ( 16 / factor ) * src_h / dst_h ;
const int src_stride = src_strides [ i ] ;
const int dst_stride = dst_strides [ i ] ;
const uint8_t * src_ptr = srcs [ i ] + ( y / factor ) * src_h / dst_h * src_stride + ( x / factor ) * src_w / dst_w ;
uint8_t * dst_ptr = dsts [ i ] + ( y / factor ) * dst_stride + ( x / factor ) ;
vp9_convolve8 ( src_ptr , src_stride , dst_ptr , dst_stride , kernel [ x_q4 & 0xf ] , 16 * src_w / dst_w , kernel [ y_q4 & 0xf ] , 16 * src_h / dst_h , / factor , 16 / factor ) ;
}
}
}
vp9_extend_frame_borders ( dst ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | TEST_F ( PromoResourceServiceTest , NotificationPromoCompatNoStringsTest ) {
NotificationPromoTest promo_test ;
promo_test . Init ( "{
" " \"ntp_notification_promo\": [" " {
" " \"date\":" " [" " {
" " \"start\":\"3 Aug 1999 9:26:06 GMT\"," " \"end\":\"$1\"" " }
" " ]," " \"grouping\":" " {
" " \"buckets\":1000," " \"segment\":200," " \"increment\":100," " \"increment_frequency\":3600," " \"increment_max\":400" " }
," " \"payload\":" " {
" " \"promo_message_short\":" " \"What do you think of Chrome?\"," " \"days_active\":7," " \"install_age_days\":21" " }
," " \"max_views\":30" " }
" " ]" "}
" , "What do you think of Chrome?" , 933672366 , 1000 , 200 , 100 , 3600 , 400 , 30 ) ;
promo_test . InitPromoFromJson ( true ) ;
promo_test . InitPromoFromJson ( false ) ;
promo_test . TestInitFromPrefs ( ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void printAt ( UBreakIterator * boundary , int32_t pos , UChar * str ) {
int32_t start ;
int32_t end = ubrk_following ( boundary , pos ) ;
start = ubrk_previous ( boundary ) ;
printTextRange ( str , start , end ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void pxa2xx_rtc_sysbus_class_init ( ObjectClass * klass , void * data ) {
DeviceClass * dc = DEVICE_CLASS ( klass ) ;
SysBusDeviceClass * k = SYS_BUS_DEVICE_CLASS ( klass ) ;
k -> init = pxa2xx_rtc_init ;
dc -> desc = "PXA2xx RTC Controller" ;
dc -> vmsd = & vmstate_pxa2xx_rtc_regs ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | EVP_PKEY * d2i_PrivateKey_bio ( BIO * bp , EVP_PKEY * * a ) {
return ASN1_d2i_bio_of ( EVP_PKEY , EVP_PKEY_new , d2i_AutoPrivateKey , bp , a ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | void vp9_build_inter_predictors_sbuv ( MACROBLOCKD * xd , int mi_row , int mi_col , BLOCK_SIZE bsize ) {
build_inter_predictors_for_planes ( xd , bsize , mi_row , mi_col , 1 , MAX_MB_PLANE - 1 ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static bool SetEncChromaFormat ( encoder_t * p_enc , uint32_t i_codec ) {
encoder_sys_t * p_sys = p_enc -> p_sys ;
switch ( i_codec ) {
case VLC_CODEC_I420 : p_enc -> fmt_in . i_codec = i_codec ;
p_enc -> fmt_in . video . i_bits_per_pixel = 12 ;
p_sys -> p_format -> chroma_format = SCHRO_CHROMA_420 ;
break ;
case VLC_CODEC_I422 : p_enc -> fmt_in . i_codec = i_codec ;
p_enc -> fmt_in . video . i_bits_per_pixel = 16 ;
p_sys -> p_format -> chroma_format = SCHRO_CHROMA_422 ;
break ;
case VLC_CODEC_I444 : p_enc -> fmt_in . i_codec = i_codec ;
p_enc -> fmt_in . video . i_bits_per_pixel = 24 ;
p_sys -> p_format -> chroma_format = SCHRO_CHROMA_444 ;
break ;
default : return false ;
}
return true ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static UBool prepareReorder ( const UBiDiLevel * levels , int32_t length , int32_t * indexMap , UBiDiLevel * pMinLevel , UBiDiLevel * pMaxLevel ) {
int32_t start ;
UBiDiLevel level , minLevel , maxLevel ;
if ( levels == NULL || length <= 0 ) {
return FALSE ;
}
minLevel = UBIDI_MAX_EXPLICIT_LEVEL + 1 ;
maxLevel = 0 ;
for ( start = length ;
start > 0 ;
) {
level = levels [ -- start ] ;
if ( level > UBIDI_MAX_EXPLICIT_LEVEL + 1 ) {
return FALSE ;
}
if ( level < minLevel ) {
minLevel = level ;
}
if ( level > maxLevel ) {
maxLevel = level ;
}
}
* pMinLevel = minLevel ;
* pMaxLevel = maxLevel ;
for ( start = length ;
start > 0 ;
) {
-- start ;
indexMap [ start ] = start ;
}
return TRUE ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int get_sha1_hex_from_objpath ( const char * path , unsigned char * sha1 ) {
char hex [ 40 ] ;
if ( strlen ( path ) != 41 ) return - 1 ;
memcpy ( hex , path , 2 ) ;
path += 2 ;
path ++ ;
memcpy ( hex , path , 38 ) ;
return get_sha1_hex ( hex , sha1 ) ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static int hfinfo_mask_bitwidth ( const header_field_info * hfinfo ) {
if ( ! hfinfo -> bitmask ) {
return 0 ;
}
return ws_ilog2 ( hfinfo -> bitmask ) - ws_ctz ( hfinfo -> bitmask ) + 1 ;
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static void update_stats ( VP9_COMMON * cm , const MACROBLOCK * x ) {
const MACROBLOCKD * const xd = & x -> e_mbd ;
const MODE_INFO * const mi = xd -> mi [ 0 ] . src_mi ;
const MB_MODE_INFO * const mbmi = & mi -> mbmi ;
if ( ! frame_is_intra_only ( cm ) ) {
const int seg_ref_active = vp9_segfeature_active ( & cm -> seg , mbmi -> segment_id , SEG_LVL_REF_FRAME ) ;
if ( ! seg_ref_active ) {
FRAME_COUNTS * const counts = & cm -> counts ;
const int inter_block = is_inter_block ( mbmi ) ;
counts -> intra_inter [ vp9_get_intra_inter_context ( xd ) ] [ inter_block ] ++ ;
if ( inter_block ) {
const MV_REFERENCE_FRAME ref0 = mbmi -> ref_frame [ 0 ] ;
if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) counts -> comp_inter [ vp9_get_reference_mode_context ( cm , xd ) ] [ has_second_ref ( mbmi ) ] ++ ;
if ( has_second_ref ( mbmi ) ) {
counts -> comp_ref [ vp9_get_pred_context_comp_ref_p ( cm , xd ) ] [ ref0 == GOLDEN_FRAME ] ++ ;
}
else {
counts -> single_ref [ vp9_get_pred_context_single_ref_p1 ( xd ) ] [ 0 ] [ ref0 != LAST_FRAME ] ++ ;
if ( ref0 != LAST_FRAME ) counts -> single_ref [ vp9_get_pred_context_single_ref_p2 ( xd ) ] [ 1 ] [ ref0 != GOLDEN_FRAME ] ++ ;
}
}
}
}
} | 0False
|
Categorize the following code snippet as vulnerable or not. True or False | static __always_inline __u64 __be64_to_cpup ( const __be64 * p ) {
return __swab64p ( ( __u64 * ) p ) ;
} | 1True
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.